rafaelcaricio/gstreamer-rs
1
0
Fork 0
forked from mirrors/gstreamer-rs
Code Pull requests Activity

Run rustfmt also over all the generated code

Browse source
This commit is contained in:
Sebastian Dröge 2019-06-18 13:12:00 +03:00
parent e5aa6f59f9
commit b87ffa17bb
175 changed files with 13469 additions and 4587 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

231
gstreamer-app/src/auto/app_sink.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -28,62 +28,63 @@ impl AppSink {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
pub fn get_buffer_list_support(&self) -> bool { pub fn get_buffer_list_support(&self) -> bool {
unsafe { unsafe {
from_glib(gst_app_sys::gst_app_sink_get_buffer_list_support(self.to_glib_none().0)) from_glib(gst_app_sys::gst_app_sink_get_buffer_list_support(
self.to_glib_none().0,
))
} }
} }
pub fn get_caps(&self) -> Option<gst::Caps> { pub fn get_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe { from_glib_full(gst_app_sys::gst_app_sink_get_caps(self.to_glib_none().0)) }
from_glib_full(gst_app_sys::gst_app_sink_get_caps(self.to_glib_none().0))
}
} }
pub fn get_drop(&self) -> bool { pub fn get_drop(&self) -> bool {
unsafe { unsafe { from_glib(gst_app_sys::gst_app_sink_get_drop(self.to_glib_none().0)) }
from_glib(gst_app_sys::gst_app_sink_get_drop(self.to_glib_none().0))
}
} }
pub fn get_emit_signals(&self) -> bool { pub fn get_emit_signals(&self) -> bool {
unsafe { unsafe {
from_glib(gst_app_sys::gst_app_sink_get_emit_signals(self.to_glib_none().0)) from_glib(gst_app_sys::gst_app_sink_get_emit_signals(
self.to_glib_none().0,
))
} }
} }
pub fn get_max_buffers(&self) -> u32 { pub fn get_max_buffers(&self) -> u32 {
unsafe { unsafe { gst_app_sys::gst_app_sink_get_max_buffers(self.to_glib_none().0) }
gst_app_sys::gst_app_sink_get_max_buffers(self.to_glib_none().0)
}
} }
pub fn get_wait_on_eos(&self) -> bool { pub fn get_wait_on_eos(&self) -> bool {
unsafe { unsafe {
from_glib(gst_app_sys::gst_app_sink_get_wait_on_eos(self.to_glib_none().0)) from_glib(gst_app_sys::gst_app_sink_get_wait_on_eos(
self.to_glib_none().0,
))
} }
} }
pub fn is_eos(&self) -> bool { pub fn is_eos(&self) -> bool {
unsafe { unsafe { from_glib(gst_app_sys::gst_app_sink_is_eos(self.to_glib_none().0)) }
from_glib(gst_app_sys::gst_app_sink_is_eos(self.to_glib_none().0))
}
} }
pub fn pull_preroll(&self) -> Option<gst::Sample> { pub fn pull_preroll(&self) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(gst_app_sys::gst_app_sink_pull_preroll(self.to_glib_none().0)) from_glib_full(gst_app_sys::gst_app_sink_pull_preroll(
self.to_glib_none().0,
))
} }
} }
pub fn pull_sample(&self) -> Option<gst::Sample> { pub fn pull_sample(&self) -> Option<gst::Sample> {
unsafe { unsafe { from_glib_full(gst_app_sys::gst_app_sink_pull_sample(self.to_glib_none().0)) }
from_glib_full(gst_app_sys::gst_app_sink_pull_sample(self.to_glib_none().0))
}
} }
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
pub fn set_buffer_list_support(&self, enable_lists: bool) { pub fn set_buffer_list_support(&self, enable_lists: bool) {
unsafe { unsafe {
gst_app_sys::gst_app_sink_set_buffer_list_support(self.to_glib_none().0, enable_lists.to_glib()); gst_app_sys::gst_app_sink_set_buffer_list_support(
self.to_glib_none().0,
enable_lists.to_glib(),
);
} }
} }
@ -124,132 +125,242 @@ impl AppSink {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn try_pull_preroll(&self, timeout: gst::ClockTime) -> Option<gst::Sample> { pub fn try_pull_preroll(&self, timeout: gst::ClockTime) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(gst_app_sys::gst_app_sink_try_pull_preroll(self.to_glib_none().0, timeout.to_glib())) from_glib_full(gst_app_sys::gst_app_sink_try_pull_preroll(
self.to_glib_none().0,
timeout.to_glib(),
))
} }
} }
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn try_pull_sample(&self, timeout: gst::ClockTime) -> Option<gst::Sample> { pub fn try_pull_sample(&self, timeout: gst::ClockTime) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(gst_app_sys::gst_app_sink_try_pull_sample(self.to_glib_none().0, timeout.to_glib())) from_glib_full(gst_app_sys::gst_app_sink_try_pull_sample(
self.to_glib_none().0,
timeout.to_glib(),
))
} }
} }
pub fn get_property_buffer_list(&self) -> bool { pub fn get_property_buffer_list(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"buffer-list\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"buffer-list\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_buffer_list(&self, buffer_list: bool) { pub fn set_property_buffer_list(&self, buffer_list: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"buffer-list\0".as_ptr() as *const _, Value::from(&buffer_list).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"buffer-list\0".as_ptr() as *const _,
Value::from(&buffer_list).to_glib_none().0,
);
} }
} }
pub fn get_property_eos(&self) -> bool { pub fn get_property_eos(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"eos\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"eos\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn connect_eos<F: Fn(&AppSink) + Send + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_eos<F: Fn(&AppSink) + Send + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn eos_trampoline<F: Fn(&AppSink) + Send + 'static>(this: *mut gst_app_sys::GstAppSink, f: glib_sys::gpointer) { unsafe extern "C" fn eos_trampoline<F: Fn(&AppSink) + Send + 'static>(
this: *mut gst_app_sys::GstAppSink,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"eos\0".as_ptr() as *const _, connect_raw(
Some(transmute(eos_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"eos\0".as_ptr() as *const _,
Some(transmute(eos_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_buffer_list_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_buffer_list_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_buffer_list_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_buffer_list_trampoline<
F: Fn(&AppSink) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::buffer-list\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_buffer_list_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::buffer-list\0".as_ptr() as *const _,
Some(transmute(notify_buffer_list_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_caps_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_caps_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_caps_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::caps\0".as_ptr() as *const _,
Some(transmute(notify_caps_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_drop_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_drop_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_drop_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_drop_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::drop\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_drop_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::drop\0".as_ptr() as *const _,
Some(transmute(notify_drop_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_emit_signals_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_emit_signals_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<
F: Fn(&AppSink) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_emit_signals_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::emit-signals\0".as_ptr() as *const _,
Some(transmute(notify_emit_signals_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::eos\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_eos_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::eos\0".as_ptr() as *const _,
Some(transmute(notify_eos_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_max_buffers_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_buffers_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_max_buffers_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_buffers_trampoline<
F: Fn(&AppSink) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-buffers\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_buffers_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-buffers\0".as_ptr() as *const _,
Some(transmute(notify_max_buffers_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_wait_on_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_wait_on_eos_notify<F: Fn(&AppSink) + Send + Sync + 'static>(
unsafe extern "C" fn notify_wait_on_eos_trampoline<F: Fn(&AppSink) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_wait_on_eos_trampoline<
F: Fn(&AppSink) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::wait-on-eos\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_wait_on_eos_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::wait-on-eos\0".as_ptr() as *const _,
Some(transmute(notify_wait_on_eos_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

441
gstreamer-app/src/auto/app_src.rs
View file

@ -2,13 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use AppStreamType; use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -17,6 +16,7 @@ use gst_base;
use libc; use libc;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use AppStreamType;
glib_wrapper! { glib_wrapper! {
pub struct AppSrc(Object<gst_app_sys::GstAppSrc, gst_app_sys::GstAppSrcClass, AppSrcClass>) @extends gst_base::BaseSrc, gst::Element, gst::Object, @implements gst::URIHandler; pub struct AppSrc(Object<gst_app_sys::GstAppSrc, gst_app_sys::GstAppSrcClass, AppSrcClass>) @extends gst_base::BaseSrc, gst::Element, gst::Object, @implements gst::URIHandler;
@ -28,45 +28,39 @@ glib_wrapper! {
impl AppSrc { impl AppSrc {
pub fn get_caps(&self) -> Option<gst::Caps> { pub fn get_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe { from_glib_full(gst_app_sys::gst_app_src_get_caps(self.to_glib_none().0)) }
from_glib_full(gst_app_sys::gst_app_src_get_caps(self.to_glib_none().0))
}
} }
pub fn get_current_level_bytes(&self) -> u64 { pub fn get_current_level_bytes(&self) -> u64 {
unsafe { unsafe { gst_app_sys::gst_app_src_get_current_level_bytes(self.to_glib_none().0) }
gst_app_sys::gst_app_src_get_current_level_bytes(self.to_glib_none().0)
}
} }
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn get_duration(&self) -> gst::ClockTime { pub fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe { from_glib(gst_app_sys::gst_app_src_get_duration(self.to_glib_none().0)) }
from_glib(gst_app_sys::gst_app_src_get_duration(self.to_glib_none().0))
}
} }
pub fn get_emit_signals(&self) -> bool { pub fn get_emit_signals(&self) -> bool {
unsafe { unsafe {
from_glib(gst_app_sys::gst_app_src_get_emit_signals(self.to_glib_none().0)) from_glib(gst_app_sys::gst_app_src_get_emit_signals(
self.to_glib_none().0,
))
} }
} }
pub fn get_max_bytes(&self) -> u64 { pub fn get_max_bytes(&self) -> u64 {
unsafe { unsafe { gst_app_sys::gst_app_src_get_max_bytes(self.to_glib_none().0) }
gst_app_sys::gst_app_src_get_max_bytes(self.to_glib_none().0)
}
} }
pub fn get_size(&self) -> i64 { pub fn get_size(&self) -> i64 {
unsafe { unsafe { gst_app_sys::gst_app_src_get_size(self.to_glib_none().0) }
gst_app_sys::gst_app_src_get_size(self.to_glib_none().0)
}
} }
pub fn get_stream_type(&self) -> AppStreamType { pub fn get_stream_type(&self) -> AppStreamType {
unsafe { unsafe {
from_glib(gst_app_sys::gst_app_src_get_stream_type(self.to_glib_none().0)) from_glib(gst_app_sys::gst_app_src_get_stream_type(
self.to_glib_none().0,
))
} }
} }
@ -114,290 +108,537 @@ impl AppSrc {
pub fn get_property_block(&self) -> bool { pub fn get_property_block(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"block\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"block\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_block(&self, block: bool) { pub fn set_property_block(&self, block: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"block\0".as_ptr() as *const _, Value::from(&block).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"block\0".as_ptr() as *const _,
Value::from(&block).to_glib_none().0,
);
} }
} }
pub fn get_property_duration(&self) -> u64 { pub fn get_property_duration(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_duration(&self, duration: u64) { pub fn set_property_duration(&self, duration: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, Value::from(&duration).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
Value::from(&duration).to_glib_none().0,
);
} }
} }
pub fn get_property_format(&self) -> gst::Format { pub fn get_property_format(&self) -> gst::Format {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Format as StaticType>::static_type()); let mut value = Value::from_type(<gst::Format as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"format\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"format\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_format(&self, format: gst::Format) { pub fn set_property_format(&self, format: gst::Format) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"format\0".as_ptr() as *const _, Value::from(&format).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"format\0".as_ptr() as *const _,
Value::from(&format).to_glib_none().0,
);
} }
} }
pub fn get_property_is_live(&self) -> bool { pub fn get_property_is_live(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"is-live\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"is-live\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_is_live(&self, is_live: bool) { pub fn set_property_is_live(&self, is_live: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"is-live\0".as_ptr() as *const _, Value::from(&is_live).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"is-live\0".as_ptr() as *const _,
Value::from(&is_live).to_glib_none().0,
);
} }
} }
pub fn get_property_max_latency(&self) -> i64 { pub fn get_property_max_latency(&self) -> i64 {
unsafe { unsafe {
let mut value = Value::from_type(<i64 as StaticType>::static_type()); let mut value = Value::from_type(<i64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"max-latency\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"max-latency\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_max_latency(&self, max_latency: i64) { pub fn set_property_max_latency(&self, max_latency: i64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"max-latency\0".as_ptr() as *const _, Value::from(&max_latency).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"max-latency\0".as_ptr() as *const _,
Value::from(&max_latency).to_glib_none().0,
);
} }
} }
pub fn get_property_min_latency(&self) -> i64 { pub fn get_property_min_latency(&self) -> i64 {
unsafe { unsafe {
let mut value = Value::from_type(<i64 as StaticType>::static_type()); let mut value = Value::from_type(<i64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"min-latency\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"min-latency\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_min_latency(&self, min_latency: i64) { pub fn set_property_min_latency(&self, min_latency: i64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"min-latency\0".as_ptr() as *const _, Value::from(&min_latency).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"min-latency\0".as_ptr() as *const _,
Value::from(&min_latency).to_glib_none().0,
);
} }
} }
pub fn get_property_min_percent(&self) -> u32 { pub fn get_property_min_percent(&self) -> u32 {
unsafe { unsafe {
let mut value = Value::from_type(<u32 as StaticType>::static_type()); let mut value = Value::from_type(<u32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"min-percent\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"min-percent\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_min_percent(&self, min_percent: u32) { pub fn set_property_min_percent(&self, min_percent: u32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"min-percent\0".as_ptr() as *const _, Value::from(&min_percent).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"min-percent\0".as_ptr() as *const _,
Value::from(&min_percent).to_glib_none().0,
);
} }
} }
pub fn connect_enough_data<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_enough_data<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn enough_data_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn enough_data_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"enough-data\0".as_ptr() as *const _, connect_raw(
Some(transmute(enough_data_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"enough-data\0".as_ptr() as *const _,
Some(transmute(enough_data_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_need_data<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_need_data<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(
unsafe extern "C" fn need_data_trampoline<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, length: libc::c_uint, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn need_data_trampoline<F: Fn(&AppSrc, u32) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
length: libc::c_uint,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), length) f(&from_glib_borrow(this), length)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"need-data\0".as_ptr() as *const _, connect_raw(
Some(transmute(need_data_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"need-data\0".as_ptr() as *const _,
Some(transmute(need_data_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_seek_data<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_seek_data<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(
unsafe extern "C" fn seek_data_trampoline<F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, offset: u64, f: glib_sys::gpointer) -> glib_sys::gboolean { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn seek_data_trampoline<
F: Fn(&AppSrc, u64) -> bool + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
offset: u64,
f: glib_sys::gpointer,
) -> glib_sys::gboolean {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), offset).to_glib() f(&from_glib_borrow(this), offset).to_glib()
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"seek-data\0".as_ptr() as *const _, connect_raw(
Some(transmute(seek_data_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"seek-data\0".as_ptr() as *const _,
Some(transmute(seek_data_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_block_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_block_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_block_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_block_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::block\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_block_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::block\0".as_ptr() as *const _,
Some(transmute(notify_block_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_caps_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_caps_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_caps_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::caps\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_caps_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::caps\0".as_ptr() as *const _,
Some(transmute(notify_caps_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_current_level_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_current_level_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_current_level_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_current_level_bytes_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::current-level-bytes\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_current_level_bytes_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::current-level-bytes\0".as_ptr() as *const _,
Some(transmute(
notify_current_level_bytes_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_duration_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_duration_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_emit_signals_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_emit_signals_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_emit_signals_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_emit_signals_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::emit-signals\0".as_ptr() as *const _,
Some(transmute(notify_emit_signals_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_format_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_format_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_format_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_format_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::format\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_format_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::format\0".as_ptr() as *const _,
Some(transmute(notify_format_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_is_live_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_is_live_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_is_live_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_is_live_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::is-live\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_is_live_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::is-live\0".as_ptr() as *const _,
Some(transmute(notify_is_live_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_max_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_bytes_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_max_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_bytes_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-bytes\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_bytes_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-bytes\0".as_ptr() as *const _,
Some(transmute(notify_max_bytes_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_max_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_max_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_max_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_latency_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-latency\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_latency_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-latency\0".as_ptr() as *const _,
Some(transmute(notify_max_latency_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_min_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_min_latency_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_min_latency_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_min_latency_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::min-latency\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_min_latency_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::min-latency\0".as_ptr() as *const _,
Some(transmute(notify_min_latency_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_min_percent_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_min_percent_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_min_percent_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_min_percent_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::min-percent\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_min_percent_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::min-percent\0".as_ptr() as *const _,
Some(transmute(notify_min_percent_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_size_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_size_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_size_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_size_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::size\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_size_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::size\0".as_ptr() as *const _,
Some(transmute(notify_size_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_stream_type_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_stream_type_notify<F: Fn(&AppSrc) + Send + Sync + 'static>(
unsafe extern "C" fn notify_stream_type_trampoline<F: Fn(&AppSrc) + Send + Sync + 'static>(this: *mut gst_app_sys::GstAppSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_stream_type_trampoline<
F: Fn(&AppSrc) + Send + Sync + 'static,
>(
this: *mut gst_app_sys::GstAppSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::stream-type\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_stream_type_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::stream-type\0".as_ptr() as *const _,
Some(transmute(notify_stream_type_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

10
gstreamer-app/src/auto/enums.rs
View file

@ -2,18 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_app_sys; use gst_app_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum AppStreamType { pub enum AppStreamType {
Stream, Stream,
Seekable, Seekable,
@ -31,7 +30,7 @@ impl ToGlib for AppStreamType {
AppStreamType::Stream => gst_app_sys::GST_APP_STREAM_TYPE_STREAM, AppStreamType::Stream => gst_app_sys::GST_APP_STREAM_TYPE_STREAM,
AppStreamType::Seekable => gst_app_sys::GST_APP_STREAM_TYPE_SEEKABLE, AppStreamType::Seekable => gst_app_sys::GST_APP_STREAM_TYPE_SEEKABLE,
AppStreamType::RandomAccess => gst_app_sys::GST_APP_STREAM_TYPE_RANDOM_ACCESS, AppStreamType::RandomAccess => gst_app_sys::GST_APP_STREAM_TYPE_RANDOM_ACCESS,
AppStreamType::__Unknown(value) => value AppStreamType::__Unknown(value) => value,
} }
} }
} }
@ -72,4 +71,3 @@ impl SetValue for AppStreamType {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
} }
} }

3
gstreamer-app/src/auto/mod.rs
View file

@ -12,5 +12,4 @@ mod enums;
pub use self::enums::AppStreamType; pub use self::enums::AppStreamType;
#[doc(hidden)] #[doc(hidden)]
pub mod traits { pub mod traits {}
}

1
gstreamer-app/src/lib.rs
View file

@ -27,7 +27,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::unreadable_literal)] #[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

46
gstreamer-audio/src/auto/audio_stream_align.rs
View file

@ -21,45 +21,63 @@ glib_wrapper! {
impl AudioStreamAlign { impl AudioStreamAlign {
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn new(rate: i32, alignment_threshold: gst::ClockTime, discont_wait: gst::ClockTime) -> AudioStreamAlign { pub fn new(
rate: i32,
alignment_threshold: gst::ClockTime,
discont_wait: gst::ClockTime,
) -> AudioStreamAlign {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_audio_sys::gst_audio_stream_align_new(rate, alignment_threshold.to_glib(), discont_wait.to_glib())) from_glib_full(gst_audio_sys::gst_audio_stream_align_new(
rate,
alignment_threshold.to_glib(),
discont_wait.to_glib(),
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_alignment_threshold(&mut self) -> gst::ClockTime { pub fn get_alignment_threshold(&mut self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_audio_sys::gst_audio_stream_align_get_alignment_threshold(self.to_glib_none_mut().0)) from_glib(
gst_audio_sys::gst_audio_stream_align_get_alignment_threshold(
self.to_glib_none_mut().0,
),
)
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_discont_wait(&mut self) -> gst::ClockTime { pub fn get_discont_wait(&mut self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_audio_sys::gst_audio_stream_align_get_discont_wait(self.to_glib_none_mut().0)) from_glib(gst_audio_sys::gst_audio_stream_align_get_discont_wait(
self.to_glib_none_mut().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_rate(&mut self) -> i32 { pub fn get_rate(&mut self) -> i32 {
unsafe { unsafe { gst_audio_sys::gst_audio_stream_align_get_rate(self.to_glib_none_mut().0) }
gst_audio_sys::gst_audio_stream_align_get_rate(self.to_glib_none_mut().0)
}
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_samples_since_discont(&mut self) -> u64 { pub fn get_samples_since_discont(&mut self) -> u64 {
unsafe { unsafe {
gst_audio_sys::gst_audio_stream_align_get_samples_since_discont(self.to_glib_none_mut().0) gst_audio_sys::gst_audio_stream_align_get_samples_since_discont(
self.to_glib_none_mut().0,
)
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_timestamp_at_discont(&mut self) -> gst::ClockTime { pub fn get_timestamp_at_discont(&mut self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_audio_sys::gst_audio_stream_align_get_timestamp_at_discont(self.to_glib_none_mut().0)) from_glib(
gst_audio_sys::gst_audio_stream_align_get_timestamp_at_discont(
self.to_glib_none_mut().0,
),
)
} }
} }
@ -73,14 +91,20 @@ impl AudioStreamAlign {
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn set_alignment_threshold(&mut self, alignment_threshold: gst::ClockTime) { pub fn set_alignment_threshold(&mut self, alignment_threshold: gst::ClockTime) {
unsafe { unsafe {
gst_audio_sys::gst_audio_stream_align_set_alignment_threshold(self.to_glib_none_mut().0, alignment_threshold.to_glib()); gst_audio_sys::gst_audio_stream_align_set_alignment_threshold(
self.to_glib_none_mut().0,
alignment_threshold.to_glib(),
);
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn set_discont_wait(&mut self, discont_wait: gst::ClockTime) { pub fn set_discont_wait(&mut self, discont_wait: gst::ClockTime) {
unsafe { unsafe {
gst_audio_sys::gst_audio_stream_align_set_discont_wait(self.to_glib_none_mut().0, discont_wait.to_glib()); gst_audio_sys::gst_audio_stream_align_set_discont_wait(
self.to_glib_none_mut().0,
discont_wait.to_glib(),
);
} }
} }

97
gstreamer-audio/src/auto/enums.rs
View file

@ -2,18 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_audio_sys; use gst_audio_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum AudioChannelPosition { pub enum AudioChannelPosition {
None, None,
Mono, Mono,
@ -60,34 +59,70 @@ impl ToGlib for AudioChannelPosition {
AudioChannelPosition::Mono => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_MONO, AudioChannelPosition::Mono => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_MONO,
AudioChannelPosition::Invalid => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_INVALID, AudioChannelPosition::Invalid => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_INVALID,
AudioChannelPosition::FrontLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT, AudioChannelPosition::FrontLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
AudioChannelPosition::FrontRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT, AudioChannelPosition::FrontRight => {
AudioChannelPosition::FrontCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT
}
AudioChannelPosition::FrontCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER
}
AudioChannelPosition::Lfe1 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE1, AudioChannelPosition::Lfe1 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE1,
AudioChannelPosition::RearLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_LEFT, AudioChannelPosition::RearLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
AudioChannelPosition::RearRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT, AudioChannelPosition::RearRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
AudioChannelPosition::FrontLeftOfCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER, AudioChannelPosition::FrontLeftOfCenter => {
AudioChannelPosition::FrontRightOfCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
AudioChannelPosition::RearCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_CENTER, }
AudioChannelPosition::FrontRightOfCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
}
AudioChannelPosition::RearCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_REAR_CENTER
}
AudioChannelPosition::Lfe2 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE2, AudioChannelPosition::Lfe2 => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_LFE2,
AudioChannelPosition::SideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT, AudioChannelPosition::SideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
AudioChannelPosition::SideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT, AudioChannelPosition::SideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT,
AudioChannelPosition::TopFrontLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT, AudioChannelPosition::TopFrontLeft => {
AudioChannelPosition::TopFrontRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_LEFT
AudioChannelPosition::TopFrontCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER, }
AudioChannelPosition::TopFrontRight => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_RIGHT
}
AudioChannelPosition::TopFrontCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_FRONT_CENTER
}
AudioChannelPosition::TopCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_CENTER, AudioChannelPosition::TopCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_CENTER,
AudioChannelPosition::TopRearLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT, AudioChannelPosition::TopRearLeft => {
AudioChannelPosition::TopRearRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_LEFT
AudioChannelPosition::TopSideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT, }
AudioChannelPosition::TopSideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT, AudioChannelPosition::TopRearRight => {
AudioChannelPosition::TopRearCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_RIGHT
AudioChannelPosition::BottomFrontCenter => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER, }
AudioChannelPosition::BottomFrontLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT, AudioChannelPosition::TopSideLeft => {
AudioChannelPosition::BottomFrontRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_LEFT
}
AudioChannelPosition::TopSideRight => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_SIDE_RIGHT
}
AudioChannelPosition::TopRearCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_TOP_REAR_CENTER
}
AudioChannelPosition::BottomFrontCenter => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_CENTER
}
AudioChannelPosition::BottomFrontLeft => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_LEFT
}
AudioChannelPosition::BottomFrontRight => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_BOTTOM_FRONT_RIGHT
}
AudioChannelPosition::WideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_LEFT, AudioChannelPosition::WideLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_LEFT,
AudioChannelPosition::WideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_RIGHT, AudioChannelPosition::WideRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_WIDE_RIGHT,
AudioChannelPosition::SurroundLeft => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_LEFT, AudioChannelPosition::SurroundLeft => {
AudioChannelPosition::SurroundRight => gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_RIGHT, gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_LEFT
AudioChannelPosition::__Unknown(value) => value }
AudioChannelPosition::SurroundRight => {
gst_audio_sys::GST_AUDIO_CHANNEL_POSITION_SURROUND_RIGHT
}
AudioChannelPosition::__Unknown(value) => value,
} }
} }
} }
@ -157,8 +192,7 @@ impl SetValue for AudioChannelPosition {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum AudioFormat { pub enum AudioFormat {
Unknown, Unknown,
Encoded, Encoded,
@ -234,7 +268,7 @@ impl ToGlib for AudioFormat {
AudioFormat::F32be => gst_audio_sys::GST_AUDIO_FORMAT_F32BE, AudioFormat::F32be => gst_audio_sys::GST_AUDIO_FORMAT_F32BE,
AudioFormat::F64le => gst_audio_sys::GST_AUDIO_FORMAT_F64LE, AudioFormat::F64le => gst_audio_sys::GST_AUDIO_FORMAT_F64LE,
AudioFormat::F64be => gst_audio_sys::GST_AUDIO_FORMAT_F64BE, AudioFormat::F64be => gst_audio_sys::GST_AUDIO_FORMAT_F64BE,
AudioFormat::__Unknown(value) => value AudioFormat::__Unknown(value) => value,
} }
} }
} }
@ -305,8 +339,7 @@ impl SetValue for AudioFormat {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum AudioLayout { pub enum AudioLayout {
Interleaved, Interleaved,
NonInterleaved, NonInterleaved,
@ -322,7 +355,7 @@ impl ToGlib for AudioLayout {
match *self { match *self {
AudioLayout::Interleaved => gst_audio_sys::GST_AUDIO_LAYOUT_INTERLEAVED, AudioLayout::Interleaved => gst_audio_sys::GST_AUDIO_LAYOUT_INTERLEAVED,
AudioLayout::NonInterleaved => gst_audio_sys::GST_AUDIO_LAYOUT_NON_INTERLEAVED, AudioLayout::NonInterleaved => gst_audio_sys::GST_AUDIO_LAYOUT_NON_INTERLEAVED,
AudioLayout::__Unknown(value) => value AudioLayout::__Unknown(value) => value,
} }
} }
} }
@ -363,8 +396,7 @@ impl SetValue for AudioLayout {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum StreamVolumeFormat { pub enum StreamVolumeFormat {
Linear, Linear,
Cubic, Cubic,
@ -382,7 +414,7 @@ impl ToGlib for StreamVolumeFormat {
StreamVolumeFormat::Linear => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_LINEAR, StreamVolumeFormat::Linear => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_LINEAR,
StreamVolumeFormat::Cubic => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_CUBIC, StreamVolumeFormat::Cubic => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_CUBIC,
StreamVolumeFormat::Db => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_DB, StreamVolumeFormat::Db => gst_audio_sys::GST_STREAM_VOLUME_FORMAT_DB,
StreamVolumeFormat::__Unknown(value) => value StreamVolumeFormat::__Unknown(value) => value,
} }
} }
} }
@ -399,4 +431,3 @@ impl FromGlib<gst_audio_sys::GstStreamVolumeFormat> for StreamVolumeFormat {
} }
} }
} }

5
gstreamer-audio/src/auto/flags.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_audio_sys; use gst_audio_sys;
@ -158,4 +158,3 @@ impl SetValue for AudioPackFlags {
gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
} }
} }

2
gstreamer-audio/src/auto/mod.rs
View file

@ -3,8 +3,8 @@
// DO NOT EDIT // DO NOT EDIT
mod stream_volume; mod stream_volume;
pub use self::stream_volume::{StreamVolume, NONE_STREAM_VOLUME};
pub use self::stream_volume::StreamVolumeExt; pub use self::stream_volume::StreamVolumeExt;
pub use self::stream_volume::{StreamVolume, NONE_STREAM_VOLUME};
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
mod audio_stream_align; mod audio_stream_align;

76
gstreamer-audio/src/auto/stream_volume.rs
View file

@ -2,16 +2,16 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use StreamVolumeFormat;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib_sys; use glib_sys;
use gst_audio_sys; use gst_audio_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use StreamVolumeFormat;
glib_wrapper! { glib_wrapper! {
pub struct StreamVolume(Interface<gst_audio_sys::GstStreamVolume>); pub struct StreamVolume(Interface<gst_audio_sys::GstStreamVolume>);
@ -44,61 +44,101 @@ pub trait StreamVolumeExt: 'static {
fn set_volume(&self, format: StreamVolumeFormat, val: f64); fn set_volume(&self, format: StreamVolumeFormat, val: f64);
fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<StreamVolume>> StreamVolumeExt for O { impl<O: IsA<StreamVolume>> StreamVolumeExt for O {
fn get_mute(&self) -> bool { fn get_mute(&self) -> bool {
unsafe { unsafe {
from_glib(gst_audio_sys::gst_stream_volume_get_mute(self.as_ref().to_glib_none().0)) from_glib(gst_audio_sys::gst_stream_volume_get_mute(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_volume(&self, format: StreamVolumeFormat) -> f64 { fn get_volume(&self, format: StreamVolumeFormat) -> f64 {
unsafe { unsafe {
gst_audio_sys::gst_stream_volume_get_volume(self.as_ref().to_glib_none().0, format.to_glib()) gst_audio_sys::gst_stream_volume_get_volume(
self.as_ref().to_glib_none().0,
format.to_glib(),
)
} }
} }
fn set_mute(&self, mute: bool) { fn set_mute(&self, mute: bool) {
unsafe { unsafe {
gst_audio_sys::gst_stream_volume_set_mute(self.as_ref().to_glib_none().0, mute.to_glib()); gst_audio_sys::gst_stream_volume_set_mute(
self.as_ref().to_glib_none().0,
mute.to_glib(),
);
} }
} }
fn set_volume(&self, format: StreamVolumeFormat, val: f64) { fn set_volume(&self, format: StreamVolumeFormat, val: f64) {
unsafe { unsafe {
gst_audio_sys::gst_stream_volume_set_volume(self.as_ref().to_glib_none().0, format.to_glib(), val); gst_audio_sys::gst_stream_volume_set_volume(
self.as_ref().to_glib_none().0,
format.to_glib(),
val,
);
} }
} }
fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mute_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<StreamVolume> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_audio_sys::GstStreamVolume,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<StreamVolume>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast()) f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_mute_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::mute\0".as_ptr() as *const _,
Some(transmute(notify_mute_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_volume_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_volume_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_audio_sys::GstStreamVolume, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<StreamVolume> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_volume_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_audio_sys::GstStreamVolume,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<StreamVolume>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&StreamVolume::from_glib_borrow(this).unsafe_cast()) f(&StreamVolume::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::volume\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_volume_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::volume\0".as_ptr() as *const _,
Some(transmute(notify_volume_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

1
gstreamer-audio/src/lib.rs
View file

@ -35,7 +35,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::unreadable_literal)] #[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

123
gstreamer-base/src/auto/adapter.rs
View file

@ -3,8 +3,8 @@
// DO NOT EDIT // DO NOT EDIT
use glib; use glib;
use glib::ObjectExt;
use glib::translate::*; use glib::translate::*;
use glib::ObjectExt;
use gst; use gst;
use gst_base_sys; use gst_base_sys;
use std::mem; use std::mem;
@ -20,21 +20,15 @@ glib_wrapper! {
impl Adapter { impl Adapter {
pub fn new() -> Adapter { pub fn new() -> Adapter {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_base_sys::gst_adapter_new()) }
from_glib_full(gst_base_sys::gst_adapter_new())
}
} }
pub fn available(&self) -> usize { pub fn available(&self) -> usize {
unsafe { unsafe { gst_base_sys::gst_adapter_available(self.to_glib_none().0) }
gst_base_sys::gst_adapter_available(self.to_glib_none().0)
}
} }
pub fn available_fast(&self) -> usize { pub fn available_fast(&self) -> usize {
unsafe { unsafe { gst_base_sys::gst_adapter_available_fast(self.to_glib_none().0) }
gst_base_sys::gst_adapter_available_fast(self.to_glib_none().0)
}
} }
pub fn clear(&self) { pub fn clear(&self) {
@ -45,20 +39,24 @@ impl Adapter {
pub fn copy_bytes(&self, offset: usize, size: usize) -> Option<glib::Bytes> { pub fn copy_bytes(&self, offset: usize, size: usize) -> Option<glib::Bytes> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_copy_bytes(self.to_glib_none().0, offset, size)) from_glib_full(gst_base_sys::gst_adapter_copy_bytes(
self.to_glib_none().0,
offset,
size,
))
} }
} }
pub fn distance_from_discont(&self) -> u64 { pub fn distance_from_discont(&self) -> u64 {
unsafe { unsafe { gst_base_sys::gst_adapter_distance_from_discont(self.to_glib_none().0) }
gst_base_sys::gst_adapter_distance_from_discont(self.to_glib_none().0)
}
} }
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn dts_at_discont(&self) -> gst::ClockTime { pub fn dts_at_discont(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_adapter_dts_at_discont(self.to_glib_none().0)) from_glib(gst_base_sys::gst_adapter_dts_at_discont(
self.to_glib_none().0,
))
} }
} }
@ -70,53 +68,85 @@ impl Adapter {
pub fn get_buffer(&self, nbytes: usize) -> Option<gst::Buffer> { pub fn get_buffer(&self, nbytes: usize) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_get_buffer(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_get_buffer(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn get_buffer_fast(&self, nbytes: usize) -> Option<gst::Buffer> { pub fn get_buffer_fast(&self, nbytes: usize) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_get_buffer_fast(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_get_buffer_fast(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn get_buffer_list(&self, nbytes: usize) -> Option<gst::BufferList> { pub fn get_buffer_list(&self, nbytes: usize) -> Option<gst::BufferList> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_get_buffer_list(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_get_buffer_list(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn get_list(&self, nbytes: usize) -> Vec<gst::Buffer> { pub fn get_list(&self, nbytes: usize) -> Vec<gst::Buffer> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_base_sys::gst_adapter_get_list(self.to_glib_none().0, nbytes)) FromGlibPtrContainer::from_glib_full(gst_base_sys::gst_adapter_get_list(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn masked_scan_uint32(&self, mask: u32, pattern: u32, offset: usize, size: usize) -> isize { pub fn masked_scan_uint32(&self, mask: u32, pattern: u32, offset: usize, size: usize) -> isize {
unsafe { unsafe {
gst_base_sys::gst_adapter_masked_scan_uint32(self.to_glib_none().0, mask, pattern, offset, size) gst_base_sys::gst_adapter_masked_scan_uint32(
self.to_glib_none().0,
mask,
pattern,
offset,
size,
)
} }
} }
pub fn masked_scan_uint32_peek(&self, mask: u32, pattern: u32, offset: usize, size: usize) -> (isize, u32) { pub fn masked_scan_uint32_peek(
&self,
mask: u32,
pattern: u32,
offset: usize,
size: usize,
) -> (isize, u32) {
unsafe { unsafe {
let mut value = mem::uninitialized(); let mut value = mem::uninitialized();
let ret = gst_base_sys::gst_adapter_masked_scan_uint32_peek(self.to_glib_none().0, mask, pattern, offset, size, &mut value); let ret = gst_base_sys::gst_adapter_masked_scan_uint32_peek(
self.to_glib_none().0,
mask,
pattern,
offset,
size,
&mut value,
);
(ret, value) (ret, value)
} }
} }
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn offset_at_discont(&self) -> u64 { pub fn offset_at_discont(&self) -> u64 {
unsafe { unsafe { gst_base_sys::gst_adapter_offset_at_discont(self.to_glib_none().0) }
gst_base_sys::gst_adapter_offset_at_discont(self.to_glib_none().0)
}
} }
pub fn prev_dts(&self) -> (gst::ClockTime, u64) { pub fn prev_dts(&self) -> (gst::ClockTime, u64) {
unsafe { unsafe {
let mut distance = mem::uninitialized(); let mut distance = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_adapter_prev_dts(self.to_glib_none().0, &mut distance)); let ret = from_glib(gst_base_sys::gst_adapter_prev_dts(
self.to_glib_none().0,
&mut distance,
));
(ret, distance) (ret, distance)
} }
} }
@ -124,7 +154,11 @@ impl Adapter {
pub fn prev_dts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) { pub fn prev_dts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) {
unsafe { unsafe {
let mut distance = mem::uninitialized(); let mut distance = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_adapter_prev_dts_at_offset(self.to_glib_none().0, offset, &mut distance)); let ret = from_glib(gst_base_sys::gst_adapter_prev_dts_at_offset(
self.to_glib_none().0,
offset,
&mut distance,
));
(ret, distance) (ret, distance)
} }
} }
@ -141,7 +175,10 @@ impl Adapter {
pub fn prev_pts(&self) -> (gst::ClockTime, u64) { pub fn prev_pts(&self) -> (gst::ClockTime, u64) {
unsafe { unsafe {
let mut distance = mem::uninitialized(); let mut distance = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_adapter_prev_pts(self.to_glib_none().0, &mut distance)); let ret = from_glib(gst_base_sys::gst_adapter_prev_pts(
self.to_glib_none().0,
&mut distance,
));
(ret, distance) (ret, distance)
} }
} }
@ -149,7 +186,11 @@ impl Adapter {
pub fn prev_pts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) { pub fn prev_pts_at_offset(&self, offset: usize) -> (gst::ClockTime, u64) {
unsafe { unsafe {
let mut distance = mem::uninitialized(); let mut distance = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_adapter_prev_pts_at_offset(self.to_glib_none().0, offset, &mut distance)); let ret = from_glib(gst_base_sys::gst_adapter_prev_pts_at_offset(
self.to_glib_none().0,
offset,
&mut distance,
));
(ret, distance) (ret, distance)
} }
} }
@ -157,31 +198,45 @@ impl Adapter {
#[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg(any(feature = "v1_10", feature = "dox"))]
pub fn pts_at_discont(&self) -> gst::ClockTime { pub fn pts_at_discont(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_adapter_pts_at_discont(self.to_glib_none().0)) from_glib(gst_base_sys::gst_adapter_pts_at_discont(
self.to_glib_none().0,
))
} }
} }
pub fn take_buffer(&self, nbytes: usize) -> Option<gst::Buffer> { pub fn take_buffer(&self, nbytes: usize) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_take_buffer(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_take_buffer(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn take_buffer_fast(&self, nbytes: usize) -> Option<gst::Buffer> { pub fn take_buffer_fast(&self, nbytes: usize) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_take_buffer_fast(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_take_buffer_fast(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn take_buffer_list(&self, nbytes: usize) -> Option<gst::BufferList> { pub fn take_buffer_list(&self, nbytes: usize) -> Option<gst::BufferList> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_adapter_take_buffer_list(self.to_glib_none().0, nbytes)) from_glib_full(gst_base_sys::gst_adapter_take_buffer_list(
self.to_glib_none().0,
nbytes,
))
} }
} }
pub fn take_list(&self, nbytes: usize) -> Vec<gst::Buffer> { pub fn take_list(&self, nbytes: usize) -> Vec<gst::Buffer> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_base_sys::gst_adapter_take_list(self.to_glib_none().0, nbytes)) FromGlibPtrContainer::from_glib_full(gst_base_sys::gst_adapter_take_list(
self.to_glib_none().0,
nbytes,
))
} }
} }
} }

93
gstreamer-base/src/auto/aggregator.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -53,9 +53,15 @@ pub trait AggregatorExt: 'static {
fn set_property_start_time(&self, start_time: u64); fn set_property_start_time(&self, start_time: u64);
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<Aggregator>> AggregatorExt for O { impl<O: IsA<Aggregator>> AggregatorExt for O {
@ -67,78 +73,121 @@ impl<O: IsA<Aggregator>> AggregatorExt for O {
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn get_buffer_pool(&self) -> Option<gst::BufferPool> { fn get_buffer_pool(&self) -> Option<gst::BufferPool> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_aggregator_get_buffer_pool(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_aggregator_get_buffer_pool(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn get_latency(&self) -> gst::ClockTime { fn get_latency(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_aggregator_get_latency(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_aggregator_get_latency(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) { fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
unsafe { unsafe {
gst_base_sys::gst_aggregator_set_latency(self.as_ref().to_glib_none().0, min_latency.to_glib(), max_latency.to_glib()); gst_base_sys::gst_aggregator_set_latency(
self.as_ref().to_glib_none().0,
min_latency.to_glib(),
max_latency.to_glib(),
);
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn set_src_caps(&self, caps: &gst::Caps) { fn set_src_caps(&self, caps: &gst::Caps) {
unsafe { unsafe {
gst_base_sys::gst_aggregator_set_src_caps(self.as_ref().to_glib_none().0, caps.to_glib_none().0); gst_base_sys::gst_aggregator_set_src_caps(
self.as_ref().to_glib_none().0,
caps.to_glib_none().0,
);
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn simple_get_next_time(&self) -> gst::ClockTime { fn simple_get_next_time(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_aggregator_simple_get_next_time(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_aggregator_simple_get_next_time(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_property_start_time(&self) -> u64 { fn get_property_start_time(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"start-time\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"start-time\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_start_time(&self, start_time: u64) { fn set_property_start_time(&self, start_time: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"start-time\0".as_ptr() as *const _, Value::from(&start_time).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"start-time\0".as_ptr() as *const _,
Value::from(&start_time).to_glib_none().0,
);
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_latency_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Aggregator> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_latency_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstAggregator,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Aggregator>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast()) f(&Aggregator::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::latency\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_latency_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::latency\0".as_ptr() as *const _,
Some(transmute(notify_latency_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_start_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregator, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Aggregator> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_start_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstAggregator,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Aggregator>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Aggregator::from_glib_borrow(this).unsafe_cast()) f(&Aggregator::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start-time\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_start_time_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::start-time\0".as_ptr() as *const _,
Some(transmute(notify_start_time_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

104
gstreamer-base/src/auto/aggregator_pad.rs
View file

@ -2,15 +2,15 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::StaticType; use glib::StaticType;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::Value; use glib::Value;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use gobject_sys; use gobject_sys;
@ -55,45 +55,61 @@ pub trait AggregatorPadExt: 'static {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn set_property_emit_signals(&self, emit_signals: bool); fn set_property_emit_signals(&self, emit_signals: bool);
fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<AggregatorPad>> AggregatorPadExt for O { impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn drop_buffer(&self) -> bool { fn drop_buffer(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_aggregator_pad_drop_buffer(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_aggregator_pad_drop_buffer(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14_1", feature = "dox"))] #[cfg(any(feature = "v1_14_1", feature = "dox"))]
fn has_buffer(&self) -> bool { fn has_buffer(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_aggregator_pad_has_buffer(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_aggregator_pad_has_buffer(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn is_eos(&self) -> bool { fn is_eos(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_aggregator_pad_is_eos(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_aggregator_pad_is_eos(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn peek_buffer(&self) -> Option<gst::Buffer> { fn peek_buffer(&self) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_aggregator_pad_peek_buffer(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_aggregator_pad_peek_buffer(
self.as_ref().to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
fn pop_buffer(&self) -> Option<gst::Buffer> { fn pop_buffer(&self) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_aggregator_pad_pop_buffer(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_aggregator_pad_pop_buffer(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -101,7 +117,11 @@ impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
fn get_property_emit_signals(&self) -> bool { fn get_property_emit_signals(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"emit-signals\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"emit-signals\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -109,36 +129,70 @@ impl<O: IsA<AggregatorPad>> AggregatorPadExt for O {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn set_property_emit_signals(&self, emit_signals: bool) { fn set_property_emit_signals(&self, emit_signals: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"emit-signals\0".as_ptr() as *const _, Value::from(&emit_signals).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"emit-signals\0".as_ptr() as *const _,
Value::from(&emit_signals).to_glib_none().0,
);
} }
} }
fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_buffer_consumed<F: Fn(&Self, &gst::Buffer) + Send + Sync + 'static>(
unsafe extern "C" fn buffer_consumed_trampoline<P, F: Fn(&P, &gst::Buffer) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, object: *mut gst_sys::GstBuffer, f: glib_sys::gpointer) &self,
where P: IsA<AggregatorPad> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn buffer_consumed_trampoline<
P,
F: Fn(&P, &gst::Buffer) + Send + Sync + 'static,
>(
this: *mut gst_base_sys::GstAggregatorPad,
object: *mut gst_sys::GstBuffer,
f: glib_sys::gpointer,
) where
P: IsA<AggregatorPad>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(object)) f(
&AggregatorPad::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(object),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"buffer-consumed\0".as_ptr() as *const _, connect_raw(
Some(transmute(buffer_consumed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"buffer-consumed\0".as_ptr() as *const _,
Some(transmute(buffer_consumed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_emit_signals_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_emit_signals_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstAggregatorPad, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<AggregatorPad> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_emit_signals_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstAggregatorPad,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<AggregatorPad>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&AggregatorPad::from_glib_borrow(this).unsafe_cast()) f(&AggregatorPad::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::emit-signals\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_emit_signals_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::emit-signals\0".as_ptr() as *const _,
Some(transmute(
notify_emit_signals_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

104
gstreamer-base/src/auto/base_parse.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -59,13 +59,22 @@ pub trait BaseParseExt: 'static {
fn set_property_disable_passthrough(&self, disable_passthrough: bool); fn set_property_disable_passthrough(&self, disable_passthrough: bool);
fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<BaseParse>> BaseParseExt for O { impl<O: IsA<BaseParse>> BaseParseExt for O {
fn add_index_entry(&self, offset: u64, ts: gst::ClockTime, key: bool, force: bool) -> bool { fn add_index_entry(&self, offset: u64, ts: gst::ClockTime, key: bool, force: bool) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_parse_add_index_entry(self.as_ref().to_glib_none().0, offset, ts.to_glib(), key.to_glib(), force.to_glib())) from_glib(gst_base_sys::gst_base_parse_add_index_entry(
self.as_ref().to_glib_none().0,
offset,
ts.to_glib(),
key.to_glib(),
force.to_glib(),
))
} }
} }
@ -78,55 +87,84 @@ impl<O: IsA<BaseParse>> BaseParseExt for O {
fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode) { fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_merge_tags(self.as_ref().to_glib_none().0, tags.to_glib_none().0, mode.to_glib()); gst_base_sys::gst_base_parse_merge_tags(
self.as_ref().to_glib_none().0,
tags.to_glib_none().0,
mode.to_glib(),
);
} }
} }
fn set_average_bitrate(&self, bitrate: u32) { fn set_average_bitrate(&self, bitrate: u32) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_average_bitrate(self.as_ref().to_glib_none().0, bitrate); gst_base_sys::gst_base_parse_set_average_bitrate(
self.as_ref().to_glib_none().0,
bitrate,
);
} }
} }
fn set_has_timing_info(&self, has_timing: bool) { fn set_has_timing_info(&self, has_timing: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_has_timing_info(self.as_ref().to_glib_none().0, has_timing.to_glib()); gst_base_sys::gst_base_parse_set_has_timing_info(
self.as_ref().to_glib_none().0,
has_timing.to_glib(),
);
} }
} }
fn set_infer_ts(&self, infer_ts: bool) { fn set_infer_ts(&self, infer_ts: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_infer_ts(self.as_ref().to_glib_none().0, infer_ts.to_glib()); gst_base_sys::gst_base_parse_set_infer_ts(
self.as_ref().to_glib_none().0,
infer_ts.to_glib(),
);
} }
} }
fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) { fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_latency(self.as_ref().to_glib_none().0, min_latency.to_glib(), max_latency.to_glib()); gst_base_sys::gst_base_parse_set_latency(
self.as_ref().to_glib_none().0,
min_latency.to_glib(),
max_latency.to_glib(),
);
} }
} }
fn set_min_frame_size(&self, min_size: u32) { fn set_min_frame_size(&self, min_size: u32) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_min_frame_size(self.as_ref().to_glib_none().0, min_size); gst_base_sys::gst_base_parse_set_min_frame_size(
self.as_ref().to_glib_none().0,
min_size,
);
} }
} }
fn set_passthrough(&self, passthrough: bool) { fn set_passthrough(&self, passthrough: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_passthrough(self.as_ref().to_glib_none().0, passthrough.to_glib()); gst_base_sys::gst_base_parse_set_passthrough(
self.as_ref().to_glib_none().0,
passthrough.to_glib(),
);
} }
} }
fn set_pts_interpolation(&self, pts_interpolate: bool) { fn set_pts_interpolation(&self, pts_interpolate: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_pts_interpolation(self.as_ref().to_glib_none().0, pts_interpolate.to_glib()); gst_base_sys::gst_base_parse_set_pts_interpolation(
self.as_ref().to_glib_none().0,
pts_interpolate.to_glib(),
);
} }
} }
fn set_syncable(&self, syncable: bool) { fn set_syncable(&self, syncable: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_parse_set_syncable(self.as_ref().to_glib_none().0, syncable.to_glib()); gst_base_sys::gst_base_parse_set_syncable(
self.as_ref().to_glib_none().0,
syncable.to_glib(),
);
} }
} }
@ -139,28 +177,52 @@ impl<O: IsA<BaseParse>> BaseParseExt for O {
fn get_property_disable_passthrough(&self) -> bool { fn get_property_disable_passthrough(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"disable-passthrough\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"disable-passthrough\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_disable_passthrough(&self, disable_passthrough: bool) { fn set_property_disable_passthrough(&self, disable_passthrough: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"disable-passthrough\0".as_ptr() as *const _, Value::from(&disable_passthrough).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"disable-passthrough\0".as_ptr() as *const _,
Value::from(&disable_passthrough).to_glib_none().0,
);
} }
} }
fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_disable_passthrough_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseParse, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseParse> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_disable_passthrough_trampoline<
P,
F: Fn(&P) + Send + Sync + 'static,
>(
this: *mut gst_base_sys::GstBaseParse,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseParse>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseParse::from_glib_borrow(this).unsafe_cast()) f(&BaseParse::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::disable-passthrough\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_disable_passthrough_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::disable-passthrough\0".as_ptr() as *const _,
Some(transmute(
notify_disable_passthrough_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

491
gstreamer-base/src/auto/base_sink.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -105,30 +105,66 @@ pub trait BaseSinkExt: 'static {
fn set_property_qos(&self, qos: bool); fn set_property_qos(&self, qos: bool);
fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<BaseSink>> BaseSinkExt for O { impl<O: IsA<BaseSink>> BaseSinkExt for O {
@ -137,88 +173,96 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
//} //}
fn get_blocksize(&self) -> u32 { fn get_blocksize(&self) -> u32 {
unsafe { unsafe { gst_base_sys::gst_base_sink_get_blocksize(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_sink_get_blocksize(self.as_ref().to_glib_none().0)
}
} }
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn get_drop_out_of_segment(&self) -> bool { fn get_drop_out_of_segment(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_get_drop_out_of_segment(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_get_drop_out_of_segment(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_last_sample(&self) -> Option<gst::Sample> { fn get_last_sample(&self) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_base_sink_get_last_sample(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_base_sink_get_last_sample(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_latency(&self) -> gst::ClockTime { fn get_latency(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_get_latency(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_get_latency(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_max_bitrate(&self) -> u64 { fn get_max_bitrate(&self) -> u64 {
unsafe { unsafe { gst_base_sys::gst_base_sink_get_max_bitrate(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_sink_get_max_bitrate(self.as_ref().to_glib_none().0)
}
} }
fn get_max_lateness(&self) -> i64 { fn get_max_lateness(&self) -> i64 {
unsafe { unsafe { gst_base_sys::gst_base_sink_get_max_lateness(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_sink_get_max_lateness(self.as_ref().to_glib_none().0)
}
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn get_processing_deadline(&self) -> gst::ClockTime { fn get_processing_deadline(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_get_processing_deadline(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_get_processing_deadline(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_render_delay(&self) -> gst::ClockTime { fn get_render_delay(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_get_render_delay(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_get_render_delay(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_sync(&self) -> bool { fn get_sync(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_get_sync(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_get_sync(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_throttle_time(&self) -> u64 { fn get_throttle_time(&self) -> u64 {
unsafe { unsafe { gst_base_sys::gst_base_sink_get_throttle_time(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_sink_get_throttle_time(self.as_ref().to_glib_none().0)
}
} }
fn get_ts_offset(&self) -> gst::ClockTimeDiff { fn get_ts_offset(&self) -> gst::ClockTimeDiff {
unsafe { unsafe { gst_base_sys::gst_base_sink_get_ts_offset(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_sink_get_ts_offset(self.as_ref().to_glib_none().0)
}
} }
fn is_async_enabled(&self) -> bool { fn is_async_enabled(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_is_async_enabled(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_is_async_enabled(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_last_sample_enabled(&self) -> bool { fn is_last_sample_enabled(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_is_last_sample_enabled(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_is_last_sample_enabled(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_qos_enabled(&self) -> bool { fn is_qos_enabled(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_sink_is_qos_enabled(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_sink_is_qos_enabled(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -228,14 +272,32 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
let mut upstream_live = mem::uninitialized(); let mut upstream_live = mem::uninitialized();
let mut min_latency = mem::uninitialized(); let mut min_latency = mem::uninitialized();
let mut max_latency = mem::uninitialized(); let mut max_latency = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_base_sink_query_latency(self.as_ref().to_glib_none().0, &mut live, &mut upstream_live, &mut min_latency, &mut max_latency)); let ret = from_glib(gst_base_sys::gst_base_sink_query_latency(
if ret { Some((from_glib(live), from_glib(upstream_live), from_glib(min_latency), from_glib(max_latency))) } else { None } self.as_ref().to_glib_none().0,
&mut live,
&mut upstream_live,
&mut min_latency,
&mut max_latency,
));
if ret {
Some((
from_glib(live),
from_glib(upstream_live),
from_glib(min_latency),
from_glib(max_latency),
))
} else {
None
}
} }
} }
fn set_async_enabled(&self, enabled: bool) { fn set_async_enabled(&self, enabled: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_async_enabled(self.as_ref().to_glib_none().0, enabled.to_glib()); gst_base_sys::gst_base_sink_set_async_enabled(
self.as_ref().to_glib_none().0,
enabled.to_glib(),
);
} }
} }
@ -248,44 +310,65 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn set_drop_out_of_segment(&self, drop_out_of_segment: bool) { fn set_drop_out_of_segment(&self, drop_out_of_segment: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_drop_out_of_segment(self.as_ref().to_glib_none().0, drop_out_of_segment.to_glib()); gst_base_sys::gst_base_sink_set_drop_out_of_segment(
self.as_ref().to_glib_none().0,
drop_out_of_segment.to_glib(),
);
} }
} }
fn set_last_sample_enabled(&self, enabled: bool) { fn set_last_sample_enabled(&self, enabled: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_last_sample_enabled(self.as_ref().to_glib_none().0, enabled.to_glib()); gst_base_sys::gst_base_sink_set_last_sample_enabled(
self.as_ref().to_glib_none().0,
enabled.to_glib(),
);
} }
} }
fn set_max_bitrate(&self, max_bitrate: u64) { fn set_max_bitrate(&self, max_bitrate: u64) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_max_bitrate(self.as_ref().to_glib_none().0, max_bitrate); gst_base_sys::gst_base_sink_set_max_bitrate(
self.as_ref().to_glib_none().0,
max_bitrate,
);
} }
} }
fn set_max_lateness(&self, max_lateness: i64) { fn set_max_lateness(&self, max_lateness: i64) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_max_lateness(self.as_ref().to_glib_none().0, max_lateness); gst_base_sys::gst_base_sink_set_max_lateness(
self.as_ref().to_glib_none().0,
max_lateness,
);
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn set_processing_deadline(&self, processing_deadline: gst::ClockTime) { fn set_processing_deadline(&self, processing_deadline: gst::ClockTime) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_processing_deadline(self.as_ref().to_glib_none().0, processing_deadline.to_glib()); gst_base_sys::gst_base_sink_set_processing_deadline(
self.as_ref().to_glib_none().0,
processing_deadline.to_glib(),
);
} }
} }
fn set_qos_enabled(&self, enabled: bool) { fn set_qos_enabled(&self, enabled: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_qos_enabled(self.as_ref().to_glib_none().0, enabled.to_glib()); gst_base_sys::gst_base_sink_set_qos_enabled(
self.as_ref().to_glib_none().0,
enabled.to_glib(),
);
} }
} }
fn set_render_delay(&self, delay: gst::ClockTime) { fn set_render_delay(&self, delay: gst::ClockTime) {
unsafe { unsafe {
gst_base_sys::gst_base_sink_set_render_delay(self.as_ref().to_glib_none().0, delay.to_glib()); gst_base_sys::gst_base_sink_set_render_delay(
self.as_ref().to_glib_none().0,
delay.to_glib(),
);
} }
} }
@ -310,7 +393,11 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff) { fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff) {
unsafe { unsafe {
let mut jitter = mem::uninitialized(); let mut jitter = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_base_sink_wait_clock(self.as_ref().to_glib_none().0, time.to_glib(), &mut jitter)); let ret = from_glib(gst_base_sys::gst_base_sink_wait_clock(
self.as_ref().to_glib_none().0,
time.to_glib(),
&mut jitter,
));
(ret, jitter) (ret, jitter)
} }
} }
@ -318,211 +405,383 @@ impl<O: IsA<BaseSink>> BaseSinkExt for O {
fn get_property_async(&self) -> bool { fn get_property_async(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"async\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"async\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_async(&self, async: bool) { fn set_property_async(&self, async: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"async\0".as_ptr() as *const _, Value::from(&async).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"async\0".as_ptr() as *const _,
Value::from(&async).to_glib_none().0,
);
} }
} }
fn get_property_enable_last_sample(&self) -> bool { fn get_property_enable_last_sample(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"enable-last-sample\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"enable-last-sample\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_enable_last_sample(&self, enable_last_sample: bool) { fn set_property_enable_last_sample(&self, enable_last_sample: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"enable-last-sample\0".as_ptr() as *const _, Value::from(&enable_last_sample).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"enable-last-sample\0".as_ptr() as *const _,
Value::from(&enable_last_sample).to_glib_none().0,
);
} }
} }
fn get_property_qos(&self) -> bool { fn get_property_qos(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"qos\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"qos\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_qos(&self, qos: bool) { fn set_property_qos(&self, qos: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"qos\0".as_ptr() as *const _, Value::from(&qos).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"qos\0".as_ptr() as *const _,
Value::from(&qos).to_glib_none().0,
);
} }
} }
fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::async\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_async_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::async\0".as_ptr() as *const _,
Some(transmute(notify_async_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_blocksize_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::blocksize\0".as_ptr() as *const _,
Some(transmute(notify_blocksize_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_enable_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_enable_last_sample_trampoline<
P,
F: Fn(&P) + Send + Sync + 'static,
>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::enable-last-sample\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_enable_last_sample_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::enable-last-sample\0".as_ptr() as *const _,
Some(transmute(
notify_enable_last_sample_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::last-sample\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_last_sample_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::last-sample\0".as_ptr() as *const _,
Some(transmute(notify_last_sample_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_max_bitrate_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_bitrate_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-bitrate\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_bitrate_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-bitrate\0".as_ptr() as *const _,
Some(transmute(notify_max_bitrate_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_max_lateness_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_lateness_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-lateness\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_lateness_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-lateness\0".as_ptr() as *const _,
Some(transmute(
notify_max_lateness_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_processing_deadline_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_processing_deadline_trampoline<
P,
F: Fn(&P) + Send + Sync + 'static,
>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::processing-deadline\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_processing_deadline_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::processing-deadline\0".as_ptr() as *const _,
Some(transmute(
notify_processing_deadline_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_qos_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::qos\0".as_ptr() as *const _,
Some(transmute(notify_qos_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_render_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_render_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::render-delay\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_render_delay_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::render-delay\0".as_ptr() as *const _,
Some(transmute(
notify_render_delay_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_sync_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_sync_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::sync\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_sync_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::sync\0".as_ptr() as *const _,
Some(transmute(notify_sync_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_throttle_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_throttle_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::throttle-time\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_throttle_time_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::throttle-time\0".as_ptr() as *const _,
Some(transmute(
notify_throttle_time_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_ts_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSink, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSink> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_ts_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSink,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSink>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSink::from_glib_borrow(this).unsafe_cast()) f(&BaseSink::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::ts-offset\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_ts_offset_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::ts-offset\0".as_ptr() as *const _,
Some(transmute(notify_ts_offset_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

203
gstreamer-base/src/auto/base_src.rs
View file

@ -3,13 +3,13 @@
// DO NOT EDIT // DO NOT EDIT
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -72,13 +72,25 @@ pub trait BaseSrcExt: 'static {
fn set_property_typefind(&self, typefind: bool); fn set_property_typefind(&self, typefind: bool);
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<BaseSrc>> BaseSrcExt for O { impl<O: IsA<BaseSrc>> BaseSrcExt for O {
@ -87,38 +99,49 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
//} //}
fn get_blocksize(&self) -> u32 { fn get_blocksize(&self) -> u32 {
unsafe { unsafe { gst_base_sys::gst_base_src_get_blocksize(self.as_ref().to_glib_none().0) }
gst_base_sys::gst_base_src_get_blocksize(self.as_ref().to_glib_none().0)
}
} }
fn get_buffer_pool(&self) -> Option<gst::BufferPool> { fn get_buffer_pool(&self) -> Option<gst::BufferPool> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_base_src_get_buffer_pool(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_base_src_get_buffer_pool(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_do_timestamp(&self) -> bool { fn get_do_timestamp(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_src_get_do_timestamp(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_src_get_do_timestamp(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_async(&self) -> bool { fn is_async(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_src_is_async(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_src_is_async(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_live(&self) -> bool { fn is_live(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_src_is_live(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_src_is_live(
self.as_ref().to_glib_none().0,
))
} }
} }
fn new_seamless_segment(&self, start: i64, stop: i64, time: i64) -> bool { fn new_seamless_segment(&self, start: i64, stop: i64, time: i64) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_src_new_seamless_segment(self.as_ref().to_glib_none().0, start, stop, time)) from_glib(gst_base_sys::gst_base_src_new_seamless_segment(
self.as_ref().to_glib_none().0,
start,
stop,
time,
))
} }
} }
@ -127,8 +150,21 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
let mut live = mem::uninitialized(); let mut live = mem::uninitialized();
let mut min_latency = mem::uninitialized(); let mut min_latency = mem::uninitialized();
let mut max_latency = mem::uninitialized(); let mut max_latency = mem::uninitialized();
let ret = from_glib(gst_base_sys::gst_base_src_query_latency(self.as_ref().to_glib_none().0, &mut live, &mut min_latency, &mut max_latency)); let ret = from_glib(gst_base_sys::gst_base_src_query_latency(
if ret { Some((from_glib(live), from_glib(min_latency), from_glib(max_latency))) } else { None } self.as_ref().to_glib_none().0,
&mut live,
&mut min_latency,
&mut max_latency,
));
if ret {
Some((
from_glib(live),
from_glib(min_latency),
from_glib(max_latency),
))
} else {
None
}
} }
} }
@ -140,7 +176,10 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
fn set_automatic_eos(&self, automatic_eos: bool) { fn set_automatic_eos(&self, automatic_eos: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_src_set_automatic_eos(self.as_ref().to_glib_none().0, automatic_eos.to_glib()); gst_base_sys::gst_base_src_set_automatic_eos(
self.as_ref().to_glib_none().0,
automatic_eos.to_glib(),
);
} }
} }
@ -152,19 +191,31 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
fn set_caps(&self, caps: &gst::Caps) -> Result<(), glib::error::BoolError> { fn set_caps(&self, caps: &gst::Caps) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_base_sys::gst_base_src_set_caps(self.as_ref().to_glib_none().0, caps.to_glib_none().0), "Failed to set caps") glib_result_from_gboolean!(
gst_base_sys::gst_base_src_set_caps(
self.as_ref().to_glib_none().0,
caps.to_glib_none().0
),
"Failed to set caps"
)
} }
} }
fn set_do_timestamp(&self, timestamp: bool) { fn set_do_timestamp(&self, timestamp: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_src_set_do_timestamp(self.as_ref().to_glib_none().0, timestamp.to_glib()); gst_base_sys::gst_base_src_set_do_timestamp(
self.as_ref().to_glib_none().0,
timestamp.to_glib(),
);
} }
} }
fn set_dynamic_size(&self, dynamic: bool) { fn set_dynamic_size(&self, dynamic: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_src_set_dynamic_size(self.as_ref().to_glib_none().0, dynamic.to_glib()); gst_base_sys::gst_base_src_set_dynamic_size(
self.as_ref().to_glib_none().0,
dynamic.to_glib(),
);
} }
} }
@ -183,84 +234,146 @@ impl<O: IsA<BaseSrc>> BaseSrcExt for O {
fn get_property_num_buffers(&self) -> i32 { fn get_property_num_buffers(&self) -> i32 {
unsafe { unsafe {
let mut value = Value::from_type(<i32 as StaticType>::static_type()); let mut value = Value::from_type(<i32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"num-buffers\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"num-buffers\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_num_buffers(&self, num_buffers: i32) { fn set_property_num_buffers(&self, num_buffers: i32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"num-buffers\0".as_ptr() as *const _, Value::from(&num_buffers).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"num-buffers\0".as_ptr() as *const _,
Value::from(&num_buffers).to_glib_none().0,
);
} }
} }
fn get_property_typefind(&self) -> bool { fn get_property_typefind(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"typefind\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"typefind\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_typefind(&self, typefind: bool) { fn set_property_typefind(&self, typefind: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"typefind\0".as_ptr() as *const _, Value::from(&typefind).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"typefind\0".as_ptr() as *const _,
Value::from(&typefind).to_glib_none().0,
);
} }
} }
fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSrc> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSrc>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast()) f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::blocksize\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_blocksize_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::blocksize\0".as_ptr() as *const _,
Some(transmute(notify_blocksize_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_do_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_do_timestamp_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSrc> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_do_timestamp_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSrc>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast()) f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::do-timestamp\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_do_timestamp_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::do-timestamp\0".as_ptr() as *const _,
Some(transmute(
notify_do_timestamp_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_num_buffers_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_num_buffers_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSrc> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_num_buffers_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSrc>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast()) f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::num-buffers\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_num_buffers_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::num-buffers\0".as_ptr() as *const _,
Some(transmute(notify_num_buffers_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_typefind_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_typefind_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseSrc, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseSrc> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_typefind_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseSrc,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseSrc>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseSrc::from_glib_borrow(this).unsafe_cast()) f(&BaseSrc::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::typefind\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_typefind_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::typefind\0".as_ptr() as *const _,
Some(transmute(notify_typefind_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

100
gstreamer-base/src/auto/base_transform.rs
View file

@ -3,13 +3,13 @@
// DO NOT EDIT // DO NOT EDIT
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -63,7 +63,10 @@ pub trait BaseTransformExt: 'static {
fn set_property_qos(&self, qos: bool); fn set_property_qos(&self, qos: bool);
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<BaseTransform>> BaseTransformExt for O { impl<O: IsA<BaseTransform>> BaseTransformExt for O {
@ -73,25 +76,33 @@ impl<O: IsA<BaseTransform>> BaseTransformExt for O {
fn get_buffer_pool(&self) -> Option<gst::BufferPool> { fn get_buffer_pool(&self) -> Option<gst::BufferPool> {
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_base_transform_get_buffer_pool(self.as_ref().to_glib_none().0)) from_glib_full(gst_base_sys::gst_base_transform_get_buffer_pool(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_in_place(&self) -> bool { fn is_in_place(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_transform_is_in_place(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_transform_is_in_place(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_passthrough(&self) -> bool { fn is_passthrough(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_transform_is_passthrough(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_transform_is_passthrough(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_qos_enabled(&self) -> bool { fn is_qos_enabled(&self) -> bool {
unsafe { unsafe {
from_glib(gst_base_sys::gst_base_transform_is_qos_enabled(self.as_ref().to_glib_none().0)) from_glib(gst_base_sys::gst_base_transform_is_qos_enabled(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -109,71 +120,116 @@ impl<O: IsA<BaseTransform>> BaseTransformExt for O {
fn set_gap_aware(&self, gap_aware: bool) { fn set_gap_aware(&self, gap_aware: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_set_gap_aware(self.as_ref().to_glib_none().0, gap_aware.to_glib()); gst_base_sys::gst_base_transform_set_gap_aware(
self.as_ref().to_glib_none().0,
gap_aware.to_glib(),
);
} }
} }
fn set_in_place(&self, in_place: bool) { fn set_in_place(&self, in_place: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_set_in_place(self.as_ref().to_glib_none().0, in_place.to_glib()); gst_base_sys::gst_base_transform_set_in_place(
self.as_ref().to_glib_none().0,
in_place.to_glib(),
);
} }
} }
fn set_passthrough(&self, passthrough: bool) { fn set_passthrough(&self, passthrough: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_set_passthrough(self.as_ref().to_glib_none().0, passthrough.to_glib()); gst_base_sys::gst_base_transform_set_passthrough(
self.as_ref().to_glib_none().0,
passthrough.to_glib(),
);
} }
} }
fn set_prefer_passthrough(&self, prefer_passthrough: bool) { fn set_prefer_passthrough(&self, prefer_passthrough: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_set_prefer_passthrough(self.as_ref().to_glib_none().0, prefer_passthrough.to_glib()); gst_base_sys::gst_base_transform_set_prefer_passthrough(
self.as_ref().to_glib_none().0,
prefer_passthrough.to_glib(),
);
} }
} }
fn set_qos_enabled(&self, enabled: bool) { fn set_qos_enabled(&self, enabled: bool) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_set_qos_enabled(self.as_ref().to_glib_none().0, enabled.to_glib()); gst_base_sys::gst_base_transform_set_qos_enabled(
self.as_ref().to_glib_none().0,
enabled.to_glib(),
);
} }
} }
fn update_qos(&self, proportion: f64, diff: gst::ClockTimeDiff, timestamp: gst::ClockTime) { fn update_qos(&self, proportion: f64, diff: gst::ClockTimeDiff, timestamp: gst::ClockTime) {
unsafe { unsafe {
gst_base_sys::gst_base_transform_update_qos(self.as_ref().to_glib_none().0, proportion, diff, timestamp.to_glib()); gst_base_sys::gst_base_transform_update_qos(
self.as_ref().to_glib_none().0,
proportion,
diff,
timestamp.to_glib(),
);
} }
} }
fn update_src_caps(&self, updated_caps: &gst::Caps) -> Result<(), glib::error::BoolError> { fn update_src_caps(&self, updated_caps: &gst::Caps) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_base_sys::gst_base_transform_update_src_caps(self.as_ref().to_glib_none().0, updated_caps.to_glib_none().0), "Failed to update src caps") glib_result_from_gboolean!(
gst_base_sys::gst_base_transform_update_src_caps(
self.as_ref().to_glib_none().0,
updated_caps.to_glib_none().0
),
"Failed to update src caps"
)
} }
} }
fn get_property_qos(&self) -> bool { fn get_property_qos(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"qos\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"qos\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_qos(&self, qos: bool) { fn set_property_qos(&self, qos: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"qos\0".as_ptr() as *const _, Value::from(&qos).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"qos\0".as_ptr() as *const _,
Value::from(&qos).to_glib_none().0,
);
} }
} }
fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_base_sys::GstBaseTransform, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<BaseTransform> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_base_sys::GstBaseTransform,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<BaseTransform>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&BaseTransform::from_glib_borrow(this).unsafe_cast()) f(&BaseTransform::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_qos_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::qos\0".as_ptr() as *const _,
Some(transmute(notify_qos_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

1
gstreamer-base/src/auto/flags.rs
View file

@ -32,4 +32,3 @@ impl FromGlib<gst_base_sys::GstBaseParseFrameFlags> for BaseParseFrameFlags {
BaseParseFrameFlags::from_bits_truncate(value) BaseParseFrameFlags::from_bits_truncate(value)
} }
} }

56
gstreamer-base/src/auto/functions.rs
View file

@ -8,48 +8,84 @@ use gst;
use gst_base_sys; use gst_base_sys;
use std::mem; use std::mem;
pub fn type_find_helper<P: IsA<gst::Pad>>(src: &P, size: u64) -> Option<gst::Caps> { pub fn type_find_helper<P: IsA<gst::Pad>>(src: &P, size: u64) -> Option<gst::Caps> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_type_find_helper(src.as_ref().to_glib_none().0, size)) from_glib_full(gst_base_sys::gst_type_find_helper(
src.as_ref().to_glib_none().0,
size,
))
} }
} }
pub fn type_find_helper_for_buffer<P: IsA<gst::Object>>(obj: Option<&P>, buf: &gst::Buffer) -> (Option<gst::Caps>, gst::TypeFindProbability) { pub fn type_find_helper_for_buffer<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut prob = mem::uninitialized(); let mut prob = mem::uninitialized();
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_buffer(obj.map(|p| p.as_ref()).to_glib_none().0, buf.to_glib_none().0, &mut prob)); let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_buffer(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
&mut prob,
));
(ret, from_glib(prob)) (ret, from_glib(prob))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_buffer_with_extension<P: IsA<gst::Object>>(obj: Option<&P>, buf: &gst::Buffer, extension: Option<&str>) -> (Option<gst::Caps>, gst::TypeFindProbability) { pub fn type_find_helper_for_buffer_with_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
buf: &gst::Buffer,
extension: Option<&str>,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut prob = mem::uninitialized(); let mut prob = mem::uninitialized();
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_buffer_with_extension(obj.map(|p| p.as_ref()).to_glib_none().0, buf.to_glib_none().0, extension.to_glib_none().0, &mut prob)); let ret = from_glib_full(
gst_base_sys::gst_type_find_helper_for_buffer_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
buf.to_glib_none().0,
extension.to_glib_none().0,
&mut prob,
),
);
(ret, from_glib(prob)) (ret, from_glib(prob))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn type_find_helper_for_data_with_extension<P: IsA<gst::Object>>(obj: Option<&P>, data: &[u8], extension: Option<&str>) -> (Option<gst::Caps>, gst::TypeFindProbability) { pub fn type_find_helper_for_data_with_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
data: &[u8],
extension: Option<&str>,
) -> (Option<gst::Caps>, gst::TypeFindProbability) {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
let size = data.len() as usize; let size = data.len() as usize;
unsafe { unsafe {
let mut prob = mem::uninitialized(); let mut prob = mem::uninitialized();
let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_data_with_extension(obj.map(|p| p.as_ref()).to_glib_none().0, data.to_glib_none().0, size, extension.to_glib_none().0, &mut prob)); let ret = from_glib_full(gst_base_sys::gst_type_find_helper_for_data_with_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
data.to_glib_none().0,
size,
extension.to_glib_none().0,
&mut prob,
));
(ret, from_glib(prob)) (ret, from_glib(prob))
} }
} }
pub fn type_find_helper_for_extension<P: IsA<gst::Object>>(obj: Option<&P>, extension: &str) -> Option<gst::Caps> { pub fn type_find_helper_for_extension<P: IsA<gst::Object>>(
obj: Option<&P>,
extension: &str,
) -> Option<gst::Caps> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_base_sys::gst_type_find_helper_for_extension(obj.map(|p| p.as_ref()).to_glib_none().0, extension.to_glib_none().0)) from_glib_full(gst_base_sys::gst_type_find_helper_for_extension(
obj.map(|p| p.as_ref()).to_glib_none().0,
extension.to_glib_none().0,
))
} }
} }

16
gstreamer-base/src/auto/mod.rs
View file

@ -8,32 +8,32 @@ pub use self::adapter::{Adapter, AdapterClass};
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
mod aggregator; mod aggregator;
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator::{Aggregator, AggregatorClass, NONE_AGGREGATOR};
#[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator::AggregatorExt; pub use self::aggregator::AggregatorExt;
#[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator::{Aggregator, AggregatorClass, NONE_AGGREGATOR};
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
mod aggregator_pad; mod aggregator_pad;
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator_pad::{AggregatorPad, AggregatorPadClass, NONE_AGGREGATOR_PAD};
#[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator_pad::AggregatorPadExt; pub use self::aggregator_pad::AggregatorPadExt;
#[cfg(any(feature = "v1_14", feature = "dox"))]
pub use self::aggregator_pad::{AggregatorPad, AggregatorPadClass, NONE_AGGREGATOR_PAD};
mod base_parse; mod base_parse;
pub use self::base_parse::{BaseParse, BaseParseClass, NONE_BASE_PARSE};
pub use self::base_parse::BaseParseExt; pub use self::base_parse::BaseParseExt;
pub use self::base_parse::{BaseParse, BaseParseClass, NONE_BASE_PARSE};
mod base_sink; mod base_sink;
pub use self::base_sink::{BaseSink, BaseSinkClass, NONE_BASE_SINK};
pub use self::base_sink::BaseSinkExt; pub use self::base_sink::BaseSinkExt;
pub use self::base_sink::{BaseSink, BaseSinkClass, NONE_BASE_SINK};
mod base_src; mod base_src;
pub use self::base_src::{BaseSrc, BaseSrcClass, NONE_BASE_SRC};
pub use self::base_src::BaseSrcExt; pub use self::base_src::BaseSrcExt;
pub use self::base_src::{BaseSrc, BaseSrcClass, NONE_BASE_SRC};
mod base_transform; mod base_transform;
pub use self::base_transform::{BaseTransform, BaseTransformClass, NONE_BASE_TRANSFORM};
pub use self::base_transform::BaseTransformExt; pub use self::base_transform::BaseTransformExt;
pub use self::base_transform::{BaseTransform, BaseTransformClass, NONE_BASE_TRANSFORM};
mod push_src; mod push_src;
pub use self::push_src::{PushSrc, PushSrcClass, NONE_PUSH_SRC}; pub use self::push_src::{PushSrc, PushSrcClass, NONE_PUSH_SRC};

2
gstreamer-base/src/auto/push_src.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use BaseSrc;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_base_sys; use gst_base_sys;
use BaseSrc;
glib_wrapper! { glib_wrapper! {
pub struct PushSrc(Object<gst_base_sys::GstPushSrc, gst_base_sys::GstPushSrcClass, PushSrcClass>) @extends BaseSrc, gst::Element, gst::Object; pub struct PushSrc(Object<gst_base_sys::GstPushSrc, gst_base_sys::GstPushSrcClass, PushSrcClass>) @extends BaseSrc, gst::Element, gst::Object;

1
gstreamer-base/src/lib.rs
View file

@ -38,7 +38,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::functions::*; pub use auto::functions::*;
pub use auto::*; pub use auto::*;

3
gstreamer-check/src/auto/mod.rs
View file

@ -6,5 +6,4 @@ mod test_clock;
pub use self::test_clock::{TestClock, TestClockClass}; pub use self::test_clock::{TestClock, TestClockClass};
#[doc(hidden)] #[doc(hidden)]
pub mod traits { pub mod traits {}
}

66
gstreamer-check/src/auto/test_clock.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::ObjectType as ObjectType_; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -27,15 +27,16 @@ glib_wrapper! {
impl TestClock { impl TestClock {
pub fn new() -> TestClock { pub fn new() -> TestClock {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { gst::Clock::from_glib_full(gst_check_sys::gst_test_clock_new()).unsafe_cast() }
gst::Clock::from_glib_full(gst_check_sys::gst_test_clock_new()).unsafe_cast()
}
} }
pub fn new_with_start_time(start_time: gst::ClockTime) -> TestClock { pub fn new_with_start_time(start_time: gst::ClockTime) -> TestClock {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
gst::Clock::from_glib_full(gst_check_sys::gst_test_clock_new_with_start_time(start_time.to_glib())).unsafe_cast() gst::Clock::from_glib_full(gst_check_sys::gst_test_clock_new_with_start_time(
start_time.to_glib(),
))
.unsafe_cast()
} }
} }
@ -46,14 +47,14 @@ impl TestClock {
} }
pub fn crank(&self) -> bool { pub fn crank(&self) -> bool {
unsafe { unsafe { from_glib(gst_check_sys::gst_test_clock_crank(self.to_glib_none().0)) }
from_glib(gst_check_sys::gst_test_clock_crank(self.to_glib_none().0))
}
} }
pub fn get_next_entry_time(&self) -> gst::ClockTime { pub fn get_next_entry_time(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_check_sys::gst_test_clock_get_next_entry_time(self.to_glib_none().0)) from_glib(gst_check_sys::gst_test_clock_get_next_entry_time(
self.to_glib_none().0,
))
} }
} }
@ -62,9 +63,7 @@ impl TestClock {
//} //}
pub fn peek_id_count(&self) -> u32 { pub fn peek_id_count(&self) -> u32 {
unsafe { unsafe { gst_check_sys::gst_test_clock_peek_id_count(self.to_glib_none().0) }
gst_check_sys::gst_test_clock_peek_id_count(self.to_glib_none().0)
}
} }
//pub fn peek_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) -> bool { //pub fn peek_next_pending_id(&self, pending_id: /*Ignored*/&mut gst::ClockID) -> bool {
@ -107,21 +106,33 @@ impl TestClock {
pub fn get_property_clock_type(&self) -> gst::ClockType { pub fn get_property_clock_type(&self) -> gst::ClockType {
unsafe { unsafe {
let mut value = Value::from_type(<gst::ClockType as StaticType>::static_type()); let mut value = Value::from_type(<gst::ClockType as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"clock-type\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"clock-type\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_clock_type(&self, clock_type: gst::ClockType) { pub fn set_property_clock_type(&self, clock_type: gst::ClockType) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"clock-type\0".as_ptr() as *const _, Value::from(&clock_type).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"clock-type\0".as_ptr() as *const _,
Value::from(&clock_type).to_glib_none().0,
);
} }
} }
pub fn get_property_start_time(&self) -> u64 { pub fn get_property_start_time(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"start-time\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"start-time\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -130,15 +141,28 @@ impl TestClock {
// unsafe { TODO: call gst_check_sys:gst_test_clock_id_list_get_latest_time() } // unsafe { TODO: call gst_check_sys:gst_test_clock_id_list_get_latest_time() }
//} //}
pub fn connect_property_clock_type_notify<F: Fn(&TestClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_clock_type_notify<F: Fn(&TestClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_clock_type_trampoline<F: Fn(&TestClock) + Send + Sync + 'static>(this: *mut gst_check_sys::GstTestClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_clock_type_trampoline<
F: Fn(&TestClock) + Send + Sync + 'static,
>(
this: *mut gst_check_sys::GstTestClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::clock-type\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_clock_type_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::clock-type\0".as_ptr() as *const _,
Some(transmute(notify_clock_type_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

1
gstreamer-check/src/lib.rs
View file

@ -29,7 +29,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

174
gstreamer-editing-services/src/auto/asset.rs
View file

@ -2,26 +2,26 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Error;
use Extractable;
#[cfg(feature = "futures")] #[cfg(feature = "futures")]
use futures::future; use futures::future;
use ges_sys; use ges_sys;
use gio; use gio;
use gio_sys; use gio_sys;
use glib; use glib;
use glib::GString;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Error;
use Extractable;
glib_wrapper! { glib_wrapper! {
pub struct Asset(Object<ges_sys::GESAsset, ges_sys::GESAssetClass, AssetClass>); pub struct Asset(Object<ges_sys::GESAsset, ges_sys::GESAssetClass, AssetClass>);
@ -35,52 +35,88 @@ impl Asset {
pub fn needs_reload(extractable_type: glib::types::Type, id: &str) -> bool { pub fn needs_reload(extractable_type: glib::types::Type, id: &str) -> bool {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib(ges_sys::ges_asset_needs_reload(extractable_type.to_glib(), id.to_glib_none().0)) from_glib(ges_sys::ges_asset_needs_reload(
extractable_type.to_glib(),
id.to_glib_none().0,
))
} }
} }
pub fn request(extractable_type: glib::types::Type, id: Option<&str>) -> Result<Option<Asset>, Error> { pub fn request(
extractable_type: glib::types::Type,
id: Option<&str>,
) -> Result<Option<Asset>, Error> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_asset_request(extractable_type.to_glib(), id.to_glib_none().0, &mut error); let ret = ges_sys::ges_asset_request(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } extractable_type.to_glib(),
id.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
pub fn request_async<P: IsA<gio::Cancellable>, Q: FnOnce(Result<Asset, Error>) + Send + 'static>(extractable_type: glib::types::Type, id: &str, cancellable: Option<&P>, callback: Q) { pub fn request_async<
P: IsA<gio::Cancellable>,
Q: FnOnce(Result<Asset, Error>) + Send + 'static,
>(
extractable_type: glib::types::Type,
id: &str,
cancellable: Option<&P>,
callback: Q,
) {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
let user_data: Box<Q> = Box::new(callback); let user_data: Box<Q> = Box::new(callback);
unsafe extern "C" fn request_async_trampoline<Q: FnOnce(Result<Asset, Error>) + Send + 'static>(_source_object: *mut gobject_sys::GObject, res: *mut gio_sys::GAsyncResult, user_data: glib_sys::gpointer) { unsafe extern "C" fn request_async_trampoline<
Q: FnOnce(Result<Asset, Error>) + Send + 'static,
>(
_source_object: *mut gobject_sys::GObject,
res: *mut gio_sys::GAsyncResult,
user_data: glib_sys::gpointer,
) {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_asset_request_finish(res, &mut error); let ret = ges_sys::ges_asset_request_finish(res, &mut error);
let result = if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }; let result = if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
};
let callback: Box<Q> = Box::from_raw(user_data as *mut _); let callback: Box<Q> = Box::from_raw(user_data as *mut _);
callback(result); callback(result);
} }
let callback = request_async_trampoline::<Q>; let callback = request_async_trampoline::<Q>;
unsafe { unsafe {
ges_sys::ges_asset_request_async(extractable_type.to_glib(), id.to_glib_none().0, cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box::into_raw(user_data) as *mut _); ges_sys::ges_asset_request_async(
extractable_type.to_glib(),
id.to_glib_none().0,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box::into_raw(user_data) as *mut _,
);
} }
} }
#[cfg(feature = "futures")] #[cfg(feature = "futures")]
pub fn request_async_future(extractable_type: glib::types::Type, id: &str) -> Box_<dyn future::Future<Output = Result<Asset, Error>> + std::marker::Unpin> { pub fn request_async_future(
use gio::GioFuture; extractable_type: glib::types::Type,
id: &str,
) -> Box_<dyn future::Future<Output = Result<Asset, Error>> + std::marker::Unpin> {
use fragile::Fragile; use fragile::Fragile;
use gio::GioFuture;
let id = String::from(id); let id = String::from(id);
GioFuture::new(&(), move |_obj, send| { GioFuture::new(&(), move |_obj, send| {
let cancellable = gio::Cancellable::new(); let cancellable = gio::Cancellable::new();
let send = Fragile::new(send); let send = Fragile::new(send);
Self::request_async( Self::request_async(extractable_type, &id, Some(&cancellable), move |res| {
extractable_type,
&id,
Some(&cancellable),
move |res| {
let _ = send.into_inner().send(res); let _ = send.into_inner().send(res);
}, });
);
cancellable cancellable
}) })
@ -112,7 +148,8 @@ pub trait AssetExt: 'static {
fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(&self, f: F)
-> SignalHandlerId;
} }
impl<O: IsA<Asset>> AssetExt for O { impl<O: IsA<Asset>> AssetExt for O {
@ -120,89 +157,130 @@ impl<O: IsA<Asset>> AssetExt for O {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_asset_extract(self.as_ref().to_glib_none().0, &mut error); let ret = ges_sys::ges_asset_extract(self.as_ref().to_glib_none().0, &mut error);
if error.is_null() { Ok(from_glib_none(ret)) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(from_glib_none(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
fn get_error(&self) -> Option<Error> { fn get_error(&self) -> Option<Error> {
unsafe { unsafe { from_glib_none(ges_sys::ges_asset_get_error(self.as_ref().to_glib_none().0)) }
from_glib_none(ges_sys::ges_asset_get_error(self.as_ref().to_glib_none().0))
}
} }
fn get_extractable_type(&self) -> glib::types::Type { fn get_extractable_type(&self) -> glib::types::Type {
unsafe { unsafe {
from_glib(ges_sys::ges_asset_get_extractable_type(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_asset_get_extractable_type(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_id(&self) -> Option<GString> { fn get_id(&self) -> Option<GString> {
unsafe { unsafe { from_glib_none(ges_sys::ges_asset_get_id(self.as_ref().to_glib_none().0)) }
from_glib_none(ges_sys::ges_asset_get_id(self.as_ref().to_glib_none().0))
}
} }
fn get_proxy(&self) -> Option<Asset> { fn get_proxy(&self) -> Option<Asset> {
unsafe { unsafe { from_glib_none(ges_sys::ges_asset_get_proxy(self.as_ref().to_glib_none().0)) }
from_glib_none(ges_sys::ges_asset_get_proxy(self.as_ref().to_glib_none().0))
}
} }
fn get_proxy_target(&self) -> Option<Asset> { fn get_proxy_target(&self) -> Option<Asset> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_asset_get_proxy_target(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_asset_get_proxy_target(
self.as_ref().to_glib_none().0,
))
} }
} }
fn list_proxies(&self) -> Vec<Asset> { fn list_proxies(&self) -> Vec<Asset> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(ges_sys::ges_asset_list_proxies(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_none(ges_sys::ges_asset_list_proxies(
self.as_ref().to_glib_none().0,
))
} }
} }
fn set_proxy<P: IsA<Asset>>(&self, proxy: Option<&P>) -> Result<(), glib::error::BoolError> { fn set_proxy<P: IsA<Asset>>(&self, proxy: Option<&P>) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_asset_set_proxy(self.as_ref().to_glib_none().0, proxy.map(|p| p.as_ref()).to_glib_none().0), "Failed to set proxy") glib_result_from_gboolean!(
ges_sys::ges_asset_set_proxy(
self.as_ref().to_glib_none().0,
proxy.map(|p| p.as_ref()).to_glib_none().0
),
"Failed to set proxy"
)
} }
} }
fn unproxy<P: IsA<Asset>>(&self, proxy: &P) -> Result<(), glib::error::BoolError> { fn unproxy<P: IsA<Asset>>(&self, proxy: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_asset_unproxy(self.as_ref().to_glib_none().0, proxy.as_ref().to_glib_none().0), "Failed to unproxy asset") glib_result_from_gboolean!(
ges_sys::ges_asset_unproxy(
self.as_ref().to_glib_none().0,
proxy.as_ref().to_glib_none().0
),
"Failed to unproxy asset"
)
} }
} }
fn set_property_proxy_target(&self, proxy_target: Option<&Asset>) { fn set_property_proxy_target(&self, proxy_target: Option<&Asset>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"proxy-target\0".as_ptr() as *const _, Value::from(proxy_target).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"proxy-target\0".as_ptr() as *const _,
Value::from(proxy_target).to_glib_none().0,
);
} }
} }
fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_proxy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_proxy_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_proxy_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Asset> this: *mut ges_sys::GESAsset,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Asset>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast()) f(&Asset::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::proxy\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_proxy_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::proxy\0".as_ptr() as *const _,
Some(transmute(notify_proxy_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_proxy_target_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_proxy_target_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Asset> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_proxy_target_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESAsset,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Asset>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Asset::from_glib_borrow(this).unsafe_cast()) f(&Asset::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::proxy-target\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_proxy_target_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::proxy-target\0".as_ptr() as *const _,
Some(transmute(
notify_proxy_target_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

4
gstreamer-editing-services/src/auto/base_effect.rs
View file

@ -2,11 +2,11 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib::translate::*;
use Extractable; use Extractable;
use TimelineElement; use TimelineElement;
use TrackElement; use TrackElement;
use ges_sys;
use glib::translate::*;
glib_wrapper! { glib_wrapper! {
pub struct BaseEffect(Object<ges_sys::GESBaseEffect, ges_sys::GESBaseEffectClass, BaseEffectClass>) @extends TrackElement, TimelineElement, @implements Extractable; pub struct BaseEffect(Object<ges_sys::GESBaseEffect, ges_sys::GESBaseEffectClass, BaseEffectClass>) @extends TrackElement, TimelineElement, @implements Extractable;

190
gstreamer-editing-services/src/auto/clip.rs
View file

@ -2,6 +2,16 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
use Asset; use Asset;
use BaseEffect; use BaseEffect;
use Container; use Container;
@ -11,16 +21,6 @@ use TimelineElement;
use Track; use Track;
use TrackElement; use TrackElement;
use TrackType; use TrackType;
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
glib_wrapper! { glib_wrapper! {
pub struct Clip(Object<ges_sys::GESClip, ges_sys::GESClipClass, ClipClass>) @extends Container, TimelineElement, @implements Extractable; pub struct Clip(Object<ges_sys::GESClip, ges_sys::GESClipClass, ClipClass>) @extends Container, TimelineElement, @implements Extractable;
@ -35,9 +35,18 @@ pub const NONE_CLIP: Option<&Clip> = None;
pub trait ClipExt: 'static { pub trait ClipExt: 'static {
fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Option<TrackElement>; fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Option<TrackElement>;
fn find_track_element<P: IsA<Track>>(&self, track: Option<&P>, type_: glib::types::Type) -> Option<TrackElement>; fn find_track_element<P: IsA<Track>>(
&self,
track: Option<&P>,
type_: glib::types::Type,
) -> Option<TrackElement>;
fn find_track_elements<P: IsA<Track>>(&self, track: Option<&P>, track_type: TrackType, type_: glib::types::Type) -> Vec<TrackElement>; fn find_track_elements<P: IsA<Track>>(
&self,
track: Option<&P>,
track_type: TrackType,
type_: glib::types::Type,
) -> Vec<TrackElement>;
fn get_layer(&self) -> Option<Layer>; fn get_layer(&self) -> Option<Layer>;
@ -53,121 +62,216 @@ pub trait ClipExt: 'static {
fn set_supported_formats(&self, supportedformats: TrackType); fn set_supported_formats(&self, supportedformats: TrackType);
fn set_top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P, newindex: u32) -> Result<(), glib::error::BoolError>; fn set_top_effect_index<P: IsA<BaseEffect>>(
&self,
effect: &P,
newindex: u32,
) -> Result<(), glib::error::BoolError>;
fn set_top_effect_priority<P: IsA<BaseEffect>>(&self, effect: &P, newpriority: u32) -> Result<(), glib::error::BoolError>; fn set_top_effect_priority<P: IsA<BaseEffect>>(
&self,
effect: &P,
newpriority: u32,
) -> Result<(), glib::error::BoolError>;
fn split(&self, position: u64) -> Option<Clip>; fn split(&self, position: u64) -> Option<Clip>;
fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<Clip>> ClipExt for O { impl<O: IsA<Clip>> ClipExt for O {
fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Option<TrackElement> { fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Option<TrackElement> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_clip_add_asset(self.as_ref().to_glib_none().0, asset.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_clip_add_asset(
self.as_ref().to_glib_none().0,
asset.as_ref().to_glib_none().0,
))
} }
} }
fn find_track_element<P: IsA<Track>>(&self, track: Option<&P>, type_: glib::types::Type) -> Option<TrackElement> { fn find_track_element<P: IsA<Track>>(
&self,
track: Option<&P>,
type_: glib::types::Type,
) -> Option<TrackElement> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_clip_find_track_element(self.as_ref().to_glib_none().0, track.map(|p| p.as_ref()).to_glib_none().0, type_.to_glib())) from_glib_full(ges_sys::ges_clip_find_track_element(
self.as_ref().to_glib_none().0,
track.map(|p| p.as_ref()).to_glib_none().0,
type_.to_glib(),
))
} }
} }
fn find_track_elements<P: IsA<Track>>(&self, track: Option<&P>, track_type: TrackType, type_: glib::types::Type) -> Vec<TrackElement> { fn find_track_elements<P: IsA<Track>>(
&self,
track: Option<&P>,
track_type: TrackType,
type_: glib::types::Type,
) -> Vec<TrackElement> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_clip_find_track_elements(self.as_ref().to_glib_none().0, track.map(|p| p.as_ref()).to_glib_none().0, track_type.to_glib(), type_.to_glib())) FromGlibPtrContainer::from_glib_full(ges_sys::ges_clip_find_track_elements(
self.as_ref().to_glib_none().0,
track.map(|p| p.as_ref()).to_glib_none().0,
track_type.to_glib(),
type_.to_glib(),
))
} }
} }
fn get_layer(&self) -> Option<Layer> { fn get_layer(&self) -> Option<Layer> {
unsafe { unsafe { from_glib_full(ges_sys::ges_clip_get_layer(self.as_ref().to_glib_none().0)) }
from_glib_full(ges_sys::ges_clip_get_layer(self.as_ref().to_glib_none().0))
}
} }
fn get_supported_formats(&self) -> TrackType { fn get_supported_formats(&self) -> TrackType {
unsafe { unsafe {
from_glib(ges_sys::ges_clip_get_supported_formats(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_clip_get_supported_formats(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 { fn get_top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 {
unsafe { unsafe {
ges_sys::ges_clip_get_top_effect_index(self.as_ref().to_glib_none().0, effect.as_ref().to_glib_none().0) ges_sys::ges_clip_get_top_effect_index(
self.as_ref().to_glib_none().0,
effect.as_ref().to_glib_none().0,
)
} }
} }
fn get_top_effect_position<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 { fn get_top_effect_position<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 {
unsafe { unsafe {
ges_sys::ges_clip_get_top_effect_position(self.as_ref().to_glib_none().0, effect.as_ref().to_glib_none().0) ges_sys::ges_clip_get_top_effect_position(
self.as_ref().to_glib_none().0,
effect.as_ref().to_glib_none().0,
)
} }
} }
fn get_top_effects(&self) -> Vec<TrackElement> { fn get_top_effects(&self) -> Vec<TrackElement> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_clip_get_top_effects(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_clip_get_top_effects(
self.as_ref().to_glib_none().0,
))
} }
} }
fn move_to_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> { fn move_to_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_clip_move_to_layer(self.as_ref().to_glib_none().0, layer.as_ref().to_glib_none().0), "Failed to move clip to specified layer") glib_result_from_gboolean!(
ges_sys::ges_clip_move_to_layer(
self.as_ref().to_glib_none().0,
layer.as_ref().to_glib_none().0
),
"Failed to move clip to specified layer"
)
} }
} }
fn set_supported_formats(&self, supportedformats: TrackType) { fn set_supported_formats(&self, supportedformats: TrackType) {
unsafe { unsafe {
ges_sys::ges_clip_set_supported_formats(self.as_ref().to_glib_none().0, supportedformats.to_glib()); ges_sys::ges_clip_set_supported_formats(
self.as_ref().to_glib_none().0,
supportedformats.to_glib(),
);
} }
} }
fn set_top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P, newindex: u32) -> Result<(), glib::error::BoolError> { fn set_top_effect_index<P: IsA<BaseEffect>>(
&self,
effect: &P,
newindex: u32,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_clip_set_top_effect_index(self.as_ref().to_glib_none().0, effect.as_ref().to_glib_none().0, newindex), "Failed to move effect") glib_result_from_gboolean!(
ges_sys::ges_clip_set_top_effect_index(
self.as_ref().to_glib_none().0,
effect.as_ref().to_glib_none().0,
newindex
),
"Failed to move effect"
)
} }
} }
fn set_top_effect_priority<P: IsA<BaseEffect>>(&self, effect: &P, newpriority: u32) -> Result<(), glib::error::BoolError> { fn set_top_effect_priority<P: IsA<BaseEffect>>(
&self,
effect: &P,
newpriority: u32,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_clip_set_top_effect_priority(self.as_ref().to_glib_none().0, effect.as_ref().to_glib_none().0, newpriority), "Failed to the set top effect priority") glib_result_from_gboolean!(
ges_sys::ges_clip_set_top_effect_priority(
self.as_ref().to_glib_none().0,
effect.as_ref().to_glib_none().0,
newpriority
),
"Failed to the set top effect priority"
)
} }
} }
fn split(&self, position: u64) -> Option<Clip> { fn split(&self, position: u64) -> Option<Clip> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_clip_split(self.as_ref().to_glib_none().0, position)) from_glib_none(ges_sys::ges_clip_split(
self.as_ref().to_glib_none().0,
position,
))
} }
} }
fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Clip> this: *mut ges_sys::GESClip,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Clip>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast()) f(&Clip::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::layer\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_layer_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::layer\0".as_ptr() as *const _,
Some(transmute(notify_layer_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Clip> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESClip,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Clip>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Clip::from_glib_borrow(this).unsafe_cast()) f(&Clip::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_supported_formats_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::supported-formats\0".as_ptr() as *const _,
Some(transmute(
notify_supported_formats_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

170
gstreamer-editing-services/src/auto/container.rs
View file

@ -2,24 +2,24 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
use Edge; use Edge;
use EditMode; use EditMode;
use Extractable; use Extractable;
use Layer; use Layer;
use TimelineElement; use TimelineElement;
use ges_sys;
use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys;
use gobject_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
glib_wrapper! { glib_wrapper! {
pub struct Container(Object<ges_sys::GESContainer, ges_sys::GESContainerClass, ContainerClass>) @extends TimelineElement, @implements Extractable; pub struct Container(Object<ges_sys::GESContainer, ges_sys::GESContainerClass, ContainerClass>) @extends TimelineElement, @implements Extractable;
@ -32,9 +32,7 @@ glib_wrapper! {
impl Container { impl Container {
pub fn group(containers: &[Container]) -> Option<Container> { pub fn group(containers: &[Container]) -> Option<Container> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_container_group(containers.to_glib_none().0)) }
from_glib_none(ges_sys::ges_container_group(containers.to_glib_none().0))
}
} }
} }
@ -43,7 +41,14 @@ pub const NONE_CONTAINER: Option<&Container> = None;
pub trait GESContainerExt: 'static { pub trait GESContainerExt: 'static {
fn add<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError>; fn add<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError>;
fn edit(&self, layers: &[Layer], new_layer_priority: i32, mode: EditMode, edge: Edge, position: u64) -> Result<(), glib::error::BoolError>; fn edit(
&self,
layers: &[Layer],
new_layer_priority: i32,
mode: EditMode,
edge: Edge,
position: u64,
) -> Result<(), glib::error::BoolError>;
fn get_children(&self, recursive: bool) -> Vec<TimelineElement>; fn get_children(&self, recursive: bool) -> Vec<TimelineElement>;
@ -53,9 +58,15 @@ pub trait GESContainerExt: 'static {
fn get_property_height(&self) -> u32; fn get_property_height(&self) -> u32;
fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
} }
@ -63,81 +74,156 @@ pub trait GESContainerExt: 'static {
impl<O: IsA<Container>> GESContainerExt for O { impl<O: IsA<Container>> GESContainerExt for O {
fn add<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError> { fn add<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_container_add(self.as_ref().to_glib_none().0, child.as_ref().to_glib_none().0), "Failed to add element") glib_result_from_gboolean!(
ges_sys::ges_container_add(
self.as_ref().to_glib_none().0,
child.as_ref().to_glib_none().0
),
"Failed to add element"
)
} }
} }
fn edit(&self, layers: &[Layer], new_layer_priority: i32, mode: EditMode, edge: Edge, position: u64) -> Result<(), glib::error::BoolError> { fn edit(
&self,
layers: &[Layer],
new_layer_priority: i32,
mode: EditMode,
edge: Edge,
position: u64,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_container_edit(self.as_ref().to_glib_none().0, layers.to_glib_none().0, new_layer_priority, mode.to_glib(), edge.to_glib(), position), "Failed to edit container") glib_result_from_gboolean!(
ges_sys::ges_container_edit(
self.as_ref().to_glib_none().0,
layers.to_glib_none().0,
new_layer_priority,
mode.to_glib(),
edge.to_glib(),
position
),
"Failed to edit container"
)
} }
} }
fn get_children(&self, recursive: bool) -> Vec<TimelineElement> { fn get_children(&self, recursive: bool) -> Vec<TimelineElement> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_container_get_children(self.as_ref().to_glib_none().0, recursive.to_glib())) FromGlibPtrContainer::from_glib_full(ges_sys::ges_container_get_children(
self.as_ref().to_glib_none().0,
recursive.to_glib(),
))
} }
} }
fn remove<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError> { fn remove<P: IsA<TimelineElement>>(&self, child: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_container_remove(self.as_ref().to_glib_none().0, child.as_ref().to_glib_none().0), "Failed to remove element") glib_result_from_gboolean!(
ges_sys::ges_container_remove(
self.as_ref().to_glib_none().0,
child.as_ref().to_glib_none().0
),
"Failed to remove element"
)
} }
} }
fn ungroup(&self, recursive: bool) -> Vec<Container> { fn ungroup(&self, recursive: bool) -> Vec<Container> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_container_ungroup(self.as_ref().to_glib_full(), recursive.to_glib())) FromGlibPtrContainer::from_glib_full(ges_sys::ges_container_ungroup(
self.as_ref().to_glib_full(),
recursive.to_glib(),
))
} }
} }
fn get_property_height(&self) -> u32 { fn get_property_height(&self) -> u32 {
unsafe { unsafe {
let mut value = Value::from_type(<u32 as StaticType>::static_type()); let mut value = Value::from_type(<u32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"height\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"height\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_added<F: Fn(&Self, &TimelineElement) + 'static>(
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer) &self,
where P: IsA<Container> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn child_added_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(
this: *mut ges_sys::GESContainer,
element: *mut ges_sys::GESTimelineElement,
f: glib_sys::gpointer,
) where
P: IsA<Container>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element)) f(
&Container::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(element),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(child_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"child-added\0".as_ptr() as *const _,
Some(transmute(child_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_child_removed<F: Fn(&Self, &TimelineElement) + 'static>(
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(this: *mut ges_sys::GESContainer, element: *mut ges_sys::GESTimelineElement, f: glib_sys::gpointer) &self,
where P: IsA<Container> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn child_removed_trampoline<P, F: Fn(&P, &TimelineElement) + 'static>(
this: *mut ges_sys::GESContainer,
element: *mut ges_sys::GESTimelineElement,
f: glib_sys::gpointer,
) where
P: IsA<Container>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(element)) f(
&Container::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(element),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"child-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(child_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"child-removed\0".as_ptr() as *const _,
Some(transmute(child_removed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_height_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESContainer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_height_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Container> this: *mut ges_sys::GESContainer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Container>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Container::from_glib_borrow(this).unsafe_cast()) f(&Container::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::height\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_height_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::height\0".as_ptr() as *const _,
Some(transmute(notify_height_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

24
gstreamer-editing-services/src/auto/effect.rs
View file

@ -2,17 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib::object::IsA;
use glib::translate::*;
use glib::GString;
use glib::StaticType;
use glib::Value;
use gobject_sys;
use BaseEffect; use BaseEffect;
use Extractable; use Extractable;
use TimelineElement; use TimelineElement;
use TrackElement; use TrackElement;
use ges_sys;
use glib::GString;
use glib::StaticType;
use glib::Value;
use glib::object::IsA;
use glib::translate::*;
use gobject_sys;
glib_wrapper! { glib_wrapper! {
pub struct Effect(Object<ges_sys::GESEffect, ges_sys::GESEffectClass, EffectClass>) @extends BaseEffect, TrackElement, TimelineElement, @implements Extractable; pub struct Effect(Object<ges_sys::GESEffect, ges_sys::GESEffectClass, EffectClass>) @extends BaseEffect, TrackElement, TimelineElement, @implements Extractable;
@ -25,9 +25,7 @@ glib_wrapper! {
impl Effect { impl Effect {
pub fn new(bin_description: &str) -> Option<Effect> { pub fn new(bin_description: &str) -> Option<Effect> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_effect_new(bin_description.to_glib_none().0)) }
from_glib_none(ges_sys::ges_effect_new(bin_description.to_glib_none().0))
}
} }
} }
@ -41,7 +39,11 @@ impl<O: IsA<Effect>> EffectExt for O {
fn get_property_bin_description(&self) -> Option<GString> { fn get_property_bin_description(&self) -> Option<GString> {
unsafe { unsafe {
let mut value = Value::from_type(<GString as StaticType>::static_type()); let mut value = Value::from_type(<GString as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"bin-description\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"bin-description\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }

15
gstreamer-editing-services/src/auto/enums.rs
View file

@ -3,17 +3,16 @@
// DO NOT EDIT // DO NOT EDIT
use ges_sys; use ges_sys;
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum Edge { pub enum Edge {
EdgeStart, EdgeStart,
EdgeEnd, EdgeEnd,
@ -31,7 +30,7 @@ impl ToGlib for Edge {
Edge::EdgeStart => ges_sys::GES_EDGE_START, Edge::EdgeStart => ges_sys::GES_EDGE_START,
Edge::EdgeEnd => ges_sys::GES_EDGE_END, Edge::EdgeEnd => ges_sys::GES_EDGE_END,
Edge::EdgeNone => ges_sys::GES_EDGE_NONE, Edge::EdgeNone => ges_sys::GES_EDGE_NONE,
Edge::__Unknown(value) => value Edge::__Unknown(value) => value,
} }
} }
} }
@ -73,8 +72,7 @@ impl SetValue for Edge {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum EditMode { pub enum EditMode {
EditNormal, EditNormal,
EditRipple, EditRipple,
@ -96,7 +94,7 @@ impl ToGlib for EditMode {
EditMode::EditRoll => ges_sys::GES_EDIT_MODE_ROLL, EditMode::EditRoll => ges_sys::GES_EDIT_MODE_ROLL,
EditMode::EditTrim => ges_sys::GES_EDIT_MODE_TRIM, EditMode::EditTrim => ges_sys::GES_EDIT_MODE_TRIM,
EditMode::EditSlide => ges_sys::GES_EDIT_MODE_SLIDE, EditMode::EditSlide => ges_sys::GES_EDIT_MODE_SLIDE,
EditMode::__Unknown(value) => value EditMode::__Unknown(value) => value,
} }
} }
} }
@ -139,4 +137,3 @@ impl SetValue for EditMode {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
} }
} }

20
gstreamer-editing-services/src/auto/extractable.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Asset;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::GString;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use Asset;
glib_wrapper! { glib_wrapper! {
pub struct Extractable(Interface<ges_sys::GESExtractable>); pub struct Extractable(Interface<ges_sys::GESExtractable>);
@ -30,19 +30,29 @@ pub trait ExtractableExt: 'static {
impl<O: IsA<Extractable>> ExtractableExt for O { impl<O: IsA<Extractable>> ExtractableExt for O {
fn get_asset(&self) -> Option<Asset> { fn get_asset(&self) -> Option<Asset> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_extractable_get_asset(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_extractable_get_asset(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_id(&self) -> Option<GString> { fn get_id(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_extractable_get_id(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_extractable_get_id(
self.as_ref().to_glib_none().0,
))
} }
} }
fn set_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError> { fn set_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_extractable_set_asset(self.as_ref().to_glib_none().0, asset.as_ref().to_glib_none().0), "Failed to set asset") glib_result_from_gboolean!(
ges_sys::ges_extractable_set_asset(
self.as_ref().to_glib_none().0,
asset.as_ref().to_glib_none().0
),
"Failed to set asset"
)
} }
} }
} }

5
gstreamer-editing-services/src/auto/flags.rs
View file

@ -3,13 +3,13 @@
// DO NOT EDIT // DO NOT EDIT
use ges_sys; use ges_sys;
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
bitflags! { bitflags! {
@ -113,4 +113,3 @@ impl SetValue for TrackType {
gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
} }
} }

166
gstreamer-editing-services/src/auto/group.rs
View file

@ -2,21 +2,21 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Container;
use Extractable;
use TimelineElement;
use ges_sys; use ges_sys;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use Container;
use Extractable;
use TimelineElement;
glib_wrapper! { glib_wrapper! {
pub struct Group(Object<ges_sys::GESGroup, ges_sys::GESGroupClass, GroupClass>) @extends Container, TimelineElement, @implements Extractable; pub struct Group(Object<ges_sys::GESGroup, ges_sys::GESGroupClass, GroupClass>) @extends Container, TimelineElement, @implements Extractable;
@ -29,9 +29,7 @@ glib_wrapper! {
impl Group { impl Group {
pub fn new() -> Group { pub fn new() -> Group {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_group_new()) }
from_glib_none(ges_sys::ges_group_new())
}
} }
} }
@ -68,7 +66,8 @@ pub trait GroupExt: 'static {
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F)
-> SignalHandlerId;
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
@ -79,140 +78,225 @@ impl<O: IsA<Group>> GroupExt for O {
fn get_property_duration(&self) -> u64 { fn get_property_duration(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_duration(&self, duration: u64) { fn set_property_duration(&self, duration: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, Value::from(&duration).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
Value::from(&duration).to_glib_none().0,
);
} }
} }
fn get_property_in_point(&self) -> u64 { fn get_property_in_point(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"in-point\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"in-point\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_in_point(&self, in_point: u64) { fn set_property_in_point(&self, in_point: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"in-point\0".as_ptr() as *const _, Value::from(&in_point).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"in-point\0".as_ptr() as *const _,
Value::from(&in_point).to_glib_none().0,
);
} }
} }
fn get_property_max_duration(&self) -> u64 { fn get_property_max_duration(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"max-duration\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"max-duration\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_max_duration(&self, max_duration: u64) { fn set_property_max_duration(&self, max_duration: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"max-duration\0".as_ptr() as *const _, Value::from(&max_duration).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"max-duration\0".as_ptr() as *const _,
Value::from(&max_duration).to_glib_none().0,
);
} }
} }
fn get_property_priority(&self) -> u32 { fn get_property_priority(&self) -> u32 {
unsafe { unsafe {
let mut value = Value::from_type(<u32 as StaticType>::static_type()); let mut value = Value::from_type(<u32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"priority\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"priority\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_priority(&self, priority: u32) { fn set_property_priority(&self, priority: u32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"priority\0".as_ptr() as *const _, Value::from(&priority).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"priority\0".as_ptr() as *const _,
Value::from(&priority).to_glib_none().0,
);
} }
} }
fn get_property_start(&self) -> u64 { fn get_property_start(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"start\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"start\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_start(&self, start: u64) { fn set_property_start(&self, start: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"start\0".as_ptr() as *const _, Value::from(&start).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"start\0".as_ptr() as *const _,
Value::from(&start).to_glib_none().0,
);
} }
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Group> this: *mut ges_sys::GESGroup,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Group>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast()) f(&Group::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Group> this: *mut ges_sys::GESGroup,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Group>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast()) f(&Group::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_in_point_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::in-point\0".as_ptr() as *const _,
Some(transmute(notify_in_point_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Group> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESGroup,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Group>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast()) f(&Group::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-duration\0".as_ptr() as *const _,
Some(transmute(
notify_max_duration_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Group> this: *mut ges_sys::GESGroup,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Group>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast()) f(&Group::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_priority_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::priority\0".as_ptr() as *const _,
Some(transmute(notify_priority_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESGroup, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Group> this: *mut ges_sys::GESGroup,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Group>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Group::from_glib_borrow(this).unsafe_cast()) f(&Group::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_start_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::start\0".as_ptr() as *const _,
Some(transmute(notify_start_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

185
gstreamer-editing-services/src/auto/layer.rs
View file

@ -2,22 +2,22 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Asset;
use Clip;
use Extractable;
use Timeline;
use TrackType;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib_sys; use glib_sys;
use gst; use gst;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use Asset;
use Clip;
use Extractable;
use Timeline;
use TrackType;
glib_wrapper! { glib_wrapper! {
pub struct Layer(Object<ges_sys::GESLayer, ges_sys::GESLayerClass, LayerClass>) @implements Extractable; pub struct Layer(Object<ges_sys::GESLayer, ges_sys::GESLayerClass, LayerClass>) @implements Extractable;
@ -30,9 +30,7 @@ glib_wrapper! {
impl Layer { impl Layer {
pub fn new() -> Layer { pub fn new() -> Layer {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_layer_new()) }
from_glib_none(ges_sys::ges_layer_new())
}
} }
} }
@ -45,7 +43,14 @@ impl Default for Layer {
pub const NONE_LAYER: Option<&Layer> = None; pub const NONE_LAYER: Option<&Layer> = None;
pub trait LayerExt: 'static { pub trait LayerExt: 'static {
fn add_asset<P: IsA<Asset>>(&self, asset: &P, start: gst::ClockTime, inpoint: gst::ClockTime, duration: gst::ClockTime, track_types: TrackType) -> Option<Clip>; fn add_asset<P: IsA<Asset>>(
&self,
asset: &P,
start: gst::ClockTime,
inpoint: gst::ClockTime,
duration: gst::ClockTime,
track_types: TrackType,
) -> Option<Clip>;
fn add_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError>; fn add_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError>;
@ -76,76 +81,116 @@ pub trait LayerExt: 'static {
fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
#[cfg_attr(feature = "v1_16", deprecated)] #[cfg_attr(feature = "v1_16", deprecated)]
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
} }
impl<O: IsA<Layer>> LayerExt for O { impl<O: IsA<Layer>> LayerExt for O {
fn add_asset<P: IsA<Asset>>(&self, asset: &P, start: gst::ClockTime, inpoint: gst::ClockTime, duration: gst::ClockTime, track_types: TrackType) -> Option<Clip> { fn add_asset<P: IsA<Asset>>(
&self,
asset: &P,
start: gst::ClockTime,
inpoint: gst::ClockTime,
duration: gst::ClockTime,
track_types: TrackType,
) -> Option<Clip> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_layer_add_asset(self.as_ref().to_glib_none().0, asset.as_ref().to_glib_none().0, start.to_glib(), inpoint.to_glib(), duration.to_glib(), track_types.to_glib())) from_glib_none(ges_sys::ges_layer_add_asset(
self.as_ref().to_glib_none().0,
asset.as_ref().to_glib_none().0,
start.to_glib(),
inpoint.to_glib(),
duration.to_glib(),
track_types.to_glib(),
))
} }
} }
fn add_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError> { fn add_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_layer_add_clip(self.as_ref().to_glib_none().0, clip.as_ref().to_glib_none().0), "Failed to add clip") glib_result_from_gboolean!(
ges_sys::ges_layer_add_clip(
self.as_ref().to_glib_none().0,
clip.as_ref().to_glib_none().0
),
"Failed to add clip"
)
} }
} }
fn get_auto_transition(&self) -> bool { fn get_auto_transition(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_layer_get_auto_transition(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_layer_get_auto_transition(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_clips(&self) -> Vec<Clip> { fn get_clips(&self) -> Vec<Clip> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_layer_get_clips(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_layer_get_clips(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_clips_in_interval(&self, start: gst::ClockTime, end: gst::ClockTime) -> Vec<Clip> { fn get_clips_in_interval(&self, start: gst::ClockTime, end: gst::ClockTime) -> Vec<Clip> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_layer_get_clips_in_interval(self.as_ref().to_glib_none().0, start.to_glib(), end.to_glib())) FromGlibPtrContainer::from_glib_full(ges_sys::ges_layer_get_clips_in_interval(
self.as_ref().to_glib_none().0,
start.to_glib(),
end.to_glib(),
))
} }
} }
fn get_duration(&self) -> gst::ClockTime { fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_layer_get_duration(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_layer_get_duration(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_priority(&self) -> u32 { fn get_priority(&self) -> u32 {
unsafe { unsafe { ges_sys::ges_layer_get_priority(self.as_ref().to_glib_none().0) }
ges_sys::ges_layer_get_priority(self.as_ref().to_glib_none().0)
}
} }
fn get_timeline(&self) -> Option<Timeline> { fn get_timeline(&self) -> Option<Timeline> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_layer_get_timeline(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_layer_get_timeline(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_empty(&self) -> bool { fn is_empty(&self) -> bool {
unsafe { unsafe { from_glib(ges_sys::ges_layer_is_empty(self.as_ref().to_glib_none().0)) }
from_glib(ges_sys::ges_layer_is_empty(self.as_ref().to_glib_none().0))
}
} }
fn remove_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError> { fn remove_clip<P: IsA<Clip>>(&self, clip: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_layer_remove_clip(self.as_ref().to_glib_none().0, clip.as_ref().to_glib_none().0), "Failed to remove clip") glib_result_from_gboolean!(
ges_sys::ges_layer_remove_clip(
self.as_ref().to_glib_none().0,
clip.as_ref().to_glib_none().0
),
"Failed to remove clip"
)
} }
} }
fn set_auto_transition(&self, auto_transition: bool) { fn set_auto_transition(&self, auto_transition: bool) {
unsafe { unsafe {
ges_sys::ges_layer_set_auto_transition(self.as_ref().to_glib_none().0, auto_transition.to_glib()); ges_sys::ges_layer_set_auto_transition(
self.as_ref().to_glib_none().0,
auto_transition.to_glib(),
);
} }
} }
@ -157,63 +202,109 @@ impl<O: IsA<Layer>> LayerExt for O {
fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) { fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) {
unsafe { unsafe {
ges_sys::ges_layer_set_timeline(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_none().0); ges_sys::ges_layer_set_timeline(
self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_none().0,
);
} }
} }
fn connect_clip_added<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_clip_added<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn clip_added_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer) unsafe extern "C" fn clip_added_trampoline<P, F: Fn(&P, &Clip) + 'static>(
where P: IsA<Layer> this: *mut ges_sys::GESLayer,
clip: *mut ges_sys::GESClip,
f: glib_sys::gpointer,
) where
P: IsA<Layer>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip)) f(
&Layer::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(clip),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"clip-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(clip_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"clip-added\0".as_ptr() as *const _,
Some(transmute(clip_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_clip_removed<F: Fn(&Self, &Clip) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn clip_removed_trampoline<P, F: Fn(&P, &Clip) + 'static>(this: *mut ges_sys::GESLayer, clip: *mut ges_sys::GESClip, f: glib_sys::gpointer) unsafe extern "C" fn clip_removed_trampoline<P, F: Fn(&P, &Clip) + 'static>(
where P: IsA<Layer> this: *mut ges_sys::GESLayer,
clip: *mut ges_sys::GESClip,
f: glib_sys::gpointer,
) where
P: IsA<Layer>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(clip)) f(
&Layer::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(clip),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"clip-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(clip_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"clip-removed\0".as_ptr() as *const _,
Some(transmute(clip_removed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Layer> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESLayer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Layer>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast()) f(&Layer::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_auto_transition_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::auto-transition\0".as_ptr() as *const _,
Some(transmute(
notify_auto_transition_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESLayer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Layer> this: *mut ges_sys::GESLayer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Layer>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Layer::from_glib_borrow(this).unsafe_cast()) f(&Layer::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_priority_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::priority\0".as_ptr() as *const _,
Some(transmute(notify_priority_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

42
gstreamer-editing-services/src/auto/mod.rs
View file

@ -3,71 +3,71 @@
// DO NOT EDIT // DO NOT EDIT
mod asset; mod asset;
pub use self::asset::{Asset, AssetClass, NONE_ASSET};
pub use self::asset::AssetExt; pub use self::asset::AssetExt;
pub use self::asset::{Asset, AssetClass, NONE_ASSET};
mod base_effect; mod base_effect;
pub use self::base_effect::{BaseEffect, BaseEffectClass, NONE_BASE_EFFECT}; pub use self::base_effect::{BaseEffect, BaseEffectClass, NONE_BASE_EFFECT};
mod clip; mod clip;
pub use self::clip::{Clip, ClipClass, NONE_CLIP};
pub use self::clip::ClipExt; pub use self::clip::ClipExt;
pub use self::clip::{Clip, ClipClass, NONE_CLIP};
mod container; mod container;
pub use self::container::{Container, ContainerClass, NONE_CONTAINER};
pub use self::container::GESContainerExt; pub use self::container::GESContainerExt;
pub use self::container::{Container, ContainerClass, NONE_CONTAINER};
mod effect; mod effect;
pub use self::effect::{Effect, EffectClass, NONE_EFFECT};
pub use self::effect::EffectExt; pub use self::effect::EffectExt;
pub use self::effect::{Effect, EffectClass, NONE_EFFECT};
mod extractable; mod extractable;
pub use self::extractable::{Extractable, NONE_EXTRACTABLE};
pub use self::extractable::ExtractableExt; pub use self::extractable::ExtractableExt;
pub use self::extractable::{Extractable, NONE_EXTRACTABLE};
mod group; mod group;
pub use self::group::{Group, GroupClass, NONE_GROUP};
pub use self::group::GroupExt; pub use self::group::GroupExt;
pub use self::group::{Group, GroupClass, NONE_GROUP};
mod layer; mod layer;
pub use self::layer::{Layer, LayerClass, NONE_LAYER};
pub use self::layer::LayerExt; pub use self::layer::LayerExt;
pub use self::layer::{Layer, LayerClass, NONE_LAYER};
mod pipeline; mod pipeline;
pub use self::pipeline::{Pipeline, PipelineClass, NONE_PIPELINE};
pub use self::pipeline::GESPipelineExt; pub use self::pipeline::GESPipelineExt;
pub use self::pipeline::{Pipeline, PipelineClass, NONE_PIPELINE};
mod project; mod project;
pub use self::project::{Project, ProjectClass, NONE_PROJECT};
pub use self::project::ProjectExt; pub use self::project::ProjectExt;
pub use self::project::{Project, ProjectClass, NONE_PROJECT};
mod timeline; mod timeline;
pub use self::timeline::{Timeline, TimelineClass, NONE_TIMELINE};
pub use self::timeline::TimelineExt; pub use self::timeline::TimelineExt;
pub use self::timeline::{Timeline, TimelineClass, NONE_TIMELINE};
mod timeline_element; mod timeline_element;
pub use self::timeline_element::{TimelineElement, TimelineElementClass, NONE_TIMELINE_ELEMENT};
pub use self::timeline_element::TimelineElementExt; pub use self::timeline_element::TimelineElementExt;
pub use self::timeline_element::{TimelineElement, TimelineElementClass, NONE_TIMELINE_ELEMENT};
mod track; mod track;
pub use self::track::{Track, TrackClass, NONE_TRACK};
pub use self::track::GESTrackExt; pub use self::track::GESTrackExt;
pub use self::track::{Track, TrackClass, NONE_TRACK};
mod track_element; mod track_element;
pub use self::track_element::{TrackElement, TrackElementClass, NONE_TRACK_ELEMENT};
pub use self::track_element::TrackElementExt; pub use self::track_element::TrackElementExt;
pub use self::track_element::{TrackElement, TrackElementClass, NONE_TRACK_ELEMENT};
mod uri_clip; mod uri_clip;
pub use self::uri_clip::{UriClip, UriClipClass, NONE_URI_CLIP};
pub use self::uri_clip::UriClipExt; pub use self::uri_clip::UriClipExt;
pub use self::uri_clip::{UriClip, UriClipClass, NONE_URI_CLIP};
mod uri_clip_asset; mod uri_clip_asset;
pub use self::uri_clip_asset::{UriClipAsset, UriClipAssetClass, NONE_URI_CLIP_ASSET};
pub use self::uri_clip_asset::UriClipAssetExt; pub use self::uri_clip_asset::UriClipAssetExt;
pub use self::uri_clip_asset::{UriClipAsset, UriClipAssetClass, NONE_URI_CLIP_ASSET};
mod uri_source_asset; mod uri_source_asset;
pub use self::uri_source_asset::{UriSourceAsset, UriSourceAssetClass, NONE_URI_SOURCE_ASSET};
pub use self::uri_source_asset::UriSourceAssetExt; pub use self::uri_source_asset::UriSourceAssetExt;
pub use self::uri_source_asset::{UriSourceAsset, UriSourceAssetClass, NONE_URI_SOURCE_ASSET};
mod enums; mod enums;
pub use self::enums::Edge; pub use self::enums::Edge;
@ -81,18 +81,18 @@ pub use self::flags::TrackType;
pub mod traits { pub mod traits {
pub use super::AssetExt; pub use super::AssetExt;
pub use super::ClipExt; pub use super::ClipExt;
pub use super::GESContainerExt;
pub use super::EffectExt; pub use super::EffectExt;
pub use super::ExtractableExt; pub use super::ExtractableExt;
pub use super::GESContainerExt;
pub use super::GESPipelineExt;
pub use super::GESTrackExt;
pub use super::GroupExt; pub use super::GroupExt;
pub use super::LayerExt; pub use super::LayerExt;
pub use super::GESPipelineExt;
pub use super::ProjectExt; pub use super::ProjectExt;
pub use super::TimelineExt;
pub use super::TimelineElementExt; pub use super::TimelineElementExt;
pub use super::GESTrackExt; pub use super::TimelineExt;
pub use super::TrackElementExt; pub use super::TrackElementExt;
pub use super::UriClipExt;
pub use super::UriClipAssetExt; pub use super::UriClipAssetExt;
pub use super::UriClipExt;
pub use super::UriSourceAssetExt; pub use super::UriSourceAssetExt;
} }

284
gstreamer-editing-services/src/auto/pipeline.rs
View file

@ -2,18 +2,15 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Error;
use PipelineFlags;
use Timeline;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -21,6 +18,9 @@ use gst_pbutils;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Error;
use PipelineFlags;
use Timeline;
glib_wrapper! { glib_wrapper! {
pub struct Pipeline(Object<ges_sys::GESPipeline, ges_sys::GESPipelineClass, PipelineClass>) @extends gst::Pipeline, gst::Element, gst::Object; pub struct Pipeline(Object<ges_sys::GESPipeline, ges_sys::GESPipelineClass, PipelineClass>) @extends gst::Pipeline, gst::Element, gst::Object;
@ -33,9 +33,7 @@ glib_wrapper! {
impl Pipeline { impl Pipeline {
pub fn new() -> Pipeline { pub fn new() -> Pipeline {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_pipeline_new()) }
from_glib_none(ges_sys::ges_pipeline_new())
}
} }
} }
@ -62,11 +60,21 @@ pub trait GESPipelineExt: 'static {
fn preview_set_video_sink<P: IsA<gst::Element>>(&self, sink: &P); fn preview_set_video_sink<P: IsA<gst::Element>>(&self, sink: &P);
fn save_thumbnail(&self, width: i32, height: i32, format: &str, location: &str) -> Result<(), Error>; fn save_thumbnail(
&self,
width: i32,
height: i32,
format: &str,
location: &str,
) -> Result<(), Error>;
fn set_mode(&self, mode: PipelineFlags) -> Result<(), glib::error::BoolError>; fn set_mode(&self, mode: PipelineFlags) -> Result<(), glib::error::BoolError>;
fn set_render_settings<P: IsA<gst_pbutils::EncodingProfile>>(&self, output_uri: &str, profile: &P) -> Result<(), glib::error::BoolError>; fn set_render_settings<P: IsA<gst_pbutils::EncodingProfile>>(
&self,
output_uri: &str,
profile: &P,
) -> Result<(), glib::error::BoolError>;
fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError>; fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError>;
@ -88,7 +96,8 @@ pub trait GESPipelineExt: 'static {
fn set_property_video_sink(&self, video_sink: Option<&gst::Element>); fn set_property_video_sink(&self, video_sink: Option<&gst::Element>);
fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(&self, f: F)
-> SignalHandlerId;
fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
@ -96,7 +105,8 @@ pub trait GESPipelineExt: 'static {
fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(&self, f: F)
-> SignalHandlerId;
fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
} }
@ -104,104 +114,180 @@ pub trait GESPipelineExt: 'static {
impl<O: IsA<Pipeline>> GESPipelineExt for O { impl<O: IsA<Pipeline>> GESPipelineExt for O {
fn get_mode(&self) -> PipelineFlags { fn get_mode(&self) -> PipelineFlags {
unsafe { unsafe {
from_glib(ges_sys::ges_pipeline_get_mode(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_pipeline_get_mode(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_thumbnail(&self, caps: &gst::Caps) -> Option<gst::Sample> { fn get_thumbnail(&self, caps: &gst::Caps) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_pipeline_get_thumbnail(self.as_ref().to_glib_none().0, caps.to_glib_none().0)) from_glib_full(ges_sys::ges_pipeline_get_thumbnail(
self.as_ref().to_glib_none().0,
caps.to_glib_none().0,
))
} }
} }
fn get_thumbnail_rgb24(&self, width: i32, height: i32) -> Option<gst::Sample> { fn get_thumbnail_rgb24(&self, width: i32, height: i32) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_pipeline_get_thumbnail_rgb24(self.as_ref().to_glib_none().0, width, height)) from_glib_full(ges_sys::ges_pipeline_get_thumbnail_rgb24(
self.as_ref().to_glib_none().0,
width,
height,
))
} }
} }
fn preview_get_audio_sink(&self) -> Option<gst::Element> { fn preview_get_audio_sink(&self) -> Option<gst::Element> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_pipeline_preview_get_audio_sink(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_pipeline_preview_get_audio_sink(
self.as_ref().to_glib_none().0,
))
} }
} }
fn preview_get_video_sink(&self) -> Option<gst::Element> { fn preview_get_video_sink(&self) -> Option<gst::Element> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_pipeline_preview_get_video_sink(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_pipeline_preview_get_video_sink(
self.as_ref().to_glib_none().0,
))
} }
} }
fn preview_set_audio_sink<P: IsA<gst::Element>>(&self, sink: &P) { fn preview_set_audio_sink<P: IsA<gst::Element>>(&self, sink: &P) {
unsafe { unsafe {
ges_sys::ges_pipeline_preview_set_audio_sink(self.as_ref().to_glib_none().0, sink.as_ref().to_glib_none().0); ges_sys::ges_pipeline_preview_set_audio_sink(
self.as_ref().to_glib_none().0,
sink.as_ref().to_glib_none().0,
);
} }
} }
fn preview_set_video_sink<P: IsA<gst::Element>>(&self, sink: &P) { fn preview_set_video_sink<P: IsA<gst::Element>>(&self, sink: &P) {
unsafe { unsafe {
ges_sys::ges_pipeline_preview_set_video_sink(self.as_ref().to_glib_none().0, sink.as_ref().to_glib_none().0); ges_sys::ges_pipeline_preview_set_video_sink(
self.as_ref().to_glib_none().0,
sink.as_ref().to_glib_none().0,
);
} }
} }
fn save_thumbnail(&self, width: i32, height: i32, format: &str, location: &str) -> Result<(), Error> { fn save_thumbnail(
&self,
width: i32,
height: i32,
format: &str,
location: &str,
) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = ges_sys::ges_pipeline_save_thumbnail(self.as_ref().to_glib_none().0, width, height, format.to_glib_none().0, location.to_glib_none().0, &mut error); let _ = ges_sys::ges_pipeline_save_thumbnail(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
width,
height,
format.to_glib_none().0,
location.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn set_mode(&self, mode: PipelineFlags) -> Result<(), glib::error::BoolError> { fn set_mode(&self, mode: PipelineFlags) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_pipeline_set_mode(self.as_ref().to_glib_none().0, mode.to_glib()), "Failed to set mode") glib_result_from_gboolean!(
ges_sys::ges_pipeline_set_mode(self.as_ref().to_glib_none().0, mode.to_glib()),
"Failed to set mode"
)
} }
} }
fn set_render_settings<P: IsA<gst_pbutils::EncodingProfile>>(&self, output_uri: &str, profile: &P) -> Result<(), glib::error::BoolError> { fn set_render_settings<P: IsA<gst_pbutils::EncodingProfile>>(
&self,
output_uri: &str,
profile: &P,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_pipeline_set_render_settings(self.as_ref().to_glib_none().0, output_uri.to_glib_none().0, profile.as_ref().to_glib_none().0), "Failed to set render settings") glib_result_from_gboolean!(
ges_sys::ges_pipeline_set_render_settings(
self.as_ref().to_glib_none().0,
output_uri.to_glib_none().0,
profile.as_ref().to_glib_none().0
),
"Failed to set render settings"
)
} }
} }
fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError> { fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_pipeline_set_timeline(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_full()), "Failed to set timeline") glib_result_from_gboolean!(
ges_sys::ges_pipeline_set_timeline(
self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_full()
),
"Failed to set timeline"
)
} }
} }
fn get_property_audio_filter(&self) -> Option<gst::Element> { fn get_property_audio_filter(&self) -> Option<gst::Element> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Element as StaticType>::static_type()); let mut value = Value::from_type(<gst::Element as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"audio-filter\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"audio-filter\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
fn set_property_audio_filter(&self, audio_filter: Option<&gst::Element>) { fn set_property_audio_filter(&self, audio_filter: Option<&gst::Element>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"audio-filter\0".as_ptr() as *const _, Value::from(audio_filter).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"audio-filter\0".as_ptr() as *const _,
Value::from(audio_filter).to_glib_none().0,
);
} }
} }
fn get_property_audio_sink(&self) -> Option<gst::Element> { fn get_property_audio_sink(&self) -> Option<gst::Element> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Element as StaticType>::static_type()); let mut value = Value::from_type(<gst::Element as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"audio-sink\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"audio-sink\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
fn set_property_audio_sink(&self, audio_sink: Option<&gst::Element>) { fn set_property_audio_sink(&self, audio_sink: Option<&gst::Element>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"audio-sink\0".as_ptr() as *const _, Value::from(audio_sink).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"audio-sink\0".as_ptr() as *const _,
Value::from(audio_sink).to_glib_none().0,
);
} }
} }
fn get_property_timeline(&self) -> Option<Timeline> { fn get_property_timeline(&self) -> Option<Timeline> {
unsafe { unsafe {
let mut value = Value::from_type(<Timeline as StaticType>::static_type()); let mut value = Value::from_type(<Timeline as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"timeline\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"timeline\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -209,112 +295,186 @@ impl<O: IsA<Pipeline>> GESPipelineExt for O {
fn get_property_video_filter(&self) -> Option<gst::Element> { fn get_property_video_filter(&self) -> Option<gst::Element> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Element as StaticType>::static_type()); let mut value = Value::from_type(<gst::Element as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"video-filter\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"video-filter\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
fn set_property_video_filter(&self, video_filter: Option<&gst::Element>) { fn set_property_video_filter(&self, video_filter: Option<&gst::Element>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"video-filter\0".as_ptr() as *const _, Value::from(video_filter).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"video-filter\0".as_ptr() as *const _,
Value::from(video_filter).to_glib_none().0,
);
} }
} }
fn get_property_video_sink(&self) -> Option<gst::Element> { fn get_property_video_sink(&self) -> Option<gst::Element> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Element as StaticType>::static_type()); let mut value = Value::from_type(<gst::Element as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"video-sink\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"video-sink\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
fn set_property_video_sink(&self, video_sink: Option<&gst::Element>) { fn set_property_video_sink(&self, video_sink: Option<&gst::Element>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"video-sink\0".as_ptr() as *const _, Value::from(video_sink).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"video-sink\0".as_ptr() as *const _,
Value::from(video_sink).to_glib_none().0,
);
} }
} }
fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_audio_filter_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_audio_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Pipeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_audio_filter_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::audio-filter\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_audio_filter_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::audio-filter\0".as_ptr() as *const _,
Some(transmute(
notify_audio_filter_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_audio_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_audio_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_audio_sink_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Pipeline> this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::audio-sink\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_audio_sink_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::audio-sink\0".as_ptr() as *const _,
Some(transmute(notify_audio_sink_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mode_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_mode_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Pipeline> this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mode\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_mode_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::mode\0".as_ptr() as *const _,
Some(transmute(notify_mode_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Pipeline> this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_timeline_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::timeline\0".as_ptr() as *const _,
Some(transmute(notify_timeline_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_video_filter_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_video_filter_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Pipeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_video_filter_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-filter\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_video_filter_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::video-filter\0".as_ptr() as *const _,
Some(transmute(
notify_video_filter_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_video_sink_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_video_sink_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESPipeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_video_sink_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Pipeline> this: *mut ges_sys::GESPipeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Pipeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Pipeline::from_glib_borrow(this).unsafe_cast()) f(&Pipeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_video_sink_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::video-sink\0".as_ptr() as *const _,
Some(transmute(notify_video_sink_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

304
gstreamer-editing-services/src/auto/project.rs
View file

@ -2,23 +2,23 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Asset;
use Error;
use Timeline;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::GString;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use glib_sys; use glib_sys;
use gst_pbutils; use gst_pbutils;
use libc; use libc;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Asset;
use Error;
use Timeline;
glib_wrapper! { glib_wrapper! {
pub struct Project(Object<ges_sys::GESProject, ges_sys::GESProjectClass, ProjectClass>) @extends Asset; pub struct Project(Object<ges_sys::GESProject, ges_sys::GESProjectClass, ProjectClass>) @extends Asset;
@ -31,9 +31,7 @@ glib_wrapper! {
impl Project { impl Project {
pub fn new(uri: Option<&str>) -> Project { pub fn new(uri: Option<&str>) -> Project {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(ges_sys::ges_project_new(uri.to_glib_none().0)) }
from_glib_full(ges_sys::ges_project_new(uri.to_glib_none().0))
}
} }
} }
@ -42,11 +40,18 @@ pub const NONE_PROJECT: Option<&Project> = None;
pub trait ProjectExt: 'static { pub trait ProjectExt: 'static {
fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> bool; fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> bool;
fn add_encoding_profile<P: IsA<gst_pbutils::EncodingProfile>>(&self, profile: &P) -> Result<(), glib::error::BoolError>; fn add_encoding_profile<P: IsA<gst_pbutils::EncodingProfile>>(
&self,
profile: &P,
) -> Result<(), glib::error::BoolError>;
fn create_asset(&self, id: Option<&str>, extractable_type: glib::types::Type) -> bool; fn create_asset(&self, id: Option<&str>, extractable_type: glib::types::Type) -> bool;
fn create_asset_sync(&self, id: Option<&str>, extractable_type: glib::types::Type) -> Result<Option<Asset>, Error>; fn create_asset_sync(
&self,
id: Option<&str>,
extractable_type: glib::types::Type,
) -> Result<Option<Asset>, Error>;
fn get_asset(&self, id: &str, extractable_type: glib::types::Type) -> Option<Asset>; fn get_asset(&self, id: &str, extractable_type: glib::types::Type) -> Option<Asset>;
@ -62,7 +67,13 @@ pub trait ProjectExt: 'static {
fn remove_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError>; fn remove_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError>;
fn save<P: IsA<Timeline>, Q: IsA<Asset>>(&self, timeline: &P, uri: &str, formatter_asset: Option<&Q>, overwrite: bool) -> Result<(), Error>; fn save<P: IsA<Timeline>, Q: IsA<Asset>>(
&self,
timeline: &P,
uri: &str,
formatter_asset: Option<&Q>,
overwrite: bool,
) -> Result<(), Error>;
fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId;
@ -70,173 +81,336 @@ pub trait ProjectExt: 'static {
fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(&self, f: F) -> SignalHandlerId; fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<Project>> ProjectExt for O { impl<O: IsA<Project>> ProjectExt for O {
fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> bool { fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_project_add_asset(self.as_ref().to_glib_none().0, asset.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_project_add_asset(
self.as_ref().to_glib_none().0,
asset.as_ref().to_glib_none().0,
))
} }
} }
fn add_encoding_profile<P: IsA<gst_pbutils::EncodingProfile>>(&self, profile: &P) -> Result<(), glib::error::BoolError> { fn add_encoding_profile<P: IsA<gst_pbutils::EncodingProfile>>(
&self,
profile: &P,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_project_add_encoding_profile(self.as_ref().to_glib_none().0, profile.as_ref().to_glib_none().0), "Failed to add profile") glib_result_from_gboolean!(
ges_sys::ges_project_add_encoding_profile(
self.as_ref().to_glib_none().0,
profile.as_ref().to_glib_none().0
),
"Failed to add profile"
)
} }
} }
fn create_asset(&self, id: Option<&str>, extractable_type: glib::types::Type) -> bool { fn create_asset(&self, id: Option<&str>, extractable_type: glib::types::Type) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_project_create_asset(self.as_ref().to_glib_none().0, id.to_glib_none().0, extractable_type.to_glib())) from_glib(ges_sys::ges_project_create_asset(
self.as_ref().to_glib_none().0,
id.to_glib_none().0,
extractable_type.to_glib(),
))
} }
} }
fn create_asset_sync(&self, id: Option<&str>, extractable_type: glib::types::Type) -> Result<Option<Asset>, Error> { fn create_asset_sync(
&self,
id: Option<&str>,
extractable_type: glib::types::Type,
) -> Result<Option<Asset>, Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_project_create_asset_sync(self.as_ref().to_glib_none().0, id.to_glib_none().0, extractable_type.to_glib(), &mut error); let ret = ges_sys::ges_project_create_asset_sync(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
id.to_glib_none().0,
extractable_type.to_glib(),
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
fn get_asset(&self, id: &str, extractable_type: glib::types::Type) -> Option<Asset> { fn get_asset(&self, id: &str, extractable_type: glib::types::Type) -> Option<Asset> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_project_get_asset(self.as_ref().to_glib_none().0, id.to_glib_none().0, extractable_type.to_glib())) from_glib_full(ges_sys::ges_project_get_asset(
self.as_ref().to_glib_none().0,
id.to_glib_none().0,
extractable_type.to_glib(),
))
} }
} }
fn get_loading_assets(&self) -> Vec<Asset> { fn get_loading_assets(&self) -> Vec<Asset> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_project_get_loading_assets(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_project_get_loading_assets(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_uri(&self) -> Option<GString> { fn get_uri(&self) -> Option<GString> {
unsafe { unsafe { from_glib_full(ges_sys::ges_project_get_uri(self.as_ref().to_glib_none().0)) }
from_glib_full(ges_sys::ges_project_get_uri(self.as_ref().to_glib_none().0))
}
} }
fn list_assets(&self, filter: glib::types::Type) -> Vec<Asset> { fn list_assets(&self, filter: glib::types::Type) -> Vec<Asset> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_project_list_assets(self.as_ref().to_glib_none().0, filter.to_glib())) FromGlibPtrContainer::from_glib_full(ges_sys::ges_project_list_assets(
self.as_ref().to_glib_none().0,
filter.to_glib(),
))
} }
} }
fn list_encoding_profiles(&self) -> Vec<gst_pbutils::EncodingProfile> { fn list_encoding_profiles(&self) -> Vec<gst_pbutils::EncodingProfile> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(ges_sys::ges_project_list_encoding_profiles(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_none(ges_sys::ges_project_list_encoding_profiles(
self.as_ref().to_glib_none().0,
))
} }
} }
fn load<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), Error> { fn load<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = ges_sys::ges_project_load(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_none().0, &mut error); let _ = ges_sys::ges_project_load(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn remove_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError> { fn remove_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_project_remove_asset(self.as_ref().to_glib_none().0, asset.as_ref().to_glib_none().0), "Failed to remove asset") glib_result_from_gboolean!(
ges_sys::ges_project_remove_asset(
self.as_ref().to_glib_none().0,
asset.as_ref().to_glib_none().0
),
"Failed to remove asset"
)
} }
} }
fn save<P: IsA<Timeline>, Q: IsA<Asset>>(&self, timeline: &P, uri: &str, formatter_asset: Option<&Q>, overwrite: bool) -> Result<(), Error> { fn save<P: IsA<Timeline>, Q: IsA<Asset>>(
&self,
timeline: &P,
uri: &str,
formatter_asset: Option<&Q>,
overwrite: bool,
) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = ges_sys::ges_project_save(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_none().0, uri.to_glib_none().0, formatter_asset.map(|p| p.as_ref()).to_glib_none().0, overwrite.to_glib(), &mut error); let _ = ges_sys::ges_project_save(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_none().0,
uri.to_glib_none().0,
formatter_asset.map(|p| p.as_ref()).to_glib_none().0,
overwrite.to_glib(),
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_added<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_added_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) unsafe extern "C" fn asset_added_trampoline<P, F: Fn(&P, &Asset) + 'static>(
where P: IsA<Project> this: *mut ges_sys::GESProject,
asset: *mut ges_sys::GESAsset,
f: glib_sys::gpointer,
) where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset)) f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(asset),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(asset_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"asset-added\0".as_ptr() as *const _,
Some(transmute(asset_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_asset_loading<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_loading<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_loading_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) unsafe extern "C" fn asset_loading_trampoline<P, F: Fn(&P, &Asset) + 'static>(
where P: IsA<Project> this: *mut ges_sys::GESProject,
asset: *mut ges_sys::GESAsset,
f: glib_sys::gpointer,
) where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset)) f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(asset),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-loading\0".as_ptr() as *const _, connect_raw(
Some(transmute(asset_loading_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"asset-loading\0".as_ptr() as *const _,
Some(transmute(asset_loading_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_asset_removed<F: Fn(&Self, &Asset) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn asset_removed_trampoline<P, F: Fn(&P, &Asset) + 'static>(this: *mut ges_sys::GESProject, asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) unsafe extern "C" fn asset_removed_trampoline<P, F: Fn(&P, &Asset) + 'static>(
where P: IsA<Project> this: *mut ges_sys::GESProject,
asset: *mut ges_sys::GESAsset,
f: glib_sys::gpointer,
) where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(asset)) f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(asset),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"asset-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(asset_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"asset-removed\0".as_ptr() as *const _,
Some(transmute(asset_removed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_error_loading_asset<F: Fn(&Self, &Error, &str, glib::types::Type) + 'static>(
unsafe extern "C" fn error_loading_asset_trampoline<P, F: Fn(&P, &Error, &str, glib::types::Type) + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, id: *mut libc::c_char, extractable_type: glib_sys::GType, f: glib_sys::gpointer) &self,
where P: IsA<Project> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn error_loading_asset_trampoline<
P,
F: Fn(&P, &Error, &str, glib::types::Type) + 'static,
>(
this: *mut ges_sys::GESProject,
error: *mut glib_sys::GError,
id: *mut libc::c_char,
extractable_type: glib_sys::GType,
f: glib_sys::gpointer,
) where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &GString::from_glib_borrow(id), from_glib(extractable_type)) f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(error),
&GString::from_glib_borrow(id),
from_glib(extractable_type),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"error-loading-asset\0".as_ptr() as *const _, connect_raw(
Some(transmute(error_loading_asset_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"error-loading-asset\0".as_ptr() as *const _,
Some(transmute(
error_loading_asset_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_loaded<F: Fn(&Self, &Timeline) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn loaded_trampoline<P, F: Fn(&P, &Timeline) + 'static>(this: *mut ges_sys::GESProject, timeline: *mut ges_sys::GESTimeline, f: glib_sys::gpointer) unsafe extern "C" fn loaded_trampoline<P, F: Fn(&P, &Timeline) + 'static>(
where P: IsA<Project> this: *mut ges_sys::GESProject,
timeline: *mut ges_sys::GESTimeline,
f: glib_sys::gpointer,
) where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(timeline)) f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(timeline),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"loaded\0".as_ptr() as *const _, connect_raw(
Some(transmute(loaded_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"loaded\0".as_ptr() as *const _,
Some(transmute(loaded_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(&self, f: F) -> SignalHandlerId { fn connect_missing_uri<F: Fn(&Self, &Error, &Asset) -> Option<GString> + 'static>(
unsafe extern "C" fn missing_uri_trampoline<P, F: Fn(&P, &Error, &Asset) -> Option<GString> + 'static>(this: *mut ges_sys::GESProject, error: *mut glib_sys::GError, wrong_asset: *mut ges_sys::GESAsset, f: glib_sys::gpointer) -> *mut libc::c_char &self,
where P: IsA<Project> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn missing_uri_trampoline<
P,
F: Fn(&P, &Error, &Asset) -> Option<GString> + 'static,
>(
this: *mut ges_sys::GESProject,
error: *mut glib_sys::GError,
wrong_asset: *mut ges_sys::GESAsset,
f: glib_sys::gpointer,
) -> *mut libc::c_char
where
P: IsA<Project>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Project::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(error), &from_glib_borrow(wrong_asset)).to_glib_full() f(
&Project::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(error),
&from_glib_borrow(wrong_asset),
)
.to_glib_full()
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"missing-uri\0".as_ptr() as *const _, connect_raw(
Some(transmute(missing_uri_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"missing-uri\0".as_ptr() as *const _,
Some(transmute(missing_uri_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

490
gstreamer-editing-services/src/auto/timeline.rs
View file

@ -2,6 +2,18 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib_sys;
use gst;
use std::boxed::Box as Box_;
use std::mem::transmute;
use std::ptr;
use Asset; use Asset;
use Error; use Error;
use Extractable; use Extractable;
@ -10,18 +22,6 @@ use Layer;
use TimelineElement; use TimelineElement;
use Track; use Track;
use TrackElement; use TrackElement;
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys;
use gst;
use std::boxed::Box as Box_;
use std::mem::transmute;
use std::ptr;
glib_wrapper! { glib_wrapper! {
pub struct Timeline(Object<ges_sys::GESTimeline, ges_sys::GESTimelineClass, TimelineClass>) @extends gst::Element, gst::Object, @implements Extractable; pub struct Timeline(Object<ges_sys::GESTimeline, ges_sys::GESTimelineClass, TimelineClass>) @extends gst::Element, gst::Object, @implements Extractable;
@ -34,16 +34,12 @@ glib_wrapper! {
impl Timeline { impl Timeline {
pub fn new() -> Timeline { pub fn new() -> Timeline {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_timeline_new()) }
from_glib_none(ges_sys::ges_timeline_new())
}
} }
pub fn new_audio_video() -> Timeline { pub fn new_audio_video() -> Timeline {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_timeline_new_audio_video()) }
from_glib_none(ges_sys::ges_timeline_new_audio_video())
}
} }
pub fn new_from_uri(uri: &str) -> Result<Option<Timeline>, Error> { pub fn new_from_uri(uri: &str) -> Result<Option<Timeline>, Error> {
@ -51,7 +47,11 @@ impl Timeline {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_timeline_new_from_uri(uri.to_glib_none().0, &mut error); let ret = ges_sys::ges_timeline_new_from_uri(uri.to_glib_none().0, &mut error);
if error.is_null() { Ok(from_glib_none(ret)) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(from_glib_none(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
} }
@ -99,15 +99,29 @@ pub trait TimelineExt: 'static {
fn load_from_uri(&self, uri: &str) -> Result<(), Error>; fn load_from_uri(&self, uri: &str) -> Result<(), Error>;
fn move_layer<P: IsA<Layer>>(&self, layer: &P, new_layer_priority: u32) -> Result<(), glib::error::BoolError>; fn move_layer<P: IsA<Layer>>(
&self,
layer: &P,
new_layer_priority: u32,
) -> Result<(), glib::error::BoolError>;
fn paste_element<P: IsA<TimelineElement>>(&self, element: &P, position: gst::ClockTime, layer_priority: i32) -> Option<TimelineElement>; fn paste_element<P: IsA<TimelineElement>>(
&self,
element: &P,
position: gst::ClockTime,
layer_priority: i32,
) -> Option<TimelineElement>;
fn remove_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError>; fn remove_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError>;
fn remove_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError>; fn remove_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError>;
fn save_to_uri<P: IsA<Asset>>(&self, uri: &str, formatter_asset: Option<&P>, overwrite: bool) -> Result<(), Error>; fn save_to_uri<P: IsA<Asset>>(
&self,
uri: &str,
formatter_asset: Option<&P>,
overwrite: bool,
) -> Result<(), Error>;
fn set_auto_transition(&self, auto_transition: bool); fn set_auto_transition(&self, auto_transition: bool);
@ -125,195 +139,327 @@ pub trait TimelineExt: 'static {
//fn connect_select_tracks_for_object<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId; //fn connect_select_tracks_for_object<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId;
fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<Timeline>> TimelineExt for O { impl<O: IsA<Timeline>> TimelineExt for O {
fn add_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> { fn add_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_add_layer(self.as_ref().to_glib_none().0, layer.as_ref().to_glib_none().0), "Failed to add layer") glib_result_from_gboolean!(
ges_sys::ges_timeline_add_layer(
self.as_ref().to_glib_none().0,
layer.as_ref().to_glib_none().0
),
"Failed to add layer"
)
} }
} }
fn add_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError> { fn add_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_add_track(self.as_ref().to_glib_none().0, track.as_ref().to_glib_full()), "Failed to add track") glib_result_from_gboolean!(
ges_sys::ges_timeline_add_track(
self.as_ref().to_glib_none().0,
track.as_ref().to_glib_full()
),
"Failed to add track"
)
} }
} }
fn append_layer(&self) -> Layer { fn append_layer(&self) -> Layer {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_append_layer(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_timeline_append_layer(
self.as_ref().to_glib_none().0,
))
} }
} }
fn commit(&self) -> bool { fn commit(&self) -> bool {
unsafe { unsafe { from_glib(ges_sys::ges_timeline_commit(self.as_ref().to_glib_none().0)) }
from_glib(ges_sys::ges_timeline_commit(self.as_ref().to_glib_none().0))
}
} }
fn commit_sync(&self) -> bool { fn commit_sync(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_commit_sync(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_commit_sync(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_auto_transition(&self) -> bool { fn get_auto_transition(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_get_auto_transition(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_get_auto_transition(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_duration(&self) -> gst::ClockTime { fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_get_duration(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_get_duration(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_element(&self, name: &str) -> Option<TimelineElement> { fn get_element(&self, name: &str) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_get_element(self.as_ref().to_glib_none().0, name.to_glib_none().0)) from_glib_full(ges_sys::ges_timeline_get_element(
self.as_ref().to_glib_none().0,
name.to_glib_none().0,
))
} }
} }
fn get_groups(&self) -> Vec<Group> { fn get_groups(&self) -> Vec<Group> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(ges_sys::ges_timeline_get_groups(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_none(ges_sys::ges_timeline_get_groups(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_layer(&self, priority: u32) -> Option<Layer> { fn get_layer(&self, priority: u32) -> Option<Layer> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_get_layer(self.as_ref().to_glib_none().0, priority)) from_glib_full(ges_sys::ges_timeline_get_layer(
self.as_ref().to_glib_none().0,
priority,
))
} }
} }
fn get_layers(&self) -> Vec<Layer> { fn get_layers(&self) -> Vec<Layer> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_timeline_get_layers(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_timeline_get_layers(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_pad_for_track<P: IsA<Track>>(&self, track: &P) -> Option<gst::Pad> { fn get_pad_for_track<P: IsA<Track>>(&self, track: &P) -> Option<gst::Pad> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_get_pad_for_track(self.as_ref().to_glib_none().0, track.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_timeline_get_pad_for_track(
self.as_ref().to_glib_none().0,
track.as_ref().to_glib_none().0,
))
} }
} }
fn get_snapping_distance(&self) -> gst::ClockTime { fn get_snapping_distance(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_get_snapping_distance(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_get_snapping_distance(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_track_for_pad<P: IsA<gst::Pad>>(&self, pad: &P) -> Option<Track> { fn get_track_for_pad<P: IsA<gst::Pad>>(&self, pad: &P) -> Option<Track> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_get_track_for_pad(self.as_ref().to_glib_none().0, pad.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_timeline_get_track_for_pad(
self.as_ref().to_glib_none().0,
pad.as_ref().to_glib_none().0,
))
} }
} }
fn get_tracks(&self) -> Vec<Track> { fn get_tracks(&self) -> Vec<Track> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_timeline_get_tracks(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_timeline_get_tracks(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_empty(&self) -> bool { fn is_empty(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_is_empty(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_is_empty(
self.as_ref().to_glib_none().0,
))
} }
} }
fn load_from_uri(&self, uri: &str) -> Result<(), Error> { fn load_from_uri(&self, uri: &str) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = ges_sys::ges_timeline_load_from_uri(self.as_ref().to_glib_none().0, uri.to_glib_none().0, &mut error); let _ = ges_sys::ges_timeline_load_from_uri(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
uri.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn move_layer<P: IsA<Layer>>(&self, layer: &P, new_layer_priority: u32) -> Result<(), glib::error::BoolError> { fn move_layer<P: IsA<Layer>>(
&self,
layer: &P,
new_layer_priority: u32,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_move_layer(self.as_ref().to_glib_none().0, layer.as_ref().to_glib_none().0, new_layer_priority), "Failed to move layer") glib_result_from_gboolean!(
ges_sys::ges_timeline_move_layer(
self.as_ref().to_glib_none().0,
layer.as_ref().to_glib_none().0,
new_layer_priority
),
"Failed to move layer"
)
} }
} }
fn paste_element<P: IsA<TimelineElement>>(&self, element: &P, position: gst::ClockTime, layer_priority: i32) -> Option<TimelineElement> { fn paste_element<P: IsA<TimelineElement>>(
&self,
element: &P,
position: gst::ClockTime,
layer_priority: i32,
) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_paste_element(self.as_ref().to_glib_none().0, element.as_ref().to_glib_none().0, position.to_glib(), layer_priority)) from_glib_none(ges_sys::ges_timeline_paste_element(
self.as_ref().to_glib_none().0,
element.as_ref().to_glib_none().0,
position.to_glib(),
layer_priority,
))
} }
} }
fn remove_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> { fn remove_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_remove_layer(self.as_ref().to_glib_none().0, layer.as_ref().to_glib_none().0), "Failed to remove layer") glib_result_from_gboolean!(
ges_sys::ges_timeline_remove_layer(
self.as_ref().to_glib_none().0,
layer.as_ref().to_glib_none().0
),
"Failed to remove layer"
)
} }
} }
fn remove_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError> { fn remove_track<P: IsA<Track>>(&self, track: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_remove_track(self.as_ref().to_glib_none().0, track.as_ref().to_glib_none().0), "Failed to remove track") glib_result_from_gboolean!(
ges_sys::ges_timeline_remove_track(
self.as_ref().to_glib_none().0,
track.as_ref().to_glib_none().0
),
"Failed to remove track"
)
} }
} }
fn save_to_uri<P: IsA<Asset>>(&self, uri: &str, formatter_asset: Option<&P>, overwrite: bool) -> Result<(), Error> { fn save_to_uri<P: IsA<Asset>>(
&self,
uri: &str,
formatter_asset: Option<&P>,
overwrite: bool,
) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = ges_sys::ges_timeline_save_to_uri(self.as_ref().to_glib_none().0, uri.to_glib_none().0, formatter_asset.map(|p| p.as_ref()).to_glib_none().0, overwrite.to_glib(), &mut error); let _ = ges_sys::ges_timeline_save_to_uri(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
uri.to_glib_none().0,
formatter_asset.map(|p| p.as_ref()).to_glib_none().0,
overwrite.to_glib(),
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn set_auto_transition(&self, auto_transition: bool) { fn set_auto_transition(&self, auto_transition: bool) {
unsafe { unsafe {
ges_sys::ges_timeline_set_auto_transition(self.as_ref().to_glib_none().0, auto_transition.to_glib()); ges_sys::ges_timeline_set_auto_transition(
self.as_ref().to_glib_none().0,
auto_transition.to_glib(),
);
} }
} }
fn set_snapping_distance(&self, snapping_distance: gst::ClockTime) { fn set_snapping_distance(&self, snapping_distance: gst::ClockTime) {
unsafe { unsafe {
ges_sys::ges_timeline_set_snapping_distance(self.as_ref().to_glib_none().0, snapping_distance.to_glib()); ges_sys::ges_timeline_set_snapping_distance(
self.as_ref().to_glib_none().0,
snapping_distance.to_glib(),
);
} }
} }
fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, f: glib_sys::gpointer) unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast()) f(&Timeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _, connect_raw(
Some(transmute(commited_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"commited\0".as_ptr() as *const _,
Some(transmute(commited_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_group_added<F: Fn(&Self, &Group) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_group_added<F: Fn(&Self, &Group) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn group_added_trampoline<P, F: Fn(&P, &Group) + 'static>(this: *mut ges_sys::GESTimeline, group: *mut ges_sys::GESGroup, f: glib_sys::gpointer) unsafe extern "C" fn group_added_trampoline<P, F: Fn(&P, &Group) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
group: *mut ges_sys::GESGroup,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(group)) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(group),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"group-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(group_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"group-added\0".as_ptr() as *const _,
Some(transmute(group_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
@ -322,30 +468,52 @@ impl<O: IsA<Timeline>> TimelineExt for O {
//} //}
fn connect_layer_added<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_layer_added<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn layer_added_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer) unsafe extern "C" fn layer_added_trampoline<P, F: Fn(&P, &Layer) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
layer: *mut ges_sys::GESLayer,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer)) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(layer),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"layer-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(layer_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"layer-added\0".as_ptr() as *const _,
Some(transmute(layer_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_layer_removed<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_layer_removed<F: Fn(&Self, &Layer) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn layer_removed_trampoline<P, F: Fn(&P, &Layer) + 'static>(this: *mut ges_sys::GESTimeline, layer: *mut ges_sys::GESLayer, f: glib_sys::gpointer) unsafe extern "C" fn layer_removed_trampoline<P, F: Fn(&P, &Layer) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
layer: *mut ges_sys::GESLayer,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(layer)) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(layer),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"layer-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(layer_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"layer-removed\0".as_ptr() as *const _,
Some(transmute(layer_removed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
@ -353,101 +521,199 @@ impl<O: IsA<Timeline>> TimelineExt for O {
// Empty ctype return value *.PtrArray TypeId { ns_id: 1, id: 16 } // Empty ctype return value *.PtrArray TypeId { ns_id: 1, id: 16 }
//} //}
fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_snapping_ended<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(
unsafe extern "C" fn snapping_ended_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer) &self,
where P: IsA<Timeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn snapping_ended_trampoline<
P,
F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static,
>(
this: *mut ges_sys::GESTimeline,
obj1: *mut ges_sys::GESTrackElement,
obj2: *mut ges_sys::GESTrackElement,
position: u64,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(obj1),
&from_glib_borrow(obj2),
position,
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"snapping-ended\0".as_ptr() as *const _, connect_raw(
Some(transmute(snapping_ended_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"snapping-ended\0".as_ptr() as *const _,
Some(transmute(snapping_ended_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_snapping_started<F: Fn(&Self, &TrackElement, &TrackElement, u64) + 'static>(
unsafe extern "C" fn snapping_started_trampoline<P, F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static>(this: *mut ges_sys::GESTimeline, obj1: *mut ges_sys::GESTrackElement, obj2: *mut ges_sys::GESTrackElement, position: u64, f: glib_sys::gpointer) &self,
where P: IsA<Timeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn snapping_started_trampoline<
P,
F: Fn(&P, &TrackElement, &TrackElement, u64) + 'static,
>(
this: *mut ges_sys::GESTimeline,
obj1: *mut ges_sys::GESTrackElement,
obj2: *mut ges_sys::GESTrackElement,
position: u64,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(obj1), &from_glib_borrow(obj2), position) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(obj1),
&from_glib_borrow(obj2),
position,
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"snapping-started\0".as_ptr() as *const _, connect_raw(
Some(transmute(snapping_started_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"snapping-started\0".as_ptr() as *const _,
Some(transmute(snapping_started_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_added<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_added_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer) unsafe extern "C" fn track_added_trampoline<P, F: Fn(&P, &Track) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
track: *mut ges_sys::GESTrack,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track)) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(track),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(track_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"track-added\0".as_ptr() as *const _,
Some(transmute(track_added_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_removed<F: Fn(&Self, &Track) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn track_removed_trampoline<P, F: Fn(&P, &Track) + 'static>(this: *mut ges_sys::GESTimeline, track: *mut ges_sys::GESTrack, f: glib_sys::gpointer) unsafe extern "C" fn track_removed_trampoline<P, F: Fn(&P, &Track) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
track: *mut ges_sys::GESTrack,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(track)) f(
&Timeline::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(track),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(track_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"track-removed\0".as_ptr() as *const _,
Some(transmute(track_removed_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_auto_transition_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Timeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_auto_transition_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESTimeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast()) f(&Timeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::auto-transition\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_auto_transition_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::auto-transition\0".as_ptr() as *const _,
Some(transmute(
notify_auto_transition_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Timeline> this: *mut ges_sys::GESTimeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast()) f(&Timeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_snapping_distance_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_snapping_distance_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimeline, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Timeline> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_snapping_distance_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESTimeline,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Timeline>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Timeline::from_glib_borrow(this).unsafe_cast()) f(&Timeline::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::snapping-distance\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_snapping_distance_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::snapping-distance\0".as_ptr() as *const _,
Some(transmute(
notify_snapping_distance_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

342
gstreamer-editing-services/src/auto/timeline_element.rs
View file

@ -2,24 +2,24 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Extractable;
use Timeline;
use TrackType;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use Extractable;
use Timeline;
use TrackType;
glib_wrapper! { glib_wrapper! {
pub struct TimelineElement(Object<ges_sys::GESTimelineElement, ges_sys::GESTimelineElementClass, TimelineElementClass>) @implements Extractable; pub struct TimelineElement(Object<ges_sys::GESTimelineElement, ges_sys::GESTimelineElementClass, TimelineElementClass>) @implements Extractable;
@ -98,7 +98,8 @@ pub trait TimelineElementExt: 'static {
fn set_name(&self, name: Option<&str>) -> Result<(), glib::error::BoolError>; fn set_name(&self, name: Option<&str>) -> Result<(), glib::error::BoolError>;
fn set_parent<P: IsA<TimelineElement>>(&self, parent: &P) -> Result<(), glib::error::BoolError>; fn set_parent<P: IsA<TimelineElement>>(&self, parent: &P)
-> Result<(), glib::error::BoolError>;
fn set_priority(&self, priority: u32) -> bool; fn set_priority(&self, priority: u32) -> bool;
@ -122,7 +123,8 @@ pub trait TimelineElementExt: 'static {
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F)
-> SignalHandlerId;
fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
@ -144,7 +146,10 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
fn copy(&self, deep: bool) -> Option<TimelineElement> { fn copy(&self, deep: bool) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_element_copy(self.as_ref().to_glib_none().0, deep.to_glib())) from_glib_none(ges_sys::ges_timeline_element_copy(
self.as_ref().to_glib_none().0,
deep.to_glib(),
))
} }
} }
@ -166,67 +171,81 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
fn get_duration(&self) -> gst::ClockTime { fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_get_duration(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_element_get_duration(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_inpoint(&self) -> gst::ClockTime { fn get_inpoint(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_get_inpoint(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_element_get_inpoint(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_layer_priority(&self) -> u32 { fn get_layer_priority(&self) -> u32 {
unsafe { unsafe { ges_sys::ges_timeline_element_get_layer_priority(self.as_ref().to_glib_none().0) }
ges_sys::ges_timeline_element_get_layer_priority(self.as_ref().to_glib_none().0)
}
} }
fn get_max_duration(&self) -> gst::ClockTime { fn get_max_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_get_max_duration(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_element_get_max_duration(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_name(&self) -> Option<GString> { fn get_name(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_element_get_name(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_timeline_element_get_name(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_parent(&self) -> Option<TimelineElement> { fn get_parent(&self) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_element_get_parent(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_timeline_element_get_parent(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_priority(&self) -> u32 { fn get_priority(&self) -> u32 {
unsafe { unsafe { ges_sys::ges_timeline_element_get_priority(self.as_ref().to_glib_none().0) }
ges_sys::ges_timeline_element_get_priority(self.as_ref().to_glib_none().0)
}
} }
fn get_start(&self) -> gst::ClockTime { fn get_start(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_get_start(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_element_get_start(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_timeline(&self) -> Option<Timeline> { fn get_timeline(&self) -> Option<Timeline> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_element_get_timeline(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_timeline_element_get_timeline(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_toplevel_parent(&self) -> Option<TimelineElement> { fn get_toplevel_parent(&self) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_full(ges_sys::ges_timeline_element_get_toplevel_parent(self.as_ref().to_glib_none().0)) from_glib_full(ges_sys::ges_timeline_element_get_toplevel_parent(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_track_types(&self) -> TrackType { fn get_track_types(&self) -> TrackType {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_get_track_types(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_timeline_element_get_track_types(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -240,7 +259,10 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
fn paste(&self, paste_position: gst::ClockTime) -> Option<TimelineElement> { fn paste(&self, paste_position: gst::ClockTime) -> Option<TimelineElement> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_timeline_element_paste(self.as_ref().to_glib_none().0, paste_position.to_glib())) from_glib_none(ges_sys::ges_timeline_element_paste(
self.as_ref().to_glib_none().0,
paste_position.to_glib(),
))
} }
} }
@ -250,25 +272,49 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
fn ripple(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> { fn ripple(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_ripple(self.as_ref().to_glib_none().0, start.to_glib()), "Failed to ripple") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_ripple(
self.as_ref().to_glib_none().0,
start.to_glib()
),
"Failed to ripple"
)
} }
} }
fn ripple_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> { fn ripple_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_ripple_end(self.as_ref().to_glib_none().0, end.to_glib()), "Failed to ripple") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_ripple_end(
self.as_ref().to_glib_none().0,
end.to_glib()
),
"Failed to ripple"
)
} }
} }
fn roll_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> { fn roll_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_roll_end(self.as_ref().to_glib_none().0, end.to_glib()), "Failed to roll") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_roll_end(
self.as_ref().to_glib_none().0,
end.to_glib()
),
"Failed to roll"
)
} }
} }
fn roll_start(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> { fn roll_start(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_roll_start(self.as_ref().to_glib_none().0, start.to_glib()), "Failed to roll") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_roll_start(
self.as_ref().to_glib_none().0,
start.to_glib()
),
"Failed to roll"
)
} }
} }
@ -290,83 +336,138 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
fn set_duration(&self, duration: gst::ClockTime) -> bool { fn set_duration(&self, duration: gst::ClockTime) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_set_duration(self.as_ref().to_glib_none().0, duration.to_glib())) from_glib(ges_sys::ges_timeline_element_set_duration(
self.as_ref().to_glib_none().0,
duration.to_glib(),
))
} }
} }
fn set_inpoint(&self, inpoint: gst::ClockTime) -> bool { fn set_inpoint(&self, inpoint: gst::ClockTime) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_set_inpoint(self.as_ref().to_glib_none().0, inpoint.to_glib())) from_glib(ges_sys::ges_timeline_element_set_inpoint(
self.as_ref().to_glib_none().0,
inpoint.to_glib(),
))
} }
} }
fn set_max_duration(&self, maxduration: gst::ClockTime) -> bool { fn set_max_duration(&self, maxduration: gst::ClockTime) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_set_max_duration(self.as_ref().to_glib_none().0, maxduration.to_glib())) from_glib(ges_sys::ges_timeline_element_set_max_duration(
self.as_ref().to_glib_none().0,
maxduration.to_glib(),
))
} }
} }
fn set_name(&self, name: Option<&str>) -> Result<(), glib::error::BoolError> { fn set_name(&self, name: Option<&str>) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_set_name(self.as_ref().to_glib_none().0, name.to_glib_none().0), "Failed to set name") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_set_name(
self.as_ref().to_glib_none().0,
name.to_glib_none().0
),
"Failed to set name"
)
} }
} }
fn set_parent<P: IsA<TimelineElement>>(&self, parent: &P) -> Result<(), glib::error::BoolError> { fn set_parent<P: IsA<TimelineElement>>(
&self,
parent: &P,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_set_parent(self.as_ref().to_glib_none().0, parent.as_ref().to_glib_none().0), "`TimelineElement` already had a parent or its parent was the same as specified") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_set_parent(
self.as_ref().to_glib_none().0,
parent.as_ref().to_glib_none().0
),
"`TimelineElement` already had a parent or its parent was the same as specified"
)
} }
} }
fn set_priority(&self, priority: u32) -> bool { fn set_priority(&self, priority: u32) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_set_priority(self.as_ref().to_glib_none().0, priority)) from_glib(ges_sys::ges_timeline_element_set_priority(
self.as_ref().to_glib_none().0,
priority,
))
} }
} }
fn set_start(&self, start: gst::ClockTime) -> bool { fn set_start(&self, start: gst::ClockTime) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_timeline_element_set_start(self.as_ref().to_glib_none().0, start.to_glib())) from_glib(ges_sys::ges_timeline_element_set_start(
self.as_ref().to_glib_none().0,
start.to_glib(),
))
} }
} }
fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError> { fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_set_timeline(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_none().0), "`Failed to set timeline") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_set_timeline(
self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_none().0
),
"`Failed to set timeline"
)
} }
} }
fn trim(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> { fn trim(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_timeline_element_trim(self.as_ref().to_glib_none().0, start.to_glib()), "`Failed to trim") glib_result_from_gboolean!(
ges_sys::ges_timeline_element_trim(self.as_ref().to_glib_none().0, start.to_glib()),
"`Failed to trim"
)
} }
} }
fn get_property_in_point(&self) -> u64 { fn get_property_in_point(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"in-point\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"in-point\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_in_point(&self, in_point: u64) { fn set_property_in_point(&self, in_point: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"in-point\0".as_ptr() as *const _, Value::from(&in_point).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"in-point\0".as_ptr() as *const _,
Value::from(&in_point).to_glib_none().0,
);
} }
} }
fn get_property_serialize(&self) -> bool { fn get_property_serialize(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"serialize\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"serialize\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn set_property_serialize(&self, serialize: bool) { fn set_property_serialize(&self, serialize: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"serialize\0".as_ptr() as *const _, Value::from(&serialize).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"serialize\0".as_ptr() as *const _,
Value::from(&serialize).to_glib_none().0,
);
} }
} }
@ -375,128 +476,205 @@ impl<O: IsA<TimelineElement>> TimelineElementExt for O {
//} //}
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_in_point_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::in-point\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_in_point_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::in-point\0".as_ptr() as *const _,
Some(transmute(notify_in_point_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_max_duration_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<TimelineElement> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_max_duration_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::max-duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_max_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::max-duration\0".as_ptr() as *const _,
Some(transmute(
notify_max_duration_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_name_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::name\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_name_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::name\0".as_ptr() as *const _,
Some(transmute(notify_name_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_parent_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::parent\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_parent_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::parent\0".as_ptr() as *const _,
Some(transmute(notify_parent_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_priority_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::priority\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_priority_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::priority\0".as_ptr() as *const _,
Some(transmute(notify_priority_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_serialize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_serialize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_serialize_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_serialize_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::serialize\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_serialize_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::serialize\0".as_ptr() as *const _,
Some(transmute(notify_serialize_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_start_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::start\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_start_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::start\0".as_ptr() as *const _,
Some(transmute(notify_start_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTimelineElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_timeline_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TimelineElement> this: *mut ges_sys::GESTimelineElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TimelineElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TimelineElement::from_glib_borrow(this).unsafe_cast()) f(&TimelineElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::timeline\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_timeline_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::timeline\0".as_ptr() as *const _,
Some(transmute(notify_timeline_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

239
gstreamer-editing-services/src/auto/track.rs
View file

@ -2,23 +2,23 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Timeline;
use TrackElement;
use TrackType;
use ges_sys; use ges_sys;
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use Timeline;
use TrackElement;
use TrackType;
glib_wrapper! { glib_wrapper! {
pub struct Track(Object<ges_sys::GESTrack, ges_sys::GESTrackClass, TrackClass>) @extends gst::Element, gst::Object; pub struct Track(Object<ges_sys::GESTrack, ges_sys::GESTrackClass, TrackClass>) @extends gst::Element, gst::Object;
@ -31,9 +31,7 @@ glib_wrapper! {
impl Track { impl Track {
pub fn new(type_: TrackType, caps: &gst::Caps) -> Track { pub fn new(type_: TrackType, caps: &gst::Caps) -> Track {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_track_new(type_.to_glib(), caps.to_glib_full())) }
from_glib_none(ges_sys::ges_track_new(type_.to_glib(), caps.to_glib_full()))
}
} }
} }
@ -52,7 +50,10 @@ pub trait GESTrackExt: 'static {
fn get_timeline(&self) -> Option<Timeline>; fn get_timeline(&self) -> Option<Timeline>;
fn remove_element<P: IsA<TrackElement>>(&self, object: &P) -> Result<(), glib::error::BoolError>; fn remove_element<P: IsA<TrackElement>>(
&self,
object: &P,
) -> Result<(), glib::error::BoolError>;
//fn set_create_element_for_gap_func<P: Fn(&Track) -> gst::Element + 'static>(&self, func: P); //fn set_create_element_for_gap_func<P: Fn(&Track) -> gst::Element + 'static>(&self, func: P);
@ -72,57 +73,83 @@ pub trait GESTrackExt: 'static {
fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<Track>> GESTrackExt for O { impl<O: IsA<Track>> GESTrackExt for O {
fn add_element<P: IsA<TrackElement>>(&self, object: &P) -> Result<(), glib::error::BoolError> { fn add_element<P: IsA<TrackElement>>(&self, object: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_track_add_element(self.as_ref().to_glib_none().0, object.as_ref().to_glib_none().0), "Failed to add element") glib_result_from_gboolean!(
ges_sys::ges_track_add_element(
self.as_ref().to_glib_none().0,
object.as_ref().to_glib_none().0
),
"Failed to add element"
)
} }
} }
fn commit(&self) -> bool { fn commit(&self) -> bool {
unsafe { unsafe { from_glib(ges_sys::ges_track_commit(self.as_ref().to_glib_none().0)) }
from_glib(ges_sys::ges_track_commit(self.as_ref().to_glib_none().0))
}
} }
fn get_caps(&self) -> Option<gst::Caps> { fn get_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe { from_glib_none(ges_sys::ges_track_get_caps(self.as_ref().to_glib_none().0)) }
from_glib_none(ges_sys::ges_track_get_caps(self.as_ref().to_glib_none().0))
}
} }
fn get_elements(&self) -> Vec<TrackElement> { fn get_elements(&self) -> Vec<TrackElement> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(ges_sys::ges_track_get_elements(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_full(ges_sys::ges_track_get_elements(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_mixing(&self) -> bool { fn get_mixing(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_track_get_mixing(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_track_get_mixing(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_timeline(&self) -> Option<Timeline> { fn get_timeline(&self) -> Option<Timeline> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_track_get_timeline(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_track_get_timeline(
self.as_ref().to_glib_none().0,
))
} }
} }
fn remove_element<P: IsA<TrackElement>>(&self, object: &P) -> Result<(), glib::error::BoolError> { fn remove_element<P: IsA<TrackElement>>(
&self,
object: &P,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_track_remove_element(self.as_ref().to_glib_none().0, object.as_ref().to_glib_none().0), "Failed to remove element") glib_result_from_gboolean!(
ges_sys::ges_track_remove_element(
self.as_ref().to_glib_none().0,
object.as_ref().to_glib_none().0
),
"Failed to remove element"
)
} }
} }
@ -138,26 +165,39 @@ impl<O: IsA<Track>> GESTrackExt for O {
fn set_restriction_caps(&self, caps: &gst::Caps) { fn set_restriction_caps(&self, caps: &gst::Caps) {
unsafe { unsafe {
ges_sys::ges_track_set_restriction_caps(self.as_ref().to_glib_none().0, caps.to_glib_none().0); ges_sys::ges_track_set_restriction_caps(
self.as_ref().to_glib_none().0,
caps.to_glib_none().0,
);
} }
} }
fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) { fn set_timeline<P: IsA<Timeline>>(&self, timeline: &P) {
unsafe { unsafe {
ges_sys::ges_track_set_timeline(self.as_ref().to_glib_none().0, timeline.as_ref().to_glib_none().0); ges_sys::ges_track_set_timeline(
self.as_ref().to_glib_none().0,
timeline.as_ref().to_glib_none().0,
);
} }
} }
fn update_restriction_caps(&self, caps: &gst::Caps) { fn update_restriction_caps(&self, caps: &gst::Caps) {
unsafe { unsafe {
ges_sys::ges_track_update_restriction_caps(self.as_ref().to_glib_none().0, caps.to_glib_none().0); ges_sys::ges_track_update_restriction_caps(
self.as_ref().to_glib_none().0,
caps.to_glib_none().0,
);
} }
} }
fn get_property_duration(&self) -> u64 { fn get_property_duration(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -165,7 +205,11 @@ impl<O: IsA<Track>> GESTrackExt for O {
fn get_property_restriction_caps(&self) -> Option<gst::Caps> { fn get_property_restriction_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Caps as StaticType>::static_type()); let mut value = Value::from_type(<gst::Caps as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"restriction-caps\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"restriction-caps\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -173,92 +217,167 @@ impl<O: IsA<Track>> GESTrackExt for O {
fn get_property_track_type(&self) -> TrackType { fn get_property_track_type(&self) -> TrackType {
unsafe { unsafe {
let mut value = Value::from_type(<TrackType as StaticType>::static_type()); let mut value = Value::from_type(<TrackType as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"track-type\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"track-type\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_commited<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, f: glib_sys::gpointer) unsafe extern "C" fn commited_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Track> this: *mut ges_sys::GESTrack,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast()) f(&Track::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"commited\0".as_ptr() as *const _, connect_raw(
Some(transmute(commited_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"commited\0".as_ptr() as *const _,
Some(transmute(commited_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_element_added<F: Fn(&Self, &TrackElement) + 'static>(
unsafe extern "C" fn track_element_added_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer) &self,
where P: IsA<Track> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn track_element_added_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(
this: *mut ges_sys::GESTrack,
effect: *mut ges_sys::GESTrackElement,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect)) f(
&Track::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(effect),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-element-added\0".as_ptr() as *const _, connect_raw(
Some(transmute(track_element_added_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"track-element-added\0".as_ptr() as *const _,
Some(transmute(
track_element_added_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_track_element_removed<F: Fn(&Self, &TrackElement) + 'static>(
unsafe extern "C" fn track_element_removed_trampoline<P, F: Fn(&P, &TrackElement) + 'static>(this: *mut ges_sys::GESTrack, effect: *mut ges_sys::GESTrackElement, f: glib_sys::gpointer) &self,
where P: IsA<Track> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn track_element_removed_trampoline<
P,
F: Fn(&P, &TrackElement) + 'static,
>(
this: *mut ges_sys::GESTrack,
effect: *mut ges_sys::GESTrackElement,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(effect)) f(
&Track::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(effect),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"track-element-removed\0".as_ptr() as *const _, connect_raw(
Some(transmute(track_element_removed_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"track-element-removed\0".as_ptr() as *const _,
Some(transmute(
track_element_removed_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Track> this: *mut ges_sys::GESTrack,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast()) f(&Track::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mixing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mixing_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_mixing_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<Track> this: *mut ges_sys::GESTrack,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast()) f(&Track::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mixing\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_mixing_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::mixing\0".as_ptr() as *const _,
Some(transmute(notify_mixing_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_restriction_caps_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_restriction_caps_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrack, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<Track> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_restriction_caps_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESTrack,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<Track>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&Track::from_glib_borrow(this).unsafe_cast()) f(&Track::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::restriction-caps\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_restriction_caps_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::restriction-caps\0".as_ptr() as *const _,
Some(transmute(
notify_restriction_caps_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

177
gstreamer-editing-services/src/auto/track_element.rs
View file

@ -2,6 +2,21 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use ges_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use gst;
use std::boxed::Box as Box_;
use std::mem::transmute;
use Edge; use Edge;
use EditMode; use EditMode;
use Extractable; use Extractable;
@ -9,21 +24,6 @@ use Layer;
use TimelineElement; use TimelineElement;
use Track; use Track;
use TrackType; use TrackType;
use ges_sys;
use glib;
use glib::GString;
use glib::StaticType;
use glib::Value;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys;
use gobject_sys;
use gst;
use std::boxed::Box as Box_;
use std::mem::transmute;
glib_wrapper! { glib_wrapper! {
pub struct TrackElement(Object<ges_sys::GESTrackElement, ges_sys::GESTrackElementClass, TrackElementClass>) @extends TimelineElement, @implements Extractable; pub struct TrackElement(Object<ges_sys::GESTrackElement, ges_sys::GESTrackElementClass, TrackElementClass>) @extends TimelineElement, @implements Extractable;
@ -36,9 +36,21 @@ glib_wrapper! {
pub const NONE_TRACK_ELEMENT: Option<&TrackElement> = None; pub const NONE_TRACK_ELEMENT: Option<&TrackElement> = None;
pub trait TrackElementExt: 'static { pub trait TrackElementExt: 'static {
fn add_children_props<P: IsA<gst::Element>>(&self, element: &P, wanted_categories: &[&str], blacklist: &[&str], whitelist: &[&str]); fn add_children_props<P: IsA<gst::Element>>(
&self,
element: &P,
wanted_categories: &[&str],
blacklist: &[&str],
whitelist: &[&str],
);
fn edit(&self, layers: &[Layer], mode: EditMode, edge: Edge, position: u64) -> Result<(), glib::error::BoolError>; fn edit(
&self,
layers: &[Layer],
mode: EditMode,
edge: Edge,
position: u64,
) -> Result<(), glib::error::BoolError>;
//fn get_all_control_bindings(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 6, id: 83 }; //fn get_all_control_bindings(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 6, id: 83 };
@ -80,15 +92,42 @@ pub trait TrackElementExt: 'static {
} }
impl<O: IsA<TrackElement>> TrackElementExt for O { impl<O: IsA<TrackElement>> TrackElementExt for O {
fn add_children_props<P: IsA<gst::Element>>(&self, element: &P, wanted_categories: &[&str], blacklist: &[&str], whitelist: &[&str]) { fn add_children_props<P: IsA<gst::Element>>(
&self,
element: &P,
wanted_categories: &[&str],
blacklist: &[&str],
whitelist: &[&str],
) {
unsafe { unsafe {
ges_sys::ges_track_element_add_children_props(self.as_ref().to_glib_none().0, element.as_ref().to_glib_none().0, wanted_categories.to_glib_none().0, blacklist.to_glib_none().0, whitelist.to_glib_none().0); ges_sys::ges_track_element_add_children_props(
self.as_ref().to_glib_none().0,
element.as_ref().to_glib_none().0,
wanted_categories.to_glib_none().0,
blacklist.to_glib_none().0,
whitelist.to_glib_none().0,
);
} }
} }
fn edit(&self, layers: &[Layer], mode: EditMode, edge: Edge, position: u64) -> Result<(), glib::error::BoolError> { fn edit(
&self,
layers: &[Layer],
mode: EditMode,
edge: Edge,
position: u64,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_track_element_edit(self.as_ref().to_glib_none().0, layers.to_glib_none().0, mode.to_glib(), edge.to_glib(), position), "Failed to edit") glib_result_from_gboolean!(
ges_sys::ges_track_element_edit(
self.as_ref().to_glib_none().0,
layers.to_glib_none().0,
mode.to_glib(),
edge.to_glib(),
position
),
"Failed to edit"
)
} }
} }
@ -102,37 +141,49 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
fn get_element(&self) -> Option<gst::Element> { fn get_element(&self) -> Option<gst::Element> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_track_element_get_element(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_track_element_get_element(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_gnlobject(&self) -> Option<gst::Element> { fn get_gnlobject(&self) -> Option<gst::Element> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_track_element_get_gnlobject(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_track_element_get_gnlobject(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_nleobject(&self) -> Option<gst::Element> { fn get_nleobject(&self) -> Option<gst::Element> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_track_element_get_nleobject(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_track_element_get_nleobject(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_track(&self) -> Option<Track> { fn get_track(&self) -> Option<Track> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_track_element_get_track(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_track_element_get_track(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_track_type(&self) -> TrackType { fn get_track_type(&self) -> TrackType {
unsafe { unsafe {
from_glib(ges_sys::ges_track_element_get_track_type(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_track_element_get_track_type(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_active(&self) -> bool { fn is_active(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_track_element_is_active(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_track_element_is_active(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -142,13 +193,22 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
fn remove_control_binding(&self, property_name: &str) -> Result<(), glib::error::BoolError> { fn remove_control_binding(&self, property_name: &str) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(ges_sys::ges_track_element_remove_control_binding(self.as_ref().to_glib_none().0, property_name.to_glib_none().0), "Failed to remove control binding") glib_result_from_gboolean!(
ges_sys::ges_track_element_remove_control_binding(
self.as_ref().to_glib_none().0,
property_name.to_glib_none().0
),
"Failed to remove control binding"
)
} }
} }
fn set_active(&self, active: bool) -> bool { fn set_active(&self, active: bool) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_track_element_set_active(self.as_ref().to_glib_none().0, active.to_glib())) from_glib(ges_sys::ges_track_element_set_active(
self.as_ref().to_glib_none().0,
active.to_glib(),
))
} }
} }
@ -158,14 +218,21 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
fn set_track_type(&self, type_: TrackType) { fn set_track_type(&self, type_: TrackType) {
unsafe { unsafe {
ges_sys::ges_track_element_set_track_type(self.as_ref().to_glib_none().0, type_.to_glib()); ges_sys::ges_track_element_set_track_type(
self.as_ref().to_glib_none().0,
type_.to_glib(),
);
} }
} }
fn get_property_active(&self) -> bool { fn get_property_active(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"active\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"active\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -179,44 +246,68 @@ impl<O: IsA<TrackElement>> TrackElementExt for O {
//} //}
fn connect_property_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_active_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_active_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TrackElement> this: *mut ges_sys::GESTrackElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TrackElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast()) f(&TrackElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_active_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::active\0".as_ptr() as *const _,
Some(transmute(notify_active_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_track_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_track_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_track_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_track_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TrackElement> this: *mut ges_sys::GESTrackElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TrackElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast()) f(&TrackElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::track\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_track_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::track\0".as_ptr() as *const _,
Some(transmute(notify_track_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_track_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_track_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_track_type_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESTrackElement, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_track_type_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<TrackElement> this: *mut ges_sys::GESTrackElement,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<TrackElement>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&TrackElement::from_glib_borrow(this).unsafe_cast()) f(&TrackElement::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::track-type\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_track_type_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::track-type\0".as_ptr() as *const _,
Some(transmute(notify_track_type_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

106
gstreamer-editing-services/src/auto/uri_clip.rs
View file

@ -2,23 +2,23 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Clip;
use Container;
use Extractable;
use TimelineElement;
use ges_sys; use ges_sys;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use Clip;
use Container;
use Extractable;
use TimelineElement;
glib_wrapper! { glib_wrapper! {
pub struct UriClip(Object<ges_sys::GESUriClip, ges_sys::GESUriClipClass, UriClipClass>) @extends Clip, Container, TimelineElement, @implements Extractable; pub struct UriClip(Object<ges_sys::GESUriClip, ges_sys::GESUriClipClass, UriClipClass>) @extends Clip, Container, TimelineElement, @implements Extractable;
@ -31,9 +31,7 @@ glib_wrapper! {
impl UriClip { impl UriClip {
pub fn new(uri: &str) -> Option<UriClip> { pub fn new(uri: &str) -> Option<UriClip> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(ges_sys::ges_uri_clip_new(uri.to_glib_none().0)) }
from_glib_none(ges_sys::ges_uri_clip_new(uri.to_glib_none().0))
}
} }
} }
@ -58,25 +56,34 @@ pub trait UriClipExt: 'static {
fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<UriClip>> UriClipExt for O { impl<O: IsA<UriClip>> UriClipExt for O {
fn get_uri(&self) -> Option<GString> { fn get_uri(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_uri_clip_get_uri(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_uri_clip_get_uri(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_image(&self) -> bool { fn is_image(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_uri_clip_is_image(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_uri_clip_is_image(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_muted(&self) -> bool { fn is_muted(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_uri_clip_is_muted(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_uri_clip_is_muted(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -95,7 +102,11 @@ impl<O: IsA<UriClip>> UriClipExt for O {
fn get_property_is_image(&self) -> bool { fn get_property_is_image(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"is-image\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"is-image\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -103,50 +114,83 @@ impl<O: IsA<UriClip>> UriClipExt for O {
fn get_property_mute(&self) -> bool { fn get_property_mute(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"mute\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"mute\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
fn connect_property_is_image_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_is_image_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_is_image_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_is_image_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<UriClip> this: *mut ges_sys::GESUriClip,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<UriClip>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast()) f(&UriClip::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::is-image\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_is_image_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::is-image\0".as_ptr() as *const _,
Some(transmute(notify_is_image_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_mute_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_mute_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<UriClip> this: *mut ges_sys::GESUriClip,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<UriClip>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast()) f(&UriClip::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::mute\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_mute_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::mute\0".as_ptr() as *const _,
Some(transmute(notify_mute_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_supported_formats_notify<F: Fn(&Self) + 'static>(
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClip, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<UriClip> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(
this: *mut ges_sys::GESUriClip,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<UriClip>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&UriClip::from_glib_borrow(this).unsafe_cast()) f(&UriClip::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::supported-formats\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_supported_formats_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::supported-formats\0".as_ptr() as *const _,
Some(transmute(
notify_supported_formats_trampoline::<Self, F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

54
gstreamer-editing-services/src/auto/uri_clip_asset.rs
View file

@ -2,16 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Asset;
use Error;
use UriSourceAsset;
use ges_sys; use ges_sys;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -19,6 +16,9 @@ use gst_pbutils;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Asset;
use Error;
use UriSourceAsset;
glib_wrapper! { glib_wrapper! {
pub struct UriClipAsset(Object<ges_sys::GESUriClipAsset, ges_sys::GESUriClipAssetClass, UriClipAssetClass>) @extends Asset; pub struct UriClipAsset(Object<ges_sys::GESUriClipAsset, ges_sys::GESUriClipAssetClass, UriClipAssetClass>) @extends Asset;
@ -42,7 +42,11 @@ impl UriClipAsset {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = ges_sys::ges_uri_clip_asset_request_sync(uri.to_glib_none().0, &mut error); let ret = ges_sys::ges_uri_clip_asset_request_sync(uri.to_glib_none().0, &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
} }
@ -66,45 +70,65 @@ pub trait UriClipAssetExt: 'static {
impl<O: IsA<UriClipAsset>> UriClipAssetExt for O { impl<O: IsA<UriClipAsset>> UriClipAssetExt for O {
fn get_duration(&self) -> gst::ClockTime { fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(ges_sys::ges_uri_clip_asset_get_duration(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_uri_clip_asset_get_duration(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_info(&self) -> Option<gst_pbutils::DiscovererInfo> { fn get_info(&self) -> Option<gst_pbutils::DiscovererInfo> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_uri_clip_asset_get_info(const_override(self.as_ref().to_glib_none().0))) from_glib_none(ges_sys::ges_uri_clip_asset_get_info(const_override(
self.as_ref().to_glib_none().0,
)))
} }
} }
fn get_stream_assets(&self) -> Vec<UriSourceAsset> { fn get_stream_assets(&self) -> Vec<UriSourceAsset> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(ges_sys::ges_uri_clip_asset_get_stream_assets(self.as_ref().to_glib_none().0)) FromGlibPtrContainer::from_glib_none(ges_sys::ges_uri_clip_asset_get_stream_assets(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_image(&self) -> bool { fn is_image(&self) -> bool {
unsafe { unsafe {
from_glib(ges_sys::ges_uri_clip_asset_is_image(self.as_ref().to_glib_none().0)) from_glib(ges_sys::ges_uri_clip_asset_is_image(
self.as_ref().to_glib_none().0,
))
} }
} }
fn set_property_duration(&self, duration: u64) { fn set_property_duration(&self, duration: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"duration\0".as_ptr() as *const _, Value::from(&duration).to_glib_none().0); gobject_sys::g_object_set_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"duration\0".as_ptr() as *const _,
Value::from(&duration).to_glib_none().0,
);
} }
} }
fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(this: *mut ges_sys::GESUriClipAsset, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) unsafe extern "C" fn notify_duration_trampoline<P, F: Fn(&P) + 'static>(
where P: IsA<UriClipAsset> this: *mut ges_sys::GESUriClipAsset,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<UriClipAsset>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&UriClipAsset::from_glib_borrow(this).unsafe_cast()) f(&UriClipAsset::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::duration\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_duration_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::duration\0".as_ptr() as *const _,
Some(transmute(notify_duration_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

18
gstreamer-editing-services/src/auto/uri_source_asset.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Asset;
use UriClipAsset;
use ges_sys; use ges_sys;
use glib::GString;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_pbutils; use gst_pbutils;
use Asset;
use UriClipAsset;
glib_wrapper! { glib_wrapper! {
pub struct UriSourceAsset(Object<ges_sys::GESUriSourceAsset, ges_sys::GESUriSourceAssetClass, UriSourceAssetClass>) @extends Asset; pub struct UriSourceAsset(Object<ges_sys::GESUriSourceAsset, ges_sys::GESUriSourceAssetClass, UriSourceAssetClass>) @extends Asset;
@ -31,19 +31,25 @@ pub trait UriSourceAssetExt: 'static {
impl<O: IsA<UriSourceAsset>> UriSourceAssetExt for O { impl<O: IsA<UriSourceAsset>> UriSourceAssetExt for O {
fn get_filesource_asset(&self) -> Option<UriClipAsset> { fn get_filesource_asset(&self) -> Option<UriClipAsset> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_uri_source_asset_get_filesource_asset(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_uri_source_asset_get_filesource_asset(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_stream_info(&self) -> Option<gst_pbutils::DiscovererStreamInfo> { fn get_stream_info(&self) -> Option<gst_pbutils::DiscovererStreamInfo> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_uri_source_asset_get_stream_info(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_uri_source_asset_get_stream_info(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_stream_uri(&self) -> Option<GString> { fn get_stream_uri(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(ges_sys::ges_uri_source_asset_get_stream_uri(self.as_ref().to_glib_none().0)) from_glib_none(ges_sys::ges_uri_source_asset_get_stream_uri(
self.as_ref().to_glib_none().0,
))
} }
} }
} }

1
gstreamer-editing-services/src/lib.rs
View file

@ -69,7 +69,6 @@ macro_rules! skip_assert_initialized {
#[allow(clippy::unreadable_literal)] #[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

72
gstreamer-gl/src/auto/enums.rs
View file

@ -2,20 +2,19 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::Quark;
use glib::StaticType;
use glib::Type;
use glib::error::ErrorDomain; use glib::error::ErrorDomain;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::Quark;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_gl_sys; use gst_gl_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLContextError { pub enum GLContextError {
Failed, Failed,
WrongConfig, WrongConfig,
@ -38,8 +37,10 @@ impl ToGlib for GLContextError {
GLContextError::WrongApi => gst_gl_sys::GST_GL_CONTEXT_ERROR_WRONG_API, GLContextError::WrongApi => gst_gl_sys::GST_GL_CONTEXT_ERROR_WRONG_API,
GLContextError::OldLibs => gst_gl_sys::GST_GL_CONTEXT_ERROR_OLD_LIBS, GLContextError::OldLibs => gst_gl_sys::GST_GL_CONTEXT_ERROR_OLD_LIBS,
GLContextError::CreateContext => gst_gl_sys::GST_GL_CONTEXT_ERROR_CREATE_CONTEXT, GLContextError::CreateContext => gst_gl_sys::GST_GL_CONTEXT_ERROR_CREATE_CONTEXT,
GLContextError::ResourceUnavailable => gst_gl_sys::GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE, GLContextError::ResourceUnavailable => {
GLContextError::__Unknown(value) => value gst_gl_sys::GST_GL_CONTEXT_ERROR_RESOURCE_UNAVAILABLE
}
GLContextError::__Unknown(value) => value,
} }
} }
} }
@ -108,8 +109,7 @@ impl SetValue for GLContextError {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLFormat { pub enum GLFormat {
Luminance, Luminance,
Alpha, Alpha,
@ -153,7 +153,7 @@ impl ToGlib for GLFormat {
GLFormat::Rgba16 => gst_gl_sys::GST_GL_RGBA16, GLFormat::Rgba16 => gst_gl_sys::GST_GL_RGBA16,
GLFormat::DepthComponent16 => gst_gl_sys::GST_GL_DEPTH_COMPONENT16, GLFormat::DepthComponent16 => gst_gl_sys::GST_GL_DEPTH_COMPONENT16,
GLFormat::Depth24Stencil8 => gst_gl_sys::GST_GL_DEPTH24_STENCIL8, GLFormat::Depth24Stencil8 => gst_gl_sys::GST_GL_DEPTH24_STENCIL8,
GLFormat::__Unknown(value) => value GLFormat::__Unknown(value) => value,
} }
} }
} }
@ -208,8 +208,7 @@ impl SetValue for GLFormat {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLQueryType { pub enum GLQueryType {
None, None,
TimeElapsed, TimeElapsed,
@ -227,7 +226,7 @@ impl ToGlib for GLQueryType {
GLQueryType::None => gst_gl_sys::GST_GL_QUERY_NONE, GLQueryType::None => gst_gl_sys::GST_GL_QUERY_NONE,
GLQueryType::TimeElapsed => gst_gl_sys::GST_GL_QUERY_TIME_ELAPSED, GLQueryType::TimeElapsed => gst_gl_sys::GST_GL_QUERY_TIME_ELAPSED,
GLQueryType::Timestamp => gst_gl_sys::GST_GL_QUERY_TIMESTAMP, GLQueryType::Timestamp => gst_gl_sys::GST_GL_QUERY_TIMESTAMP,
GLQueryType::__Unknown(value) => value GLQueryType::__Unknown(value) => value,
} }
} }
} }
@ -269,8 +268,7 @@ impl SetValue for GLQueryType {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLSLError { pub enum GLSLError {
Compile, Compile,
Link, Link,
@ -288,7 +286,7 @@ impl ToGlib for GLSLError {
GLSLError::Compile => gst_gl_sys::GST_GLSL_ERROR_COMPILE, GLSLError::Compile => gst_gl_sys::GST_GLSL_ERROR_COMPILE,
GLSLError::Link => gst_gl_sys::GST_GLSL_ERROR_LINK, GLSLError::Link => gst_gl_sys::GST_GLSL_ERROR_LINK,
GLSLError::Program => gst_gl_sys::GST_GLSL_ERROR_PROGRAM, GLSLError::Program => gst_gl_sys::GST_GLSL_ERROR_PROGRAM,
GLSLError::__Unknown(value) => value GLSLError::__Unknown(value) => value,
} }
} }
} }
@ -351,8 +349,7 @@ impl SetValue for GLSLError {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLSLVersion { pub enum GLSLVersion {
None, None,
_100, _100,
@ -398,7 +395,7 @@ impl ToGlib for GLSLVersion {
GLSLVersion::_430 => gst_gl_sys::GST_GLSL_VERSION_430, GLSLVersion::_430 => gst_gl_sys::GST_GLSL_VERSION_430,
GLSLVersion::_440 => gst_gl_sys::GST_GLSL_VERSION_440, GLSLVersion::_440 => gst_gl_sys::GST_GLSL_VERSION_440,
GLSLVersion::_450 => gst_gl_sys::GST_GLSL_VERSION_450, GLSLVersion::_450 => gst_gl_sys::GST_GLSL_VERSION_450,
GLSLVersion::__Unknown(value) => value GLSLVersion::__Unknown(value) => value,
} }
} }
} }
@ -454,8 +451,7 @@ impl SetValue for GLSLVersion {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLStereoDownmix { pub enum GLStereoDownmix {
GreenMagentaDubois, GreenMagentaDubois,
RedCyanDubois, RedCyanDubois,
@ -470,10 +466,16 @@ impl ToGlib for GLStereoDownmix {
fn to_glib(&self) -> gst_gl_sys::GstGLStereoDownmix { fn to_glib(&self) -> gst_gl_sys::GstGLStereoDownmix {
match *self { match *self {
GLStereoDownmix::GreenMagentaDubois => gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS, GLStereoDownmix::GreenMagentaDubois => {
GLStereoDownmix::RedCyanDubois => gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS, gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_GREEN_MAGENTA_DUBOIS
GLStereoDownmix::AmberBlueDubois => gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS, }
GLStereoDownmix::__Unknown(value) => value GLStereoDownmix::RedCyanDubois => {
gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_RED_CYAN_DUBOIS
}
GLStereoDownmix::AmberBlueDubois => {
gst_gl_sys::GST_GL_STEREO_DOWNMIX_ANAGLYPH_AMBER_BLUE_DUBOIS
}
GLStereoDownmix::__Unknown(value) => value,
} }
} }
} }
@ -515,8 +517,7 @@ impl SetValue for GLStereoDownmix {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLTextureTarget { pub enum GLTextureTarget {
None, None,
_2d, _2d,
@ -536,7 +537,7 @@ impl ToGlib for GLTextureTarget {
GLTextureTarget::_2d => gst_gl_sys::GST_GL_TEXTURE_TARGET_2D, GLTextureTarget::_2d => gst_gl_sys::GST_GL_TEXTURE_TARGET_2D,
GLTextureTarget::Rectangle => gst_gl_sys::GST_GL_TEXTURE_TARGET_RECTANGLE, GLTextureTarget::Rectangle => gst_gl_sys::GST_GL_TEXTURE_TARGET_RECTANGLE,
GLTextureTarget::ExternalOes => gst_gl_sys::GST_GL_TEXTURE_TARGET_EXTERNAL_OES, GLTextureTarget::ExternalOes => gst_gl_sys::GST_GL_TEXTURE_TARGET_EXTERNAL_OES,
GLTextureTarget::__Unknown(value) => value GLTextureTarget::__Unknown(value) => value,
} }
} }
} }
@ -579,8 +580,7 @@ impl SetValue for GLTextureTarget {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLUploadReturn { pub enum GLUploadReturn {
Done, Done,
Error, Error,
@ -602,7 +602,7 @@ impl ToGlib for GLUploadReturn {
GLUploadReturn::Unsupported => gst_gl_sys::GST_GL_UPLOAD_UNSUPPORTED, GLUploadReturn::Unsupported => gst_gl_sys::GST_GL_UPLOAD_UNSUPPORTED,
GLUploadReturn::Reconfigure => gst_gl_sys::GST_GL_UPLOAD_RECONFIGURE, GLUploadReturn::Reconfigure => gst_gl_sys::GST_GL_UPLOAD_RECONFIGURE,
GLUploadReturn::UnsharedGlContext => gst_gl_sys::GST_GL_UPLOAD_UNSHARED_GL_CONTEXT, GLUploadReturn::UnsharedGlContext => gst_gl_sys::GST_GL_UPLOAD_UNSHARED_GL_CONTEXT,
GLUploadReturn::__Unknown(value) => value GLUploadReturn::__Unknown(value) => value,
} }
} }
} }
@ -646,8 +646,7 @@ impl SetValue for GLUploadReturn {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum GLWindowError { pub enum GLWindowError {
Failed, Failed,
OldLibs, OldLibs,
@ -664,8 +663,10 @@ impl ToGlib for GLWindowError {
match *self { match *self {
GLWindowError::Failed => gst_gl_sys::GST_GL_WINDOW_ERROR_FAILED, GLWindowError::Failed => gst_gl_sys::GST_GL_WINDOW_ERROR_FAILED,
GLWindowError::OldLibs => gst_gl_sys::GST_GL_WINDOW_ERROR_OLD_LIBS, GLWindowError::OldLibs => gst_gl_sys::GST_GL_WINDOW_ERROR_OLD_LIBS,
GLWindowError::ResourceUnavailable => gst_gl_sys::GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE, GLWindowError::ResourceUnavailable => {
GLWindowError::__Unknown(value) => value gst_gl_sys::GST_GL_WINDOW_ERROR_RESOURCE_UNAVAILABLE
}
GLWindowError::__Unknown(value) => value,
} }
} }
} }
@ -727,4 +728,3 @@ impl SetValue for GLWindowError {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
} }
} }

5
gstreamer-gl/src/auto/flags.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_gl_sys; use gst_gl_sys;
@ -223,4 +223,3 @@ impl SetValue for GLSLProfile {
gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
} }
} }

44
gstreamer-gl/src/auto/gl_base_filter.rs
View file

@ -2,20 +2,20 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use glib::StaticType;
use glib::Value;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use GLContext;
glib_wrapper! { glib_wrapper! {
pub struct GLBaseFilter(Object<gst_gl_sys::GstGLBaseFilter, gst_gl_sys::GstGLBaseFilterClass, GLBaseFilterClass>) @extends gst::Object; pub struct GLBaseFilter(Object<gst_gl_sys::GstGLBaseFilter, gst_gl_sys::GstGLBaseFilterClass, GLBaseFilterClass>) @extends gst::Object;
@ -36,36 +36,56 @@ pub trait GLBaseFilterExt: 'static {
fn get_property_context(&self) -> Option<GLContext>; fn get_property_context(&self) -> Option<GLContext>;
fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<GLBaseFilter>> GLBaseFilterExt for O { impl<O: IsA<GLBaseFilter>> GLBaseFilterExt for O {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn find_gl_context(&self) -> bool { fn find_gl_context(&self) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_base_filter_find_gl_context(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_base_filter_find_gl_context(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_property_context(&self) -> Option<GLContext> { fn get_property_context(&self) -> Option<GLContext> {
unsafe { unsafe {
let mut value = Value::from_type(<GLContext as StaticType>::static_type()); let mut value = Value::from_type(<GLContext as StaticType>::static_type());
gobject_sys::g_object_get_property(self.to_glib_none().0 as *mut gobject_sys::GObject, b"context\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.to_glib_none().0 as *mut gobject_sys::GObject,
b"context\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_property_context_notify<F: Fn(&Self) + Send + Sync + 'static>(
unsafe extern "C" fn notify_context_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLBaseFilter, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) &self,
where P: IsA<GLBaseFilter> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_context_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
this: *mut gst_gl_sys::GstGLBaseFilter,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) where
P: IsA<GLBaseFilter>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&GLBaseFilter::from_glib_borrow(this).unsafe_cast()) f(&GLBaseFilter::from_glib_borrow(this).unsafe_cast())
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::context\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_context_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::context\0".as_ptr() as *const _,
Some(transmute(notify_context_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

35
gstreamer-gl/src/auto/gl_color_convert.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use glib; use glib;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use GLContext;
glib_wrapper! { glib_wrapper! {
pub struct GLColorConvert(Object<gst_gl_sys::GstGLColorConvert, gst_gl_sys::GstGLColorConvertClass, GLColorConvertClass>) @extends gst::Object; pub struct GLColorConvert(Object<gst_gl_sys::GstGLColorConvert, gst_gl_sys::GstGLColorConvertClass, GLColorConvertClass>) @extends gst::Object;
@ -21,20 +21,43 @@ impl GLColorConvert {
pub fn new<P: IsA<GLContext>>(context: &P) -> GLColorConvert { pub fn new<P: IsA<GLContext>>(context: &P) -> GLColorConvert {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_color_convert_new(context.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_color_convert_new(
context.as_ref().to_glib_none().0,
))
} }
} }
pub fn set_caps(&self, in_caps: &gst::Caps, out_caps: &gst::Caps) -> Result<(), glib::error::BoolError> { pub fn set_caps(
&self,
in_caps: &gst::Caps,
out_caps: &gst::Caps,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_color_convert_set_caps(self.to_glib_none().0, in_caps.to_glib_none().0, out_caps.to_glib_none().0), "Failed to set caps") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_color_convert_set_caps(
self.to_glib_none().0,
in_caps.to_glib_none().0,
out_caps.to_glib_none().0
),
"Failed to set caps"
)
} }
} }
pub fn transform_caps<P: IsA<GLContext>>(context: &P, direction: gst::PadDirection, caps: &gst::Caps, filter: &gst::Caps) -> Option<gst::Caps> { pub fn transform_caps<P: IsA<GLContext>>(
context: &P,
direction: gst::PadDirection,
caps: &gst::Caps,
filter: &gst::Caps,
) -> Option<gst::Caps> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_color_convert_transform_caps(context.as_ref().to_glib_none().0, direction.to_glib(), caps.to_glib_none().0, filter.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_color_convert_transform_caps(
context.as_ref().to_glib_none().0,
direction.to_glib(),
caps.to_glib_none().0,
filter.to_glib_none().0,
))
} }
} }
} }

142
gstreamer-gl/src/auto/gl_context.rs
View file

@ -2,13 +2,6 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Error;
use GLAPI;
use GLDisplay;
use GLPlatform;
use GLSLProfile;
use GLSLVersion;
use GLWindow;
use glib; use glib;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
@ -16,6 +9,13 @@ use gst;
use gst_gl_sys; use gst_gl_sys;
use std::mem; use std::mem;
use std::ptr; use std::ptr;
use Error;
use GLDisplay;
use GLPlatform;
use GLSLProfile;
use GLSLVersion;
use GLWindow;
use GLAPI;
glib_wrapper! { glib_wrapper! {
pub struct GLContext(Object<gst_gl_sys::GstGLContext, gst_gl_sys::GstGLContextClass, GLContextClass>) @extends gst::Object; pub struct GLContext(Object<gst_gl_sys::GstGLContext, gst_gl_sys::GstGLContextClass, GLContextClass>) @extends gst::Object;
@ -29,15 +29,15 @@ impl GLContext {
pub fn new<P: IsA<GLDisplay>>(display: &P) -> GLContext { pub fn new<P: IsA<GLDisplay>>(display: &P) -> GLContext {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_gl_context_new(display.as_ref().to_glib_none().0)) from_glib_none(gst_gl_sys::gst_gl_context_new(
display.as_ref().to_glib_none().0,
))
} }
} }
pub fn get_current() -> Option<GLContext> { pub fn get_current() -> Option<GLContext> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_none(gst_gl_sys::gst_gl_context_get_current()) }
from_glib_none(gst_gl_sys::gst_gl_context_get_current())
}
} }
pub fn get_current_gl_api(platform: GLPlatform) -> (GLAPI, u32, u32) { pub fn get_current_gl_api(platform: GLPlatform) -> (GLAPI, u32, u32) {
@ -45,7 +45,11 @@ impl GLContext {
unsafe { unsafe {
let mut major = mem::uninitialized(); let mut major = mem::uninitialized();
let mut minor = mem::uninitialized(); let mut minor = mem::uninitialized();
let ret = from_glib(gst_gl_sys::gst_gl_context_get_current_gl_api(platform.to_glib(), &mut major, &mut minor)); let ret = from_glib(gst_gl_sys::gst_gl_context_get_current_gl_api(
platform.to_glib(),
&mut major,
&mut minor,
));
(ret, major, minor) (ret, major, minor)
} }
} }
@ -109,31 +113,51 @@ pub trait GLContextExt: 'static {
impl<O: IsA<GLContext>> GLContextExt for O { impl<O: IsA<GLContext>> GLContextExt for O {
fn activate(&self, activate: bool) -> Result<(), glib::error::BoolError> { fn activate(&self, activate: bool) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_context_activate(self.as_ref().to_glib_none().0, activate.to_glib()), "Failed to activate OpenGL context") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_context_activate(
self.as_ref().to_glib_none().0,
activate.to_glib()
),
"Failed to activate OpenGL context"
)
} }
} }
fn can_share<P: IsA<GLContext>>(&self, other_context: &P) -> bool { fn can_share<P: IsA<GLContext>>(&self, other_context: &P) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_can_share(self.as_ref().to_glib_none().0, other_context.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_context_can_share(
self.as_ref().to_glib_none().0,
other_context.as_ref().to_glib_none().0,
))
} }
} }
fn check_feature(&self, feature: &str) -> bool { fn check_feature(&self, feature: &str) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_check_feature(self.as_ref().to_glib_none().0, feature.to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_context_check_feature(
self.as_ref().to_glib_none().0,
feature.to_glib_none().0,
))
} }
} }
fn check_framebuffer_status(&self, fbo_target: u32) -> bool { fn check_framebuffer_status(&self, fbo_target: u32) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_check_framebuffer_status(self.as_ref().to_glib_none().0, fbo_target)) from_glib(gst_gl_sys::gst_gl_context_check_framebuffer_status(
self.as_ref().to_glib_none().0,
fbo_target,
))
} }
} }
fn check_gl_version(&self, api: GLAPI, maj: i32, min: i32) -> bool { fn check_gl_version(&self, api: GLAPI, maj: i32, min: i32) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_check_gl_version(self.as_ref().to_glib_none().0, api.to_glib(), maj, min)) from_glib(gst_gl_sys::gst_gl_context_check_gl_version(
self.as_ref().to_glib_none().0,
api.to_glib(),
maj,
min,
))
} }
} }
@ -152,8 +176,16 @@ impl<O: IsA<GLContext>> GLContextExt for O {
fn create<P: IsA<GLContext>>(&self, other_context: Option<&P>) -> Result<(), Error> { fn create<P: IsA<GLContext>>(&self, other_context: Option<&P>) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_gl_context_create(self.as_ref().to_glib_none().0, other_context.map(|p| p.as_ref()).to_glib_none().0, &mut error); let _ = gst_gl_sys::gst_gl_context_create(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
other_context.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
@ -166,26 +198,37 @@ impl<O: IsA<GLContext>> GLContextExt for O {
fn fill_info(&self) -> Result<(), Error> { fn fill_info(&self) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_gl_context_fill_info(self.as_ref().to_glib_none().0, &mut error); let _ =
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } gst_gl_sys::gst_gl_context_fill_info(self.as_ref().to_glib_none().0, &mut error);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
fn get_display(&self) -> GLDisplay { fn get_display(&self) -> GLDisplay {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_context_get_display(self.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_context_get_display(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_gl_api(&self) -> GLAPI { fn get_gl_api(&self) -> GLAPI {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_get_gl_api(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_context_get_gl_api(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_gl_platform(&self) -> GLPlatform { fn get_gl_platform(&self) -> GLPlatform {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_get_gl_platform(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_context_get_gl_platform(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -193,7 +236,11 @@ impl<O: IsA<GLContext>> GLContextExt for O {
unsafe { unsafe {
let mut major = mem::uninitialized(); let mut major = mem::uninitialized();
let mut minor = mem::uninitialized(); let mut minor = mem::uninitialized();
gst_gl_sys::gst_gl_context_get_gl_platform_version(self.as_ref().to_glib_none().0, &mut major, &mut minor); gst_gl_sys::gst_gl_context_get_gl_platform_version(
self.as_ref().to_glib_none().0,
&mut major,
&mut minor,
);
(major, minor) (major, minor)
} }
} }
@ -202,52 +249,81 @@ impl<O: IsA<GLContext>> GLContextExt for O {
unsafe { unsafe {
let mut maj = mem::uninitialized(); let mut maj = mem::uninitialized();
let mut min = mem::uninitialized(); let mut min = mem::uninitialized();
gst_gl_sys::gst_gl_context_get_gl_version(self.as_ref().to_glib_none().0, &mut maj, &mut min); gst_gl_sys::gst_gl_context_get_gl_version(
self.as_ref().to_glib_none().0,
&mut maj,
&mut min,
);
(maj, min) (maj, min)
} }
} }
fn get_window(&self) -> Option<GLWindow> { fn get_window(&self) -> Option<GLWindow> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_context_get_window(self.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_context_get_window(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_shared(&self) -> bool { fn is_shared(&self) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_is_shared(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_context_is_shared(
self.as_ref().to_glib_none().0,
))
} }
} }
fn set_shared_with<P: IsA<GLContext>>(&self, share: &P) { fn set_shared_with<P: IsA<GLContext>>(&self, share: &P) {
unsafe { unsafe {
gst_gl_sys::gst_gl_context_set_shared_with(self.as_ref().to_glib_none().0, share.as_ref().to_glib_none().0); gst_gl_sys::gst_gl_context_set_shared_with(
self.as_ref().to_glib_none().0,
share.as_ref().to_glib_none().0,
);
} }
} }
fn set_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError> { fn set_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_context_set_window(self.as_ref().to_glib_none().0, window.as_ref().to_glib_full()), "Failed to set window") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_context_set_window(
self.as_ref().to_glib_none().0,
window.as_ref().to_glib_full()
),
"Failed to set window"
)
} }
} }
fn supports_glsl_profile_version(&self, version: GLSLVersion, profile: GLSLProfile) -> bool { fn supports_glsl_profile_version(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_supports_glsl_profile_version(self.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib(gst_gl_sys::gst_gl_context_supports_glsl_profile_version(
self.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn supports_precision(&self, version: GLSLVersion, profile: GLSLProfile) -> bool { fn supports_precision(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_supports_precision(self.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib(gst_gl_sys::gst_gl_context_supports_precision(
self.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn supports_precision_highp(&self, version: GLSLVersion, profile: GLSLProfile) -> bool { fn supports_precision_highp(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_context_supports_precision_highp(self.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib(gst_gl_sys::gst_gl_context_supports_precision_highp(
self.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
))
} }
} }

102
gstreamer-gl/src/auto/gl_display.rs
View file

@ -2,16 +2,11 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Error;
use GLAPI;
use GLContext;
use GLDisplayType;
use GLWindow;
use glib; use glib;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib_sys; use glib_sys;
use gst; use gst;
@ -19,6 +14,11 @@ use gst_gl_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Error;
use GLContext;
use GLDisplayType;
use GLWindow;
use GLAPI;
glib_wrapper! { glib_wrapper! {
pub struct GLDisplay(Object<gst_gl_sys::GstGLDisplay, gst_gl_sys::GstGLDisplayClass, GLDisplayClass>) @extends gst::Object; pub struct GLDisplay(Object<gst_gl_sys::GstGLDisplay, gst_gl_sys::GstGLDisplayClass, GLDisplayClass>) @extends gst::Object;
@ -31,9 +31,7 @@ glib_wrapper! {
impl GLDisplay { impl GLDisplay {
pub fn new() -> GLDisplay { pub fn new() -> GLDisplay {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_gl_sys::gst_gl_display_new()) }
from_glib_full(gst_gl_sys::gst_gl_display_new())
}
} }
} }
@ -65,13 +63,22 @@ pub trait GLDisplayExt: 'static {
fn remove_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError>; fn remove_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError>;
fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<GLDisplay>> GLDisplayExt for O { impl<O: IsA<GLDisplay>> GLDisplayExt for O {
fn add_context<P: IsA<GLContext>>(&self, context: &P) -> Result<(), glib::error::BoolError> { fn add_context<P: IsA<GLContext>>(&self, context: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_display_add_context(self.as_ref().to_glib_none().0, context.as_ref().to_glib_none().0), "Failed to add OpenGL context") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_display_add_context(
self.as_ref().to_glib_none().0,
context.as_ref().to_glib_none().0
),
"Failed to add OpenGL context"
)
} }
} }
@ -79,58 +86,103 @@ impl<O: IsA<GLDisplay>> GLDisplayExt for O {
unsafe { unsafe {
let mut p_context = ptr::null_mut(); let mut p_context = ptr::null_mut();
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_gl_display_create_context(self.as_ref().to_glib_none().0, other_context.as_ref().to_glib_none().0, &mut p_context, &mut error); let _ = gst_gl_sys::gst_gl_display_create_context(
if error.is_null() { Ok(from_glib_full(p_context)) } else { Err(from_glib_full(error)) } self.as_ref().to_glib_none().0,
other_context.as_ref().to_glib_none().0,
&mut p_context,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(p_context))
} else {
Err(from_glib_full(error))
}
} }
} }
fn create_window(&self) -> Option<GLWindow> { fn create_window(&self) -> Option<GLWindow> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_display_create_window(self.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_display_create_window(
self.as_ref().to_glib_none().0,
))
} }
} }
fn filter_gl_api(&self, gl_api: GLAPI) { fn filter_gl_api(&self, gl_api: GLAPI) {
unsafe { unsafe {
gst_gl_sys::gst_gl_display_filter_gl_api(self.as_ref().to_glib_none().0, gl_api.to_glib()); gst_gl_sys::gst_gl_display_filter_gl_api(
self.as_ref().to_glib_none().0,
gl_api.to_glib(),
);
} }
} }
fn get_gl_api(&self) -> GLAPI { fn get_gl_api(&self) -> GLAPI {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_display_get_gl_api(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_display_get_gl_api(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_gl_api_unlocked(&self) -> GLAPI { fn get_gl_api_unlocked(&self) -> GLAPI {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_display_get_gl_api_unlocked(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_display_get_gl_api_unlocked(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_handle_type(&self) -> GLDisplayType { fn get_handle_type(&self) -> GLDisplayType {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_display_get_handle_type(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_display_get_handle_type(
self.as_ref().to_glib_none().0,
))
} }
} }
fn remove_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError> { fn remove_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_display_remove_window(self.as_ref().to_glib_none().0, window.as_ref().to_glib_none().0), "Failed to remove window") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_display_remove_window(
self.as_ref().to_glib_none().0,
window.as_ref().to_glib_none().0
),
"Failed to remove window"
)
} }
} }
fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_create_context<F: Fn(&Self, &GLContext) -> GLContext + Send + Sync + 'static>(
unsafe extern "C" fn create_context_trampoline<P, F: Fn(&P, &GLContext) -> GLContext + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLDisplay, context: *mut gst_gl_sys::GstGLContext, f: glib_sys::gpointer) -> *mut gst_gl_sys::GstGLContext &self,
where P: IsA<GLDisplay> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn create_context_trampoline<
P,
F: Fn(&P, &GLContext) -> GLContext + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLDisplay,
context: *mut gst_gl_sys::GstGLContext,
f: glib_sys::gpointer,
) -> *mut gst_gl_sys::GstGLContext
where
P: IsA<GLDisplay>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&GLDisplay::from_glib_borrow(this).unsafe_cast(), &from_glib_borrow(context)).to_glib_full() f(
&GLDisplay::from_glib_borrow(this).unsafe_cast(),
&from_glib_borrow(context),
)
.to_glib_full()
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"create-context\0".as_ptr() as *const _, connect_raw(
Some(transmute(create_context_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"create-context\0".as_ptr() as *const _,
Some(transmute(create_context_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

6
gstreamer-gl/src/auto/gl_display_egl.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLDisplay;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use GLDisplay;
glib_wrapper! { glib_wrapper! {
pub struct GLDisplayEGL(Object<gst_gl_sys::GstGLDisplayEGL, gst_gl_sys::GstGLDisplayEGLClass, GLDisplayEGLClass>) @extends GLDisplay, gst::Object; pub struct GLDisplayEGL(Object<gst_gl_sys::GstGLDisplayEGL, gst_gl_sys::GstGLDisplayEGLClass, GLDisplayEGLClass>) @extends GLDisplay, gst::Object;
@ -18,9 +18,7 @@ glib_wrapper! {
impl GLDisplayEGL { impl GLDisplayEGL {
pub fn new() -> GLDisplayEGL { pub fn new() -> GLDisplayEGL {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_gl_sys::gst_gl_display_egl_new()) }
from_glib_full(gst_gl_sys::gst_gl_display_egl_new())
}
} }
//pub fn new_with_egl_display(display: /*Unimplemented*/Option<Fundamental: Pointer>) -> GLDisplayEGL { //pub fn new_with_egl_display(display: /*Unimplemented*/Option<Fundamental: Pointer>) -> GLDisplayEGL {

6
gstreamer-gl/src/auto/gl_display_wayland.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLDisplay;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use GLDisplay;
glib_wrapper! { glib_wrapper! {
pub struct GLDisplayWayland(Object<gst_gl_sys::GstGLDisplayWayland, gst_gl_sys::GstGLDisplayWaylandClass, GLDisplayWaylandClass>) @extends GLDisplay, gst::Object; pub struct GLDisplayWayland(Object<gst_gl_sys::GstGLDisplayWayland, gst_gl_sys::GstGLDisplayWaylandClass, GLDisplayWaylandClass>) @extends GLDisplay, gst::Object;
@ -19,7 +19,9 @@ impl GLDisplayWayland {
pub fn new(name: Option<&str>) -> GLDisplayWayland { pub fn new(name: Option<&str>) -> GLDisplayWayland {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_display_wayland_new(name.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_display_wayland_new(
name.to_glib_none().0,
))
} }
} }

6
gstreamer-gl/src/auto/gl_display_x11.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLDisplay;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use GLDisplay;
glib_wrapper! { glib_wrapper! {
pub struct GLDisplayX11(Object<gst_gl_sys::GstGLDisplayX11, gst_gl_sys::GstGLDisplayX11Class, GLDisplayX11Class>) @extends GLDisplay, gst::Object; pub struct GLDisplayX11(Object<gst_gl_sys::GstGLDisplayX11, gst_gl_sys::GstGLDisplayX11Class, GLDisplayX11Class>) @extends GLDisplay, gst::Object;
@ -18,9 +18,7 @@ glib_wrapper! {
impl GLDisplayX11 { impl GLDisplayX11 {
pub fn new(name: Option<&str>) -> GLDisplayX11 { pub fn new(name: Option<&str>) -> GLDisplayX11 {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_gl_sys::gst_gl_display_x11_new(name.to_glib_none().0)) }
from_glib_full(gst_gl_sys::gst_gl_display_x11_new(name.to_glib_none().0))
}
} }
//pub fn new_with_display(display: /*Unimplemented*/Fundamental: Pointer) -> GLDisplayX11 { //pub fn new_with_display(display: /*Unimplemented*/Fundamental: Pointer) -> GLDisplayX11 {

28
gstreamer-gl/src/auto/gl_framebuffer.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use std::mem; use std::mem;
use GLContext;
glib_wrapper! { glib_wrapper! {
pub struct GLFramebuffer(Object<gst_gl_sys::GstGLFramebuffer, gst_gl_sys::GstGLFramebufferClass, GLFramebufferClass>) @extends gst::Object; pub struct GLFramebuffer(Object<gst_gl_sys::GstGLFramebuffer, gst_gl_sys::GstGLFramebufferClass, GLFramebufferClass>) @extends gst::Object;
@ -21,14 +21,24 @@ impl GLFramebuffer {
pub fn new<P: IsA<GLContext>>(context: &P) -> GLFramebuffer { pub fn new<P: IsA<GLContext>>(context: &P) -> GLFramebuffer {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_framebuffer_new(context.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_framebuffer_new(
context.as_ref().to_glib_none().0,
))
} }
} }
pub fn new_with_default_depth<P: IsA<GLContext>>(context: &P, width: u32, height: u32) -> GLFramebuffer { pub fn new_with_default_depth<P: IsA<GLContext>>(
context: &P,
width: u32,
height: u32,
) -> GLFramebuffer {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_gl_framebuffer_new_with_default_depth(context.as_ref().to_glib_none().0, width, height)) from_glib_none(gst_gl_sys::gst_gl_framebuffer_new_with_default_depth(
context.as_ref().to_glib_none().0,
width,
height,
))
} }
} }
} }
@ -69,14 +79,16 @@ impl<O: IsA<GLFramebuffer>> GLFramebufferExt for O {
unsafe { unsafe {
let mut width = mem::uninitialized(); let mut width = mem::uninitialized();
let mut height = mem::uninitialized(); let mut height = mem::uninitialized();
gst_gl_sys::gst_gl_framebuffer_get_effective_dimensions(self.as_ref().to_glib_none().0, &mut width, &mut height); gst_gl_sys::gst_gl_framebuffer_get_effective_dimensions(
self.as_ref().to_glib_none().0,
&mut width,
&mut height,
);
(width, height) (width, height)
} }
} }
fn get_id(&self) -> u32 { fn get_id(&self) -> u32 {
unsafe { unsafe { gst_gl_sys::gst_gl_framebuffer_get_id(self.as_ref().to_glib_none().0) }
gst_gl_sys::gst_gl_framebuffer_get_id(self.as_ref().to_glib_none().0)
}
} }
} }

55
gstreamer-gl/src/auto/gl_overlay_compositor.rs
View file

@ -2,20 +2,19 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::StaticType;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::Value;
use glib::object::IsA; use glib::object::IsA;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::object::ObjectType as ObjectType_; use glib::object::ObjectType as ObjectType_;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::signal::SignalHandlerId;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::signal::connect_raw; use glib::signal::connect_raw;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::StaticType;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::Value;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use glib_sys; use glib_sys;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use gobject_sys; use gobject_sys;
@ -25,6 +24,7 @@ use gst_gl_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use std::mem::transmute; use std::mem::transmute;
use GLContext;
glib_wrapper! { glib_wrapper! {
pub struct GLOverlayCompositor(Object<gst_gl_sys::GstGLOverlayCompositor, gst_gl_sys::GstGLOverlayCompositorClass, GLOverlayCompositorClass>) @extends gst::Object; pub struct GLOverlayCompositor(Object<gst_gl_sys::GstGLOverlayCompositor, gst_gl_sys::GstGLOverlayCompositorClass, GLOverlayCompositorClass>) @extends gst::Object;
@ -38,7 +38,9 @@ impl GLOverlayCompositor {
pub fn new<P: IsA<GLContext>>(context: &P) -> GLOverlayCompositor { pub fn new<P: IsA<GLContext>>(context: &P) -> GLOverlayCompositor {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_gl_overlay_compositor_new(context.as_ref().to_glib_none().0)) from_glib_none(gst_gl_sys::gst_gl_overlay_compositor_new(
context.as_ref().to_glib_none().0,
))
} }
} }
@ -58,7 +60,11 @@ impl GLOverlayCompositor {
pub fn get_property_yinvert(&self) -> bool { pub fn get_property_yinvert(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"yinvert\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"yinvert\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -66,27 +72,46 @@ impl GLOverlayCompositor {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn set_property_yinvert(&self, yinvert: bool) { pub fn set_property_yinvert(&self, yinvert: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"yinvert\0".as_ptr() as *const _, Value::from(&yinvert).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"yinvert\0".as_ptr() as *const _,
Value::from(&yinvert).to_glib_none().0,
);
} }
} }
pub fn add_caps(caps: &gst::Caps) -> Option<gst::Caps> { pub fn add_caps(caps: &gst::Caps) -> Option<gst::Caps> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_overlay_compositor_add_caps(caps.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_overlay_compositor_add_caps(
caps.to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn connect_property_yinvert_notify<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_yinvert_notify<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(
unsafe extern "C" fn notify_yinvert_trampoline<F: Fn(&GLOverlayCompositor) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLOverlayCompositor, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_yinvert_trampoline<
F: Fn(&GLOverlayCompositor) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLOverlayCompositor,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::yinvert\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_yinvert_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::yinvert\0".as_ptr() as *const _,
Some(transmute(notify_yinvert_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

279
gstreamer-gl/src/auto/gl_shader.rs
View file

@ -2,23 +2,16 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use Error;
use GLContext;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use GLSLProfile;
use GLSLStage;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use GLSLVersion;
use glib; use glib;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -26,6 +19,13 @@ use gst_gl_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use Error;
use GLContext;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use GLSLProfile;
use GLSLStage;
#[cfg(any(feature = "v1_16", feature = "dox"))]
use GLSLVersion;
glib_wrapper! { glib_wrapper! {
pub struct GLShader(Object<gst_gl_sys::GstGLShader, gst_gl_sys::GstGLShaderClass, GLShaderClass>) @extends gst::Object; pub struct GLShader(Object<gst_gl_sys::GstGLShader, gst_gl_sys::GstGLShaderClass, GLShaderClass>) @extends gst::Object;
@ -39,7 +39,9 @@ impl GLShader {
pub fn new<P: IsA<GLContext>>(context: &P) -> GLShader { pub fn new<P: IsA<GLContext>>(context: &P) -> GLShader {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_shader_new(context.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_shader_new(
context.as_ref().to_glib_none().0,
))
} }
} }
@ -47,8 +49,15 @@ impl GLShader {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_gl_sys::gst_gl_shader_new_default(context.as_ref().to_glib_none().0, &mut error); let ret = gst_gl_sys::gst_gl_shader_new_default(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } context.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
@ -62,33 +71,58 @@ impl GLShader {
pub fn attach(&self, stage: &GLSLStage) -> Result<(), glib::error::BoolError> { pub fn attach(&self, stage: &GLSLStage) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_shader_attach(self.to_glib_none().0, stage.to_glib_none().0), "Failed to attach stage to shader") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_shader_attach(self.to_glib_none().0, stage.to_glib_none().0),
"Failed to attach stage to shader"
)
} }
} }
pub fn attach_unlocked(&self, stage: &GLSLStage) -> Result<(), glib::error::BoolError> { pub fn attach_unlocked(&self, stage: &GLSLStage) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_shader_attach_unlocked(self.to_glib_none().0, stage.to_glib_none().0), "Failed to attach stage to shader") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_shader_attach_unlocked(
self.to_glib_none().0,
stage.to_glib_none().0
),
"Failed to attach stage to shader"
)
} }
} }
pub fn bind_attribute_location(&self, index: u32, name: &str) { pub fn bind_attribute_location(&self, index: u32, name: &str) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_bind_attribute_location(self.to_glib_none().0, index, name.to_glib_none().0); gst_gl_sys::gst_gl_shader_bind_attribute_location(
self.to_glib_none().0,
index,
name.to_glib_none().0,
);
} }
} }
pub fn bind_frag_data_location(&self, index: u32, name: &str) { pub fn bind_frag_data_location(&self, index: u32, name: &str) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_bind_frag_data_location(self.to_glib_none().0, index, name.to_glib_none().0); gst_gl_sys::gst_gl_shader_bind_frag_data_location(
self.to_glib_none().0,
index,
name.to_glib_none().0,
);
} }
} }
pub fn compile_attach_stage(&self, stage: &GLSLStage) -> Result<(), Error> { pub fn compile_attach_stage(&self, stage: &GLSLStage) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_gl_shader_compile_attach_stage(self.to_glib_none().0, stage.to_glib_none().0, &mut error); let _ = gst_gl_sys::gst_gl_shader_compile_attach_stage(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.to_glib_none().0,
stage.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
@ -100,33 +134,39 @@ impl GLShader {
pub fn detach_unlocked(&self, stage: &GLSLStage) { pub fn detach_unlocked(&self, stage: &GLSLStage) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_detach_unlocked(self.to_glib_none().0, stage.to_glib_none().0); gst_gl_sys::gst_gl_shader_detach_unlocked(
self.to_glib_none().0,
stage.to_glib_none().0,
);
} }
} }
pub fn get_attribute_location(&self, name: &str) -> i32 { pub fn get_attribute_location(&self, name: &str) -> i32 {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_get_attribute_location(self.to_glib_none().0, name.to_glib_none().0) gst_gl_sys::gst_gl_shader_get_attribute_location(
self.to_glib_none().0,
name.to_glib_none().0,
)
} }
} }
pub fn get_program_handle(&self) -> i32 { pub fn get_program_handle(&self) -> i32 {
unsafe { unsafe { gst_gl_sys::gst_gl_shader_get_program_handle(self.to_glib_none().0) }
gst_gl_sys::gst_gl_shader_get_program_handle(self.to_glib_none().0)
}
} }
pub fn is_linked(&self) -> bool { pub fn is_linked(&self) -> bool {
unsafe { unsafe { from_glib(gst_gl_sys::gst_gl_shader_is_linked(self.to_glib_none().0)) }
from_glib(gst_gl_sys::gst_gl_shader_is_linked(self.to_glib_none().0))
}
} }
pub fn link(&self) -> Result<(), Error> { pub fn link(&self) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_gl_shader_link(self.to_glib_none().0, &mut error); let _ = gst_gl_sys::gst_gl_shader_link(self.to_glib_none().0, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
@ -144,105 +184,189 @@ impl GLShader {
pub fn set_uniform_1f(&self, name: &str, value: f32) { pub fn set_uniform_1f(&self, name: &str, value: f32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_1f(self.to_glib_none().0, name.to_glib_none().0, value); gst_gl_sys::gst_gl_shader_set_uniform_1f(
self.to_glib_none().0,
name.to_glib_none().0,
value,
);
} }
} }
pub fn set_uniform_1fv(&self, name: &str, value: &[f32]) { pub fn set_uniform_1fv(&self, name: &str, value: &[f32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_1fv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_1fv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_1i(&self, name: &str, value: i32) { pub fn set_uniform_1i(&self, name: &str, value: i32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_1i(self.to_glib_none().0, name.to_glib_none().0, value); gst_gl_sys::gst_gl_shader_set_uniform_1i(
self.to_glib_none().0,
name.to_glib_none().0,
value,
);
} }
} }
pub fn set_uniform_1iv(&self, name: &str, value: &[i32]) { pub fn set_uniform_1iv(&self, name: &str, value: &[i32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_1iv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_1iv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_2f(&self, name: &str, v0: f32, v1: f32) { pub fn set_uniform_2f(&self, name: &str, v0: f32, v1: f32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_2f(self.to_glib_none().0, name.to_glib_none().0, v0, v1); gst_gl_sys::gst_gl_shader_set_uniform_2f(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
);
} }
} }
pub fn set_uniform_2fv(&self, name: &str, value: &[f32]) { pub fn set_uniform_2fv(&self, name: &str, value: &[f32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_2fv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_2fv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_2i(&self, name: &str, v0: i32, v1: i32) { pub fn set_uniform_2i(&self, name: &str, v0: i32, v1: i32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_2i(self.to_glib_none().0, name.to_glib_none().0, v0, v1); gst_gl_sys::gst_gl_shader_set_uniform_2i(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
);
} }
} }
pub fn set_uniform_2iv(&self, name: &str, value: &[i32]) { pub fn set_uniform_2iv(&self, name: &str, value: &[i32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_2iv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_2iv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_3f(&self, name: &str, v0: f32, v1: f32, v2: f32) { pub fn set_uniform_3f(&self, name: &str, v0: f32, v1: f32, v2: f32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_3f(self.to_glib_none().0, name.to_glib_none().0, v0, v1, v2); gst_gl_sys::gst_gl_shader_set_uniform_3f(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
v2,
);
} }
} }
pub fn set_uniform_3fv(&self, name: &str, value: &[f32]) { pub fn set_uniform_3fv(&self, name: &str, value: &[f32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_3fv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_3fv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_3i(&self, name: &str, v0: i32, v1: i32, v2: i32) { pub fn set_uniform_3i(&self, name: &str, v0: i32, v1: i32, v2: i32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_3i(self.to_glib_none().0, name.to_glib_none().0, v0, v1, v2); gst_gl_sys::gst_gl_shader_set_uniform_3i(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
v2,
);
} }
} }
pub fn set_uniform_3iv(&self, name: &str, value: &[i32]) { pub fn set_uniform_3iv(&self, name: &str, value: &[i32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_3iv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_3iv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_4f(&self, name: &str, v0: f32, v1: f32, v2: f32, v3: f32) { pub fn set_uniform_4f(&self, name: &str, v0: f32, v1: f32, v2: f32, v3: f32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_4f(self.to_glib_none().0, name.to_glib_none().0, v0, v1, v2, v3); gst_gl_sys::gst_gl_shader_set_uniform_4f(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
v2,
v3,
);
} }
} }
pub fn set_uniform_4fv(&self, name: &str, value: &[f32]) { pub fn set_uniform_4fv(&self, name: &str, value: &[f32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_4fv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_4fv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
pub fn set_uniform_4i(&self, name: &str, v0: i32, v1: i32, v2: i32, v3: i32) { pub fn set_uniform_4i(&self, name: &str, v0: i32, v1: i32, v2: i32, v3: i32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_4i(self.to_glib_none().0, name.to_glib_none().0, v0, v1, v2, v3); gst_gl_sys::gst_gl_shader_set_uniform_4i(
self.to_glib_none().0,
name.to_glib_none().0,
v0,
v1,
v2,
v3,
);
} }
} }
pub fn set_uniform_4iv(&self, name: &str, value: &[i32]) { pub fn set_uniform_4iv(&self, name: &str, value: &[i32]) {
let count = value.len() as u32; let count = value.len() as u32;
unsafe { unsafe {
gst_gl_sys::gst_gl_shader_set_uniform_4iv(self.to_glib_none().0, name.to_glib_none().0, count, value.to_glib_none().0); gst_gl_sys::gst_gl_shader_set_uniform_4iv(
self.to_glib_none().0,
name.to_glib_none().0,
count,
value.to_glib_none().0,
);
} }
} }
@ -255,44 +379,85 @@ impl GLShader {
pub fn get_property_linked(&self) -> bool { pub fn get_property_linked(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"linked\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"linked\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn string_fragment_external_oes_get_default<P: IsA<GLContext>>(context: &P, version: GLSLVersion, profile: GLSLProfile) -> Option<GString> { pub fn string_fragment_external_oes_get_default<P: IsA<GLContext>>(
context: &P,
version: GLSLVersion,
profile: GLSLProfile,
) -> Option<GString> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_shader_string_fragment_external_oes_get_default(context.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib_full(
gst_gl_sys::gst_gl_shader_string_fragment_external_oes_get_default(
context.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
),
)
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn string_fragment_get_default<P: IsA<GLContext>>(context: &P, version: GLSLVersion, profile: GLSLProfile) -> Option<GString> { pub fn string_fragment_get_default<P: IsA<GLContext>>(
context: &P,
version: GLSLVersion,
profile: GLSLProfile,
) -> Option<GString> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_shader_string_fragment_get_default(context.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib_full(gst_gl_sys::gst_gl_shader_string_fragment_get_default(
context.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
))
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn string_get_highest_precision<P: IsA<GLContext>>(context: &P, version: GLSLVersion, profile: GLSLProfile) -> Option<GString> { pub fn string_get_highest_precision<P: IsA<GLContext>>(
context: &P,
version: GLSLVersion,
profile: GLSLProfile,
) -> Option<GString> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_gl_shader_string_get_highest_precision(context.as_ref().to_glib_none().0, version.to_glib(), profile.to_glib())) from_glib_none(gst_gl_sys::gst_gl_shader_string_get_highest_precision(
context.as_ref().to_glib_none().0,
version.to_glib(),
profile.to_glib(),
))
} }
} }
pub fn connect_property_linked_notify<F: Fn(&GLShader) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_linked_notify<F: Fn(&GLShader) + Send + Sync + 'static>(
unsafe extern "C" fn notify_linked_trampoline<F: Fn(&GLShader) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLShader, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_linked_trampoline<F: Fn(&GLShader) + Send + Sync + 'static>(
this: *mut gst_gl_sys::GstGLShader,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::linked\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_linked_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::linked\0".as_ptr() as *const _,
Some(transmute(notify_linked_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

46
gstreamer-gl/src/auto/gl_upload.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use glib; use glib;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
use std::ptr; use std::ptr;
use GLContext;
glib_wrapper! { glib_wrapper! {
pub struct GLUpload(Object<gst_gl_sys::GstGLUpload, gst_gl_sys::GstGLUploadClass, GLUploadClass>) @extends gst::Object; pub struct GLUpload(Object<gst_gl_sys::GstGLUpload, gst_gl_sys::GstGLUploadClass, GLUploadClass>) @extends gst::Object;
@ -22,7 +22,9 @@ impl GLUpload {
pub fn new<P: IsA<GLContext>>(context: &P) -> GLUpload { pub fn new<P: IsA<GLContext>>(context: &P) -> GLUpload {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_upload_new(context.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_upload_new(
context.as_ref().to_glib_none().0,
))
} }
} }
@ -35,29 +37,53 @@ impl GLUpload {
} }
} }
pub fn set_caps(&self, in_caps: &gst::Caps, out_caps: &gst::Caps) -> Result<(), glib::error::BoolError> { pub fn set_caps(
&self,
in_caps: &gst::Caps,
out_caps: &gst::Caps,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_upload_set_caps(self.to_glib_none().0, in_caps.to_glib_none().0, out_caps.to_glib_none().0), "Failed to set caps") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_upload_set_caps(
self.to_glib_none().0,
in_caps.to_glib_none().0,
out_caps.to_glib_none().0
),
"Failed to set caps"
)
} }
} }
pub fn set_context<P: IsA<GLContext>>(&self, context: &P) { pub fn set_context<P: IsA<GLContext>>(&self, context: &P) {
unsafe { unsafe {
gst_gl_sys::gst_gl_upload_set_context(self.to_glib_none().0, context.as_ref().to_glib_none().0); gst_gl_sys::gst_gl_upload_set_context(
self.to_glib_none().0,
context.as_ref().to_glib_none().0,
);
} }
} }
pub fn transform_caps<P: IsA<GLContext>>(&self, context: &P, direction: gst::PadDirection, caps: &gst::Caps, filter: &gst::Caps) -> Option<gst::Caps> { pub fn transform_caps<P: IsA<GLContext>>(
&self,
context: &P,
direction: gst::PadDirection,
caps: &gst::Caps,
filter: &gst::Caps,
) -> Option<gst::Caps> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_upload_transform_caps(self.to_glib_none().0, context.as_ref().to_glib_none().0, direction.to_glib(), caps.to_glib_none().0, filter.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_upload_transform_caps(
self.to_glib_none().0,
context.as_ref().to_glib_none().0,
direction.to_glib(),
caps.to_glib_none().0,
filter.to_glib_none().0,
))
} }
} }
pub fn get_input_template_caps() -> gst::Caps { pub fn get_input_template_caps() -> gst::Caps {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_gl_sys::gst_gl_upload_get_input_template_caps()) }
from_glib_full(gst_gl_sys::gst_gl_upload_get_input_template_caps())
}
} }
} }

266
gstreamer-gl/src/auto/gl_view_convert.rs
View file

@ -2,16 +2,14 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use GLStereoDownmix;
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::IsA; use glib::object::IsA;
use glib::object::ObjectType as ObjectType_; use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -19,6 +17,8 @@ use gst_gl_sys;
use gst_video; use gst_video;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use GLContext;
use GLStereoDownmix;
glib_wrapper! { glib_wrapper! {
pub struct GLViewConvert(Object<gst_gl_sys::GstGLViewConvert, gst_gl_sys::GstGLViewConvertClass, GLViewConvertClass>) @extends gst::Object; pub struct GLViewConvert(Object<gst_gl_sys::GstGLViewConvert, gst_gl_sys::GstGLViewConvertClass, GLViewConvertClass>) @extends gst::Object;
@ -31,14 +31,15 @@ glib_wrapper! {
impl GLViewConvert { impl GLViewConvert {
pub fn new() -> GLViewConvert { pub fn new() -> GLViewConvert {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_gl_sys::gst_gl_view_convert_new()) }
from_glib_full(gst_gl_sys::gst_gl_view_convert_new())
}
} }
pub fn perform(&self, inbuf: &gst::Buffer) -> Option<gst::Buffer> { pub fn perform(&self, inbuf: &gst::Buffer) -> Option<gst::Buffer> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_view_convert_perform(self.to_glib_none().0, inbuf.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_view_convert_perform(
self.to_glib_none().0,
inbuf.to_glib_none().0,
))
} }
} }
@ -48,151 +49,312 @@ impl GLViewConvert {
} }
} }
pub fn set_caps(&self, in_caps: &gst::Caps, out_caps: &gst::Caps) -> Result<(), glib::error::BoolError> { pub fn set_caps(
&self,
in_caps: &gst::Caps,
out_caps: &gst::Caps,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_view_convert_set_caps(self.to_glib_none().0, in_caps.to_glib_none().0, out_caps.to_glib_none().0), "Failed to set caps") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_view_convert_set_caps(
self.to_glib_none().0,
in_caps.to_glib_none().0,
out_caps.to_glib_none().0
),
"Failed to set caps"
)
} }
} }
pub fn set_context<P: IsA<GLContext>>(&self, context: &P) { pub fn set_context<P: IsA<GLContext>>(&self, context: &P) {
unsafe { unsafe {
gst_gl_sys::gst_gl_view_convert_set_context(self.to_glib_none().0, context.as_ref().to_glib_none().0); gst_gl_sys::gst_gl_view_convert_set_context(
self.to_glib_none().0,
context.as_ref().to_glib_none().0,
);
} }
} }
pub fn transform_caps(&self, direction: gst::PadDirection, caps: &gst::Caps, filter: &gst::Caps) -> Option<gst::Caps> { pub fn transform_caps(
&self,
direction: gst::PadDirection,
caps: &gst::Caps,
filter: &gst::Caps,
) -> Option<gst::Caps> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_view_convert_transform_caps(self.to_glib_none().0, direction.to_glib(), caps.to_glib_none().0, filter.to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_view_convert_transform_caps(
self.to_glib_none().0,
direction.to_glib(),
caps.to_glib_none().0,
filter.to_glib_none().0,
))
} }
} }
pub fn get_property_downmix_mode(&self) -> GLStereoDownmix { pub fn get_property_downmix_mode(&self) -> GLStereoDownmix {
unsafe { unsafe {
let mut value = Value::from_type(<GLStereoDownmix as StaticType>::static_type()); let mut value = Value::from_type(<GLStereoDownmix as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"downmix-mode\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"downmix-mode\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_downmix_mode(&self, downmix_mode: GLStereoDownmix) { pub fn set_property_downmix_mode(&self, downmix_mode: GLStereoDownmix) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"downmix-mode\0".as_ptr() as *const _, Value::from(&downmix_mode).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"downmix-mode\0".as_ptr() as *const _,
Value::from(&downmix_mode).to_glib_none().0,
);
} }
} }
pub fn get_property_input_flags_override(&self) -> gst_video::VideoMultiviewFlags { pub fn get_property_input_flags_override(&self) -> gst_video::VideoMultiviewFlags {
unsafe { unsafe {
let mut value = Value::from_type(<gst_video::VideoMultiviewFlags as StaticType>::static_type()); let mut value =
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"input-flags-override\0".as_ptr() as *const _, value.to_glib_none_mut().0); Value::from_type(<gst_video::VideoMultiviewFlags as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"input-flags-override\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_input_flags_override(&self, input_flags_override: gst_video::VideoMultiviewFlags) { pub fn set_property_input_flags_override(
&self,
input_flags_override: gst_video::VideoMultiviewFlags,
) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"input-flags-override\0".as_ptr() as *const _, Value::from(&input_flags_override).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"input-flags-override\0".as_ptr() as *const _,
Value::from(&input_flags_override).to_glib_none().0,
);
} }
} }
pub fn get_property_input_mode_override(&self) -> gst_video::VideoMultiviewMode { pub fn get_property_input_mode_override(&self) -> gst_video::VideoMultiviewMode {
unsafe { unsafe {
let mut value = Value::from_type(<gst_video::VideoMultiviewMode as StaticType>::static_type()); let mut value =
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"input-mode-override\0".as_ptr() as *const _, value.to_glib_none_mut().0); Value::from_type(<gst_video::VideoMultiviewMode as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"input-mode-override\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_input_mode_override(&self, input_mode_override: gst_video::VideoMultiviewMode) { pub fn set_property_input_mode_override(
&self,
input_mode_override: gst_video::VideoMultiviewMode,
) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"input-mode-override\0".as_ptr() as *const _, Value::from(&input_mode_override).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"input-mode-override\0".as_ptr() as *const _,
Value::from(&input_mode_override).to_glib_none().0,
);
} }
} }
pub fn get_property_output_flags_override(&self) -> gst_video::VideoMultiviewFlags { pub fn get_property_output_flags_override(&self) -> gst_video::VideoMultiviewFlags {
unsafe { unsafe {
let mut value = Value::from_type(<gst_video::VideoMultiviewFlags as StaticType>::static_type()); let mut value =
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"output-flags-override\0".as_ptr() as *const _, value.to_glib_none_mut().0); Value::from_type(<gst_video::VideoMultiviewFlags as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"output-flags-override\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_output_flags_override(&self, output_flags_override: gst_video::VideoMultiviewFlags) { pub fn set_property_output_flags_override(
&self,
output_flags_override: gst_video::VideoMultiviewFlags,
) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"output-flags-override\0".as_ptr() as *const _, Value::from(&output_flags_override).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"output-flags-override\0".as_ptr() as *const _,
Value::from(&output_flags_override).to_glib_none().0,
);
} }
} }
pub fn get_property_output_mode_override(&self) -> gst_video::VideoMultiviewMode { pub fn get_property_output_mode_override(&self) -> gst_video::VideoMultiviewMode {
unsafe { unsafe {
let mut value = Value::from_type(<gst_video::VideoMultiviewMode as StaticType>::static_type()); let mut value =
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"output-mode-override\0".as_ptr() as *const _, value.to_glib_none_mut().0); Value::from_type(<gst_video::VideoMultiviewMode as StaticType>::static_type());
gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"output-mode-override\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_output_mode_override(&self, output_mode_override: gst_video::VideoMultiviewMode) { pub fn set_property_output_mode_override(
&self,
output_mode_override: gst_video::VideoMultiviewMode,
) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"output-mode-override\0".as_ptr() as *const _, Value::from(&output_mode_override).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"output-mode-override\0".as_ptr() as *const _,
Value::from(&output_mode_override).to_glib_none().0,
);
} }
} }
pub fn connect_property_downmix_mode_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_downmix_mode_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(
unsafe extern "C" fn notify_downmix_mode_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_downmix_mode_trampoline<
F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLViewConvert,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::downmix-mode\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_downmix_mode_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::downmix-mode\0".as_ptr() as *const _,
Some(transmute(notify_downmix_mode_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_input_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_input_flags_override_notify<
unsafe extern "C" fn notify_input_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_input_flags_override_trampoline<
F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLViewConvert,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::input-flags-override\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_input_flags_override_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::input-flags-override\0".as_ptr() as *const _,
Some(transmute(
notify_input_flags_override_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_input_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_input_mode_override_notify<
unsafe extern "C" fn notify_input_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_input_mode_override_trampoline<
F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLViewConvert,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::input-mode-override\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_input_mode_override_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::input-mode-override\0".as_ptr() as *const _,
Some(transmute(
notify_input_mode_override_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_output_flags_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_output_flags_override_notify<
unsafe extern "C" fn notify_output_flags_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_output_flags_override_trampoline<
F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLViewConvert,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::output-flags-override\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_output_flags_override_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::output-flags-override\0".as_ptr() as *const _,
Some(transmute(
notify_output_flags_override_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_output_mode_override_notify<F: Fn(&GLViewConvert) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_output_mode_override_notify<
unsafe extern "C" fn notify_output_mode_override_trampoline<F: Fn(&GLViewConvert) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLViewConvert, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_output_mode_override_trampoline<
F: Fn(&GLViewConvert) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLViewConvert,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::output-mode-override\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_output_mode_override_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::output-mode-override\0".as_ptr() as *const _,
Some(transmute(
notify_output_mode_override_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
} }

154
gstreamer-gl/src/auto/gl_window.rs
View file

@ -2,15 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use GLContext;
use GLDisplay;
use glib; use glib;
use glib::GString;
use glib::object::Cast; use glib::object::Cast;
use glib::object::IsA; use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw; use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use glib_sys; use glib_sys;
use gst; use gst;
use gst_gl_sys; use gst_gl_sys;
@ -18,6 +16,8 @@ use libc;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem; use std::mem;
use std::mem::transmute; use std::mem::transmute;
use GLContext;
use GLDisplay;
glib_wrapper! { glib_wrapper! {
pub struct GLWindow(Object<gst_gl_sys::GstGLWindow, gst_gl_sys::GstGLWindowClass, GLWindowClass>) @extends gst::Object; pub struct GLWindow(Object<gst_gl_sys::GstGLWindow, gst_gl_sys::GstGLWindowClass, GLWindowClass>) @extends gst::Object;
@ -31,7 +31,9 @@ impl GLWindow {
pub fn new<P: IsA<GLDisplay>>(display: &P) -> GLWindow { pub fn new<P: IsA<GLDisplay>>(display: &P) -> GLWindow {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_window_new(display.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_window_new(
display.as_ref().to_glib_none().0,
))
} }
} }
} }
@ -67,20 +69,34 @@ pub trait GLWindowExt: 'static {
fn set_preferred_size(&self, width: i32, height: i32); fn set_preferred_size(&self, width: i32, height: i32);
fn set_render_rectangle(&self, x: i32, y: i32, width: i32, height: i32) -> Result<(), glib::error::BoolError>; fn set_render_rectangle(
&self,
x: i32,
y: i32,
width: i32,
height: i32,
) -> Result<(), glib::error::BoolError>;
fn show(&self); fn show(&self);
fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId; fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(
&self,
f: F,
) -> SignalHandlerId;
} }
impl<O: IsA<GLWindow>> GLWindowExt for O { impl<O: IsA<GLWindow>> GLWindowExt for O {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
fn controls_viewport(&self) -> bool { fn controls_viewport(&self) -> bool {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_gl_window_controls_viewport(self.as_ref().to_glib_none().0)) from_glib(gst_gl_sys::gst_gl_window_controls_viewport(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -92,7 +108,9 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
fn get_context(&self) -> Option<GLContext> { fn get_context(&self) -> Option<GLContext> {
unsafe { unsafe {
from_glib_full(gst_gl_sys::gst_gl_window_get_context(self.as_ref().to_glib_none().0)) from_glib_full(gst_gl_sys::gst_gl_window_get_context(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -100,14 +118,21 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
unsafe { unsafe {
let mut width = mem::uninitialized(); let mut width = mem::uninitialized();
let mut height = mem::uninitialized(); let mut height = mem::uninitialized();
gst_gl_sys::gst_gl_window_get_surface_dimensions(self.as_ref().to_glib_none().0, &mut width, &mut height); gst_gl_sys::gst_gl_window_get_surface_dimensions(
self.as_ref().to_glib_none().0,
&mut width,
&mut height,
);
(width, height) (width, height)
} }
} }
fn handle_events(&self, handle_events: bool) { fn handle_events(&self, handle_events: bool) {
unsafe { unsafe {
gst_gl_sys::gst_gl_window_handle_events(self.as_ref().to_glib_none().0, handle_events.to_glib()); gst_gl_sys::gst_gl_window_handle_events(
self.as_ref().to_glib_none().0,
handle_events.to_glib(),
);
} }
} }
@ -137,25 +162,54 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
fn send_key_event(&self, event_type: &str, key_str: &str) { fn send_key_event(&self, event_type: &str, key_str: &str) {
unsafe { unsafe {
gst_gl_sys::gst_gl_window_send_key_event(self.as_ref().to_glib_none().0, event_type.to_glib_none().0, key_str.to_glib_none().0); gst_gl_sys::gst_gl_window_send_key_event(
self.as_ref().to_glib_none().0,
event_type.to_glib_none().0,
key_str.to_glib_none().0,
);
} }
} }
fn send_mouse_event(&self, event_type: &str, button: i32, posx: f64, posy: f64) { fn send_mouse_event(&self, event_type: &str, button: i32, posx: f64, posy: f64) {
unsafe { unsafe {
gst_gl_sys::gst_gl_window_send_mouse_event(self.as_ref().to_glib_none().0, event_type.to_glib_none().0, button, posx, posy); gst_gl_sys::gst_gl_window_send_mouse_event(
self.as_ref().to_glib_none().0,
event_type.to_glib_none().0,
button,
posx,
posy,
);
} }
} }
fn set_preferred_size(&self, width: i32, height: i32) { fn set_preferred_size(&self, width: i32, height: i32) {
unsafe { unsafe {
gst_gl_sys::gst_gl_window_set_preferred_size(self.as_ref().to_glib_none().0, width, height); gst_gl_sys::gst_gl_window_set_preferred_size(
self.as_ref().to_glib_none().0,
width,
height,
);
} }
} }
fn set_render_rectangle(&self, x: i32, y: i32, width: i32, height: i32) -> Result<(), glib::error::BoolError> { fn set_render_rectangle(
&self,
x: i32,
y: i32,
width: i32,
height: i32,
) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_gl_window_set_render_rectangle(self.as_ref().to_glib_none().0, x, y, width, height), "Failed to set the specified region") glib_result_from_gboolean!(
gst_gl_sys::gst_gl_window_set_render_rectangle(
self.as_ref().to_glib_none().0,
x,
y,
width,
height
),
"Failed to set the specified region"
)
} }
} }
@ -165,31 +219,73 @@ impl<O: IsA<GLWindow>> GLWindowExt for O {
} }
} }
fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_key_event<F: Fn(&Self, &str, &str) + Send + Sync + 'static>(
unsafe extern "C" fn key_event_trampoline<P, F: Fn(&P, &str, &str) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, key: *mut libc::c_char, f: glib_sys::gpointer) &self,
where P: IsA<GLWindow> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn key_event_trampoline<
P,
F: Fn(&P, &str, &str) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLWindow,
id: *mut libc::c_char,
key: *mut libc::c_char,
f: glib_sys::gpointer,
) where
P: IsA<GLWindow>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), &GString::from_glib_borrow(key)) f(
&GLWindow::from_glib_borrow(this).unsafe_cast(),
&GString::from_glib_borrow(id),
&GString::from_glib_borrow(key),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"key-event\0".as_ptr() as *const _, connect_raw(
Some(transmute(key_event_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"key-event\0".as_ptr() as *const _,
Some(transmute(key_event_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { fn connect_mouse_event<F: Fn(&Self, &str, i32, f64, f64) + Send + Sync + 'static>(
unsafe extern "C" fn mouse_event_trampoline<P, F: Fn(&P, &str, i32, f64, f64) + Send + Sync + 'static>(this: *mut gst_gl_sys::GstGLWindow, id: *mut libc::c_char, button: libc::c_int, x: libc::c_double, y: libc::c_double, f: glib_sys::gpointer) &self,
where P: IsA<GLWindow> f: F,
) -> SignalHandlerId {
unsafe extern "C" fn mouse_event_trampoline<
P,
F: Fn(&P, &str, i32, f64, f64) + Send + Sync + 'static,
>(
this: *mut gst_gl_sys::GstGLWindow,
id: *mut libc::c_char,
button: libc::c_int,
x: libc::c_double,
y: libc::c_double,
f: glib_sys::gpointer,
) where
P: IsA<GLWindow>,
{ {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&GLWindow::from_glib_borrow(this).unsafe_cast(), &GString::from_glib_borrow(id), button, x, y) f(
&GLWindow::from_glib_borrow(this).unsafe_cast(),
&GString::from_glib_borrow(id),
button,
x,
y,
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"mouse-event\0".as_ptr() as *const _, connect_raw(
Some(transmute(mouse_event_trampoline::<Self, F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"mouse-event\0".as_ptr() as *const _,
Some(transmute(mouse_event_trampoline::<Self, F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

100
gstreamer-gl/src/auto/glsl_stage.rs
View file

@ -2,17 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib;
use glib::object::IsA;
use glib::translate::*;
use glib::GString;
use gst;
use gst_gl_sys;
use std::ptr;
use Error; use Error;
use GLContext; use GLContext;
use GLSLProfile; use GLSLProfile;
use GLSLVersion; use GLSLVersion;
use glib;
use glib::GString;
use glib::object::IsA;
use glib::translate::*;
use gst;
use gst_gl_sys;
use std::ptr;
glib_wrapper! { glib_wrapper! {
pub struct GLSLStage(Object<gst_gl_sys::GstGLSLStage, gst_gl_sys::GstGLSLStageClass, GLSLStageClass>) @extends gst::Object; pub struct GLSLStage(Object<gst_gl_sys::GstGLSLStage, gst_gl_sys::GstGLSLStageClass, GLSLStageClass>) @extends gst::Object;
@ -26,36 +26,68 @@ impl GLSLStage {
pub fn new<P: IsA<GLContext>>(context: &P, type_: u32) -> GLSLStage { pub fn new<P: IsA<GLContext>>(context: &P, type_: u32) -> GLSLStage {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_glsl_stage_new(context.as_ref().to_glib_none().0, type_)) from_glib_none(gst_gl_sys::gst_glsl_stage_new(
context.as_ref().to_glib_none().0,
type_,
))
} }
} }
pub fn new_default_fragment<P: IsA<GLContext>>(context: &P) -> GLSLStage { pub fn new_default_fragment<P: IsA<GLContext>>(context: &P) -> GLSLStage {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_glsl_stage_new_default_fragment(context.as_ref().to_glib_none().0)) from_glib_none(gst_gl_sys::gst_glsl_stage_new_default_fragment(
context.as_ref().to_glib_none().0,
))
} }
} }
pub fn new_default_vertex<P: IsA<GLContext>>(context: &P) -> GLSLStage { pub fn new_default_vertex<P: IsA<GLContext>>(context: &P) -> GLSLStage {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_glsl_stage_new_default_vertex(context.as_ref().to_glib_none().0)) from_glib_none(gst_gl_sys::gst_glsl_stage_new_default_vertex(
context.as_ref().to_glib_none().0,
))
} }
} }
pub fn new_with_string<P: IsA<GLContext>>(context: &P, type_: u32, version: GLSLVersion, profile: GLSLProfile, str: &str) -> GLSLStage { pub fn new_with_string<P: IsA<GLContext>>(
context: &P,
type_: u32,
version: GLSLVersion,
profile: GLSLProfile,
str: &str,
) -> GLSLStage {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_glsl_stage_new_with_string(context.as_ref().to_glib_none().0, type_, version.to_glib(), profile.to_glib(), str.to_glib_none().0)) from_glib_none(gst_gl_sys::gst_glsl_stage_new_with_string(
context.as_ref().to_glib_none().0,
type_,
version.to_glib(),
profile.to_glib(),
str.to_glib_none().0,
))
} }
} }
pub fn new_with_strings<P: IsA<GLContext>>(context: &P, type_: u32, version: GLSLVersion, profile: GLSLProfile, str: &[&str]) -> GLSLStage { pub fn new_with_strings<P: IsA<GLContext>>(
context: &P,
type_: u32,
version: GLSLVersion,
profile: GLSLProfile,
str: &[&str],
) -> GLSLStage {
skip_assert_initialized!(); skip_assert_initialized!();
let n_strings = str.len() as i32; let n_strings = str.len() as i32;
unsafe { unsafe {
from_glib_none(gst_gl_sys::gst_glsl_stage_new_with_strings(context.as_ref().to_glib_none().0, type_, version.to_glib(), profile.to_glib(), n_strings, str.to_glib_none().0)) from_glib_none(gst_gl_sys::gst_glsl_stage_new_with_strings(
context.as_ref().to_glib_none().0,
type_,
version.to_glib(),
profile.to_glib(),
n_strings,
str.to_glib_none().0,
))
} }
} }
@ -63,38 +95,56 @@ impl GLSLStage {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_gl_sys::gst_glsl_stage_compile(self.to_glib_none().0, &mut error); let _ = gst_gl_sys::gst_glsl_stage_compile(self.to_glib_none().0, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
pub fn get_handle(&self) -> u32 { pub fn get_handle(&self) -> u32 {
unsafe { unsafe { gst_gl_sys::gst_glsl_stage_get_handle(self.to_glib_none().0) }
gst_gl_sys::gst_glsl_stage_get_handle(self.to_glib_none().0)
}
} }
pub fn get_profile(&self) -> GLSLProfile { pub fn get_profile(&self) -> GLSLProfile {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_glsl_stage_get_profile(self.to_glib_none().0)) from_glib(gst_gl_sys::gst_glsl_stage_get_profile(
self.to_glib_none().0,
))
} }
} }
pub fn get_shader_type(&self) -> u32 { pub fn get_shader_type(&self) -> u32 {
unsafe { unsafe { gst_gl_sys::gst_glsl_stage_get_shader_type(self.to_glib_none().0) }
gst_gl_sys::gst_glsl_stage_get_shader_type(self.to_glib_none().0)
}
} }
pub fn get_version(&self) -> GLSLVersion { pub fn get_version(&self) -> GLSLVersion {
unsafe { unsafe {
from_glib(gst_gl_sys::gst_glsl_stage_get_version(self.to_glib_none().0)) from_glib(gst_gl_sys::gst_glsl_stage_get_version(
self.to_glib_none().0,
))
} }
} }
pub fn set_strings(&self, version: GLSLVersion, profile: GLSLProfile, str: &[&str]) -> Result<(), glib::error::BoolError> { pub fn set_strings(
&self,
version: GLSLVersion,
profile: GLSLProfile,
str: &[&str],
) -> Result<(), glib::error::BoolError> {
let n_strings = str.len() as i32; let n_strings = str.len() as i32;
unsafe { unsafe {
glib_result_from_gboolean!(gst_gl_sys::gst_glsl_stage_set_strings(self.to_glib_none().0, version.to_glib(), profile.to_glib(), n_strings, str.to_glib_none().0), "Failed to attach stage to set strings") glib_result_from_gboolean!(
gst_gl_sys::gst_glsl_stage_set_strings(
self.to_glib_none().0,
version.to_glib(),
profile.to_glib(),
n_strings,
str.to_glib_none().0
),
"Failed to attach stage to set strings"
)
} }
} }
} }

14
gstreamer-gl/src/auto/mod.rs
View file

@ -5,20 +5,20 @@
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
mod gl_base_filter; mod gl_base_filter;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub use self::gl_base_filter::{GLBaseFilter, GLBaseFilterClass, NONE_GL_BASE_FILTER};
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub use self::gl_base_filter::GLBaseFilterExt; pub use self::gl_base_filter::GLBaseFilterExt;
#[cfg(any(feature = "v1_16", feature = "dox"))]
pub use self::gl_base_filter::{GLBaseFilter, GLBaseFilterClass, NONE_GL_BASE_FILTER};
mod gl_color_convert; mod gl_color_convert;
pub use self::gl_color_convert::{GLColorConvert, GLColorConvertClass}; pub use self::gl_color_convert::{GLColorConvert, GLColorConvertClass};
mod gl_context; mod gl_context;
pub use self::gl_context::{GLContext, GLContextClass, NONE_GL_CONTEXT};
pub use self::gl_context::GLContextExt; pub use self::gl_context::GLContextExt;
pub use self::gl_context::{GLContext, GLContextClass, NONE_GL_CONTEXT};
mod gl_display; mod gl_display;
pub use self::gl_display::{GLDisplay, GLDisplayClass, NONE_GL_DISPLAY};
pub use self::gl_display::GLDisplayExt; pub use self::gl_display::GLDisplayExt;
pub use self::gl_display::{GLDisplay, GLDisplayClass, NONE_GL_DISPLAY};
#[cfg(any(feature = "egl", feature = "dox"))] #[cfg(any(feature = "egl", feature = "dox"))]
mod gl_display_egl; mod gl_display_egl;
@ -36,8 +36,8 @@ mod gl_display_x11;
pub use self::gl_display_x11::{GLDisplayX11, GLDisplayX11Class}; pub use self::gl_display_x11::{GLDisplayX11, GLDisplayX11Class};
mod gl_framebuffer; mod gl_framebuffer;
pub use self::gl_framebuffer::{GLFramebuffer, GLFramebufferClass, NONE_GL_FRAMEBUFFER};
pub use self::gl_framebuffer::GLFramebufferExt; pub use self::gl_framebuffer::GLFramebufferExt;
pub use self::gl_framebuffer::{GLFramebuffer, GLFramebufferClass, NONE_GL_FRAMEBUFFER};
mod gl_overlay_compositor; mod gl_overlay_compositor;
pub use self::gl_overlay_compositor::{GLOverlayCompositor, GLOverlayCompositorClass}; pub use self::gl_overlay_compositor::{GLOverlayCompositor, GLOverlayCompositorClass};
@ -55,8 +55,8 @@ mod gl_view_convert;
pub use self::gl_view_convert::{GLViewConvert, GLViewConvertClass}; pub use self::gl_view_convert::{GLViewConvert, GLViewConvertClass};
mod gl_window; mod gl_window;
pub use self::gl_window::{GLWindow, GLWindowClass, NONE_GL_WINDOW};
pub use self::gl_window::GLWindowExt; pub use self::gl_window::GLWindowExt;
pub use self::gl_window::{GLWindow, GLWindowClass, NONE_GL_WINDOW};
mod enums; mod enums;
pub use self::enums::GLContextError; pub use self::enums::GLContextError;
@ -70,10 +70,10 @@ pub use self::enums::GLUploadReturn;
pub use self::enums::GLWindowError; pub use self::enums::GLWindowError;
mod flags; mod flags;
pub use self::flags::GLAPI;
pub use self::flags::GLDisplayType; pub use self::flags::GLDisplayType;
pub use self::flags::GLPlatform; pub use self::flags::GLPlatform;
pub use self::flags::GLSLProfile; pub use self::flags::GLSLProfile;
pub use self::flags::GLAPI;
#[doc(hidden)] #[doc(hidden)]
pub mod traits { pub mod traits {

1
gstreamer-gl/src/lib.rs
View file

@ -40,7 +40,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::unreadable_literal)] #[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

3
gstreamer-net/src/auto/mod.rs
View file

@ -15,5 +15,4 @@ mod ptp_clock;
pub use self::ptp_clock::{PtpClock, PtpClockClass}; pub use self::ptp_clock::{PtpClock, PtpClockClass};
#[doc(hidden)] #[doc(hidden)]
pub mod traits { pub mod traits {}
}

247
gstreamer-net/src/auto/net_client_clock.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -28,21 +28,33 @@ impl NetClientClock {
pub fn get_property_address(&self) -> Option<GString> { pub fn get_property_address(&self) -> Option<GString> {
unsafe { unsafe {
let mut value = Value::from_type(<GString as StaticType>::static_type()); let mut value = Value::from_type(<GString as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"address\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"address\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
pub fn set_property_address(&self, address: Option<&str>) { pub fn set_property_address(&self, address: Option<&str>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"address\0".as_ptr() as *const _, Value::from(address).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"address\0".as_ptr() as *const _,
Value::from(address).to_glib_none().0,
);
} }
} }
pub fn get_property_base_time(&self) -> u64 { pub fn get_property_base_time(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"base-time\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"base-time\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -50,21 +62,33 @@ impl NetClientClock {
pub fn get_property_bus(&self) -> Option<gst::Bus> { pub fn get_property_bus(&self) -> Option<gst::Bus> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Bus as StaticType>::static_type()); let mut value = Value::from_type(<gst::Bus as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"bus\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"bus\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
pub fn set_property_bus(&self, bus: Option<&gst::Bus>) { pub fn set_property_bus(&self, bus: Option<&gst::Bus>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"bus\0".as_ptr() as *const _, Value::from(bus).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"bus\0".as_ptr() as *const _,
Value::from(bus).to_glib_none().0,
);
} }
} }
pub fn get_property_internal_clock(&self) -> Option<gst::Clock> { pub fn get_property_internal_clock(&self) -> Option<gst::Clock> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Clock as StaticType>::static_type()); let mut value = Value::from_type(<gst::Clock as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"internal-clock\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"internal-clock\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -72,140 +96,271 @@ impl NetClientClock {
pub fn get_property_minimum_update_interval(&self) -> u64 { pub fn get_property_minimum_update_interval(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"minimum-update-interval\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"minimum-update-interval\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_minimum_update_interval(&self, minimum_update_interval: u64) { pub fn set_property_minimum_update_interval(&self, minimum_update_interval: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"minimum-update-interval\0".as_ptr() as *const _, Value::from(&minimum_update_interval).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"minimum-update-interval\0".as_ptr() as *const _,
Value::from(&minimum_update_interval).to_glib_none().0,
);
} }
} }
pub fn get_property_port(&self) -> i32 { pub fn get_property_port(&self) -> i32 {
unsafe { unsafe {
let mut value = Value::from_type(<i32 as StaticType>::static_type()); let mut value = Value::from_type(<i32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"port\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"port\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_port(&self, port: i32) { pub fn set_property_port(&self, port: i32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"port\0".as_ptr() as *const _, Value::from(&port).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"port\0".as_ptr() as *const _,
Value::from(&port).to_glib_none().0,
);
} }
} }
pub fn get_property_qos_dscp(&self) -> i32 { pub fn get_property_qos_dscp(&self) -> i32 {
unsafe { unsafe {
let mut value = Value::from_type(<i32 as StaticType>::static_type()); let mut value = Value::from_type(<i32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"qos-dscp\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"qos-dscp\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_qos_dscp(&self, qos_dscp: i32) { pub fn set_property_qos_dscp(&self, qos_dscp: i32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"qos-dscp\0".as_ptr() as *const _, Value::from(&qos_dscp).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"qos-dscp\0".as_ptr() as *const _,
Value::from(&qos_dscp).to_glib_none().0,
);
} }
} }
pub fn get_property_round_trip_limit(&self) -> u64 { pub fn get_property_round_trip_limit(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"round-trip-limit\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"round-trip-limit\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_round_trip_limit(&self, round_trip_limit: u64) { pub fn set_property_round_trip_limit(&self, round_trip_limit: u64) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"round-trip-limit\0".as_ptr() as *const _, Value::from(&round_trip_limit).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"round-trip-limit\0".as_ptr() as *const _,
Value::from(&round_trip_limit).to_glib_none().0,
);
} }
} }
pub fn connect_property_address_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_address_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_address_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_address_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::address\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_address_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::address\0".as_ptr() as *const _,
Some(transmute(notify_address_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_bus_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_bus_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_bus_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_bus_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::bus\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_bus_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::bus\0".as_ptr() as *const _,
Some(transmute(notify_bus_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_internal_clock_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_internal_clock_notify<
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_internal_clock_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_internal_clock_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::internal-clock\0".as_ptr() as *const _,
Some(transmute(notify_internal_clock_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_minimum_update_interval_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_minimum_update_interval_notify<
unsafe extern "C" fn notify_minimum_update_interval_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_minimum_update_interval_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::minimum-update-interval\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_minimum_update_interval_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::minimum-update-interval\0".as_ptr() as *const _,
Some(transmute(
notify_minimum_update_interval_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_port_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_port_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_port_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_port_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::port\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_port_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::port\0".as_ptr() as *const _,
Some(transmute(notify_port_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_qos_dscp_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_qos_dscp_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_dscp_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_qos_dscp_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::qos-dscp\0".as_ptr() as *const _,
Some(transmute(notify_qos_dscp_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_round_trip_limit_notify<F: Fn(&NetClientClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_round_trip_limit_notify<
unsafe extern "C" fn notify_round_trip_limit_trampoline<F: Fn(&NetClientClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetClientClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_round_trip_limit_trampoline<
F: Fn(&NetClientClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetClientClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::round-trip-limit\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_round_trip_limit_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::round-trip-limit\0".as_ptr() as *const _,
Some(transmute(notify_round_trip_limit_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

92
gstreamer-net/src/auto/net_time_provider.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString; use glib::GString;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -28,21 +28,33 @@ impl NetTimeProvider {
pub fn get_property_active(&self) -> bool { pub fn get_property_active(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"active\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"active\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_active(&self, active: bool) { pub fn set_property_active(&self, active: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"active\0".as_ptr() as *const _, Value::from(&active).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"active\0".as_ptr() as *const _,
Value::from(&active).to_glib_none().0,
);
} }
} }
pub fn get_property_address(&self) -> Option<GString> { pub fn get_property_address(&self) -> Option<GString> {
unsafe { unsafe {
let mut value = Value::from_type(<GString as StaticType>::static_type()); let mut value = Value::from_type(<GString as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"address\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"address\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -50,7 +62,11 @@ impl NetTimeProvider {
pub fn get_property_clock(&self) -> Option<gst::Clock> { pub fn get_property_clock(&self) -> Option<gst::Clock> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Clock as StaticType>::static_type()); let mut value = Value::from_type(<gst::Clock as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"clock\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"clock\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -58,7 +74,11 @@ impl NetTimeProvider {
pub fn get_property_port(&self) -> i32 { pub fn get_property_port(&self) -> i32 {
unsafe { unsafe {
let mut value = Value::from_type(<i32 as StaticType>::static_type()); let mut value = Value::from_type(<i32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"port\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"port\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -66,38 +86,72 @@ impl NetTimeProvider {
pub fn get_property_qos_dscp(&self) -> i32 { pub fn get_property_qos_dscp(&self) -> i32 {
unsafe { unsafe {
let mut value = Value::from_type(<i32 as StaticType>::static_type()); let mut value = Value::from_type(<i32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"qos-dscp\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"qos-dscp\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn set_property_qos_dscp(&self, qos_dscp: i32) { pub fn set_property_qos_dscp(&self, qos_dscp: i32) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"qos-dscp\0".as_ptr() as *const _, Value::from(&qos_dscp).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"qos-dscp\0".as_ptr() as *const _,
Value::from(&qos_dscp).to_glib_none().0,
);
} }
} }
pub fn connect_property_active_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_active_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(
unsafe extern "C" fn notify_active_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_active_trampoline<
F: Fn(&NetTimeProvider) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetTimeProvider,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::active\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_active_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::active\0".as_ptr() as *const _,
Some(transmute(notify_active_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_qos_dscp_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_qos_dscp_notify<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(
unsafe extern "C" fn notify_qos_dscp_trampoline<F: Fn(&NetTimeProvider) + Send + Sync + 'static>(this: *mut gst_net_sys::GstNetTimeProvider, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_qos_dscp_trampoline<
F: Fn(&NetTimeProvider) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstNetTimeProvider,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::qos-dscp\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_qos_dscp_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::qos-dscp\0".as_ptr() as *const _,
Some(transmute(notify_qos_dscp_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

2
gstreamer-net/src/auto/ntp_clock.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use NetClientClock;
use glib::translate::*; use glib::translate::*;
use gst; use gst;
use gst_net_sys; use gst_net_sys;
use NetClientClock;
glib_wrapper! { glib_wrapper! {
pub struct NtpClock(Object<gst_net_sys::GstNtpClock, gst_net_sys::GstNtpClockClass, NtpClockClass>) @extends NetClientClock, gst::Clock, gst::Object; pub struct NtpClock(Object<gst_net_sys::GstNtpClock, gst_net_sys::GstNtpClockClass, NtpClockClass>) @extends NetClientClock, gst::Clock, gst::Object;

99
gstreamer-net/src/auto/ptp_clock.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -27,7 +27,11 @@ impl PtpClock {
pub fn get_property_domain(&self) -> u32 { pub fn get_property_domain(&self) -> u32 {
unsafe { unsafe {
let mut value = Value::from_type(<u32 as StaticType>::static_type()); let mut value = Value::from_type(<u32 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"domain\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"domain\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -35,7 +39,11 @@ impl PtpClock {
pub fn get_property_grandmaster_clock_id(&self) -> u64 { pub fn get_property_grandmaster_clock_id(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"grandmaster-clock-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"grandmaster-clock-id\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -43,7 +51,11 @@ impl PtpClock {
pub fn get_property_internal_clock(&self) -> Option<gst::Clock> { pub fn get_property_internal_clock(&self) -> Option<gst::Clock> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Clock as StaticType>::static_type()); let mut value = Value::from_type(<gst::Clock as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"internal-clock\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"internal-clock\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
@ -51,44 +63,91 @@ impl PtpClock {
pub fn get_property_master_clock_id(&self) -> u64 { pub fn get_property_master_clock_id(&self) -> u64 {
unsafe { unsafe {
let mut value = Value::from_type(<u64 as StaticType>::static_type()); let mut value = Value::from_type(<u64 as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"master-clock-id\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"master-clock-id\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
pub fn connect_property_grandmaster_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_grandmaster_clock_id_notify<
unsafe extern "C" fn notify_grandmaster_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&PtpClock) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_grandmaster_clock_id_trampoline<
F: Fn(&PtpClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstPtpClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::grandmaster-clock-id\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_grandmaster_clock_id_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::grandmaster-clock-id\0".as_ptr() as *const _,
Some(transmute(
notify_grandmaster_clock_id_trampoline::<F> as usize,
)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_internal_clock_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_internal_clock_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_internal_clock_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_internal_clock_trampoline<
F: Fn(&PtpClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstPtpClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::internal-clock\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_internal_clock_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::internal-clock\0".as_ptr() as *const _,
Some(transmute(notify_internal_clock_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_master_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_master_clock_id_notify<F: Fn(&PtpClock) + Send + Sync + 'static>(
unsafe extern "C" fn notify_master_clock_id_trampoline<F: Fn(&PtpClock) + Send + Sync + 'static>(this: *mut gst_net_sys::GstPtpClock, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_master_clock_id_trampoline<
F: Fn(&PtpClock) + Send + Sync + 'static,
>(
this: *mut gst_net_sys::GstPtpClock,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::master-clock-id\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_master_clock_id_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::master-clock-id\0".as_ptr() as *const _,
Some(transmute(notify_master_clock_id_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

1
gstreamer-net/src/lib.rs
View file

@ -29,7 +29,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::unreadable_literal)] #[allow(clippy::unreadable_literal)]
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;
mod net_client_clock; mod net_client_clock;

158
gstreamer-pbutils/src/auto/discoverer.rs
View file

@ -2,17 +2,15 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererInfo;
use Error;
use glib; use glib;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::StaticType; use glib::StaticType;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
use gobject_sys; use gobject_sys;
@ -22,6 +20,8 @@ use gst_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem::transmute; use std::mem::transmute;
use std::ptr; use std::ptr;
use DiscovererInfo;
use Error;
glib_wrapper! { glib_wrapper! {
pub struct Discoverer(Object<gst_pbutils_sys::GstDiscoverer, gst_pbutils_sys::GstDiscovererClass, DiscovererClass>); pub struct Discoverer(Object<gst_pbutils_sys::GstDiscoverer, gst_pbutils_sys::GstDiscovererClass, DiscovererClass>);
@ -37,21 +37,39 @@ impl Discoverer {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_pbutils_sys::gst_discoverer_new(timeout.to_glib(), &mut error); let ret = gst_pbutils_sys::gst_discoverer_new(timeout.to_glib(), &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
pub fn discover_uri(&self, uri: &str) -> Result<DiscovererInfo, Error> { pub fn discover_uri(&self, uri: &str) -> Result<DiscovererInfo, Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_pbutils_sys::gst_discoverer_discover_uri(self.to_glib_none().0, uri.to_glib_none().0, &mut error); let ret = gst_pbutils_sys::gst_discoverer_discover_uri(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } self.to_glib_none().0,
uri.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
pub fn discover_uri_async(&self, uri: &str) -> Result<(), glib::error::BoolError> { pub fn discover_uri_async(&self, uri: &str) -> Result<(), glib::error::BoolError> {
unsafe { unsafe {
glib_result_from_gboolean!(gst_pbutils_sys::gst_discoverer_discover_uri_async(self.to_glib_none().0, uri.to_glib_none().0), "Failed to add URI to list of discovers") glib_result_from_gboolean!(
gst_pbutils_sys::gst_discoverer_discover_uri_async(
self.to_glib_none().0,
uri.to_glib_none().0
),
"Failed to add URI to list of discovers"
)
} }
} }
@ -71,7 +89,11 @@ impl Discoverer {
pub fn get_property_use_cache(&self) -> bool { pub fn get_property_use_cache(&self) -> bool {
unsafe { unsafe {
let mut value = Value::from_type(<bool as StaticType>::static_type()); let mut value = Value::from_type(<bool as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"use-cache\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"use-cache\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get().unwrap() value.get().unwrap()
} }
} }
@ -79,68 +101,138 @@ impl Discoverer {
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn set_property_use_cache(&self, use_cache: bool) { pub fn set_property_use_cache(&self, use_cache: bool) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"use-cache\0".as_ptr() as *const _, Value::from(&use_cache).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"use-cache\0".as_ptr() as *const _,
Value::from(&use_cache).to_glib_none().0,
);
} }
} }
pub fn connect_discovered<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_discovered<
unsafe extern "C" fn discovered_trampoline<F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, info: *mut gst_pbutils_sys::GstDiscovererInfo, error: *mut glib_sys::GError, f: glib_sys::gpointer) { F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn discovered_trampoline<
F: Fn(&Discoverer, &DiscovererInfo, Option<&Error>) + Send + Sync + 'static,
>(
this: *mut gst_pbutils_sys::GstDiscoverer,
info: *mut gst_pbutils_sys::GstDiscovererInfo,
error: *mut glib_sys::GError,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(info), Option::<Error>::from_glib_borrow(error).as_ref()) f(
&from_glib_borrow(this),
&from_glib_borrow(info),
Option::<Error>::from_glib_borrow(error).as_ref(),
)
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"discovered\0".as_ptr() as *const _, connect_raw(
Some(transmute(discovered_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"discovered\0".as_ptr() as *const _,
Some(transmute(discovered_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_finished<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_finished<F: Fn(&Discoverer) + Send + Sync + 'static>(
unsafe extern "C" fn finished_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn finished_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(
this: *mut gst_pbutils_sys::GstDiscoverer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"finished\0".as_ptr() as *const _, connect_raw(
Some(transmute(finished_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"finished\0".as_ptr() as *const _,
Some(transmute(finished_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_source_setup<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_source_setup<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(
unsafe extern "C" fn source_setup_trampoline<F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, source: *mut gst_sys::GstElement, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn source_setup_trampoline<
F: Fn(&Discoverer, &gst::Element) + Send + Sync + 'static,
>(
this: *mut gst_pbutils_sys::GstDiscoverer,
source: *mut gst_sys::GstElement,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this), &from_glib_borrow(source)) f(&from_glib_borrow(this), &from_glib_borrow(source))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"source-setup\0".as_ptr() as *const _, connect_raw(
Some(transmute(source_setup_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"source-setup\0".as_ptr() as *const _,
Some(transmute(source_setup_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_starting<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_starting<F: Fn(&Discoverer) + Send + Sync + 'static>(
unsafe extern "C" fn starting_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn starting_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(
this: *mut gst_pbutils_sys::GstDiscoverer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"starting\0".as_ptr() as *const _, connect_raw(
Some(transmute(starting_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"starting\0".as_ptr() as *const _,
Some(transmute(starting_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
#[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg(any(feature = "v1_16", feature = "dox"))]
pub fn connect_property_use_cache_notify<F: Fn(&Discoverer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_use_cache_notify<F: Fn(&Discoverer) + Send + Sync + 'static>(
unsafe extern "C" fn notify_use_cache_trampoline<F: Fn(&Discoverer) + Send + Sync + 'static>(this: *mut gst_pbutils_sys::GstDiscoverer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { &self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_use_cache_trampoline<
F: Fn(&Discoverer) + Send + Sync + 'static,
>(
this: *mut gst_pbutils_sys::GstDiscoverer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::use-cache\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_use_cache_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::use-cache\0".as_ptr() as *const _,
Some(transmute(notify_use_cache_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

28
gstreamer-pbutils/src/auto/discoverer_audio_info.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererStreamInfo;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_pbutils_sys; use gst_pbutils_sys;
use DiscovererStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct DiscovererAudioInfo(Object<gst_pbutils_sys::GstDiscovererAudioInfo, DiscovererAudioInfoClass>) @extends DiscovererStreamInfo; pub struct DiscovererAudioInfo(Object<gst_pbutils_sys::GstDiscovererAudioInfo, DiscovererAudioInfoClass>) @extends DiscovererStreamInfo;
@ -17,9 +17,7 @@ glib_wrapper! {
impl DiscovererAudioInfo { impl DiscovererAudioInfo {
pub fn get_bitrate(&self) -> u32 { pub fn get_bitrate(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_audio_info_get_bitrate(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_audio_info_get_bitrate(self.to_glib_none().0)
}
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
@ -30,33 +28,27 @@ impl DiscovererAudioInfo {
} }
pub fn get_channels(&self) -> u32 { pub fn get_channels(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_audio_info_get_channels(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_audio_info_get_channels(self.to_glib_none().0)
}
} }
pub fn get_depth(&self) -> u32 { pub fn get_depth(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_audio_info_get_depth(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_audio_info_get_depth(self.to_glib_none().0)
}
} }
pub fn get_language(&self) -> Option<GString> { pub fn get_language(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_audio_info_get_language(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_audio_info_get_language(
self.to_glib_none().0,
))
} }
} }
pub fn get_max_bitrate(&self) -> u32 { pub fn get_max_bitrate(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_audio_info_get_max_bitrate(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_audio_info_get_max_bitrate(self.to_glib_none().0)
}
} }
pub fn get_sample_rate(&self) -> u32 { pub fn get_sample_rate(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_audio_info_get_sample_rate(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_audio_info_get_sample_rate(self.to_glib_none().0)
}
} }
} }

6
gstreamer-pbutils/src/auto/discoverer_container_info.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererStreamInfo;
use glib::translate::*; use glib::translate::*;
use gst_pbutils_sys; use gst_pbutils_sys;
use DiscovererStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct DiscovererContainerInfo(Object<gst_pbutils_sys::GstDiscovererContainerInfo, DiscovererContainerInfoClass>) @extends DiscovererStreamInfo; pub struct DiscovererContainerInfo(Object<gst_pbutils_sys::GstDiscovererContainerInfo, DiscovererContainerInfoClass>) @extends DiscovererStreamInfo;
@ -17,7 +17,9 @@ glib_wrapper! {
impl DiscovererContainerInfo { impl DiscovererContainerInfo {
pub fn get_streams(&self) -> Vec<DiscovererStreamInfo> { pub fn get_streams(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_container_info_get_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_container_info_get_streams(self.to_glib_none().0),
)
} }
} }
} }

90
gstreamer-pbutils/src/auto/discoverer_info.rs
View file

@ -2,14 +2,14 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib;
use glib::translate::*;
use glib::GString;
use gst;
use gst_pbutils_sys;
use DiscovererResult; use DiscovererResult;
use DiscovererSerializeFlags; use DiscovererSerializeFlags;
use DiscovererStreamInfo; use DiscovererStreamInfo;
use glib;
use glib::GString;
use glib::translate::*;
use gst;
use gst_pbutils_sys;
glib_wrapper! { glib_wrapper! {
pub struct DiscovererInfo(Object<gst_pbutils_sys::GstDiscovererInfo, DiscovererInfoClass>); pub struct DiscovererInfo(Object<gst_pbutils_sys::GstDiscovererInfo, DiscovererInfoClass>);
@ -22,117 +22,159 @@ glib_wrapper! {
impl DiscovererInfo { impl DiscovererInfo {
pub fn copy(&self) -> DiscovererInfo { pub fn copy(&self) -> DiscovererInfo {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_info_copy(self.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_info_copy(
self.to_glib_none().0,
))
} }
} }
pub fn get_audio_streams(&self) -> Vec<DiscovererStreamInfo> { pub fn get_audio_streams(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_audio_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_info_get_audio_streams(self.to_glib_none().0),
)
} }
} }
pub fn get_container_streams(&self) -> Vec<DiscovererStreamInfo> { pub fn get_container_streams(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_container_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_info_get_container_streams(self.to_glib_none().0),
)
} }
} }
pub fn get_duration(&self) -> gst::ClockTime { pub fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_info_get_duration(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_info_get_duration(
self.to_glib_none().0,
))
} }
} }
#[cfg(any(feature = "v1_14", feature = "dox"))] #[cfg(any(feature = "v1_14", feature = "dox"))]
pub fn get_live(&self) -> bool { pub fn get_live(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_info_get_live(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_info_get_live(
self.to_glib_none().0,
))
} }
} }
pub fn get_misc(&self) -> Option<gst::Structure> { pub fn get_misc(&self) -> Option<gst::Structure> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_misc(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_misc(
self.to_glib_none().0,
))
} }
} }
pub fn get_missing_elements_installer_details(&self) -> Vec<GString> { pub fn get_missing_elements_installer_details(&self) -> Vec<GString> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_missing_elements_installer_details(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_pbutils_sys::gst_discoverer_info_get_missing_elements_installer_details(
self.to_glib_none().0,
),
)
} }
} }
pub fn get_result(&self) -> DiscovererResult { pub fn get_result(&self) -> DiscovererResult {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_info_get_result(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_info_get_result(
self.to_glib_none().0,
))
} }
} }
pub fn get_seekable(&self) -> bool { pub fn get_seekable(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_info_get_seekable(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_info_get_seekable(
self.to_glib_none().0,
))
} }
} }
pub fn get_stream_info(&self) -> Option<DiscovererStreamInfo> { pub fn get_stream_info(&self) -> Option<DiscovererStreamInfo> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_stream_info(self.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_stream_info(
self.to_glib_none().0,
))
} }
} }
pub fn get_stream_list(&self) -> Vec<DiscovererStreamInfo> { pub fn get_stream_list(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_stream_list(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_info_get_stream_list(self.to_glib_none().0),
)
} }
} }
pub fn get_streams(&self, streamtype: glib::types::Type) -> Vec<DiscovererStreamInfo> { pub fn get_streams(&self, streamtype: glib::types::Type) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_streams(self.to_glib_none().0, streamtype.to_glib())) FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_streams(
self.to_glib_none().0,
streamtype.to_glib(),
))
} }
} }
pub fn get_subtitle_streams(&self) -> Vec<DiscovererStreamInfo> { pub fn get_subtitle_streams(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_subtitle_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_info_get_subtitle_streams(self.to_glib_none().0),
)
} }
} }
pub fn get_tags(&self) -> Option<gst::TagList> { pub fn get_tags(&self) -> Option<gst::TagList> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_tags(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_tags(
self.to_glib_none().0,
))
} }
} }
pub fn get_toc(&self) -> Option<gst::Toc> { pub fn get_toc(&self) -> Option<gst::Toc> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_toc(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_toc(
self.to_glib_none().0,
))
} }
} }
pub fn get_uri(&self) -> Option<GString> { pub fn get_uri(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_uri(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_info_get_uri(
self.to_glib_none().0,
))
} }
} }
pub fn get_video_streams(&self) -> Vec<DiscovererStreamInfo> { pub fn get_video_streams(&self) -> Vec<DiscovererStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_discoverer_info_get_video_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_discoverer_info_get_video_streams(self.to_glib_none().0),
)
} }
} }
pub fn to_variant(&self, flags: DiscovererSerializeFlags) -> Option<glib::Variant> { pub fn to_variant(&self, flags: DiscovererSerializeFlags) -> Option<glib::Variant> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_info_to_variant(self.to_glib_none().0, flags.to_glib())) from_glib_full(gst_pbutils_sys::gst_discoverer_info_to_variant(
self.to_glib_none().0,
flags.to_glib(),
))
} }
} }
pub fn from_variant(variant: &glib::Variant) -> Option<DiscovererInfo> { pub fn from_variant(variant: &glib::Variant) -> Option<DiscovererInfo> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_info_from_variant(variant.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_info_from_variant(
variant.to_glib_none().0,
))
} }
} }
} }

36
gstreamer-pbutils/src/auto/discoverer_stream_info.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::GString;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst; use gst;
use gst_pbutils_sys; use gst_pbutils_sys;
@ -42,49 +42,67 @@ pub trait DiscovererStreamInfoExt: 'static {
impl<O: IsA<DiscovererStreamInfo>> DiscovererStreamInfoExt for O { impl<O: IsA<DiscovererStreamInfo>> DiscovererStreamInfoExt for O {
fn get_caps(&self) -> Option<gst::Caps> { fn get_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_caps(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_caps(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_misc(&self) -> Option<gst::Structure> { fn get_misc(&self) -> Option<gst::Structure> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_misc(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_misc(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_next(&self) -> Option<DiscovererStreamInfo> { fn get_next(&self) -> Option<DiscovererStreamInfo> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_next(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_next(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_previous(&self) -> Option<DiscovererStreamInfo> { fn get_previous(&self) -> Option<DiscovererStreamInfo> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_previous(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_discoverer_stream_info_get_previous(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_stream_id(&self) -> Option<GString> { fn get_stream_id(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_stream_id(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_stream_id(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_stream_type_nick(&self) -> GString { fn get_stream_type_nick(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_stream_type_nick(self.as_ref().to_glib_none().0)) from_glib_none(
gst_pbutils_sys::gst_discoverer_stream_info_get_stream_type_nick(
self.as_ref().to_glib_none().0,
),
)
} }
} }
fn get_tags(&self) -> Option<gst::TagList> { fn get_tags(&self) -> Option<gst::TagList> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_tags(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_tags(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_toc(&self) -> Option<gst::Toc> { fn get_toc(&self) -> Option<gst::Toc> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_toc(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_stream_info_get_toc(
self.as_ref().to_glib_none().0,
))
} }
} }
} }

8
gstreamer-pbutils/src/auto/discoverer_subtitle_info.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererStreamInfo;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_pbutils_sys; use gst_pbutils_sys;
use DiscovererStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct DiscovererSubtitleInfo(Object<gst_pbutils_sys::GstDiscovererSubtitleInfo, DiscovererSubtitleInfoClass>) @extends DiscovererStreamInfo; pub struct DiscovererSubtitleInfo(Object<gst_pbutils_sys::GstDiscovererSubtitleInfo, DiscovererSubtitleInfoClass>) @extends DiscovererStreamInfo;
@ -18,7 +18,9 @@ glib_wrapper! {
impl DiscovererSubtitleInfo { impl DiscovererSubtitleInfo {
pub fn get_language(&self) -> Option<GString> { pub fn get_language(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_discoverer_subtitle_info_get_language(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_discoverer_subtitle_info_get_language(
self.to_glib_none().0,
))
} }
} }
} }

30
gstreamer-pbutils/src/auto/discoverer_video_info.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererStreamInfo;
use glib::translate::*; use glib::translate::*;
use gst_pbutils_sys; use gst_pbutils_sys;
use DiscovererStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct DiscovererVideoInfo(Object<gst_pbutils_sys::GstDiscovererVideoInfo, DiscovererVideoInfoClass>) @extends DiscovererStreamInfo; pub struct DiscovererVideoInfo(Object<gst_pbutils_sys::GstDiscovererVideoInfo, DiscovererVideoInfoClass>) @extends DiscovererStreamInfo;
@ -16,44 +16,38 @@ glib_wrapper! {
impl DiscovererVideoInfo { impl DiscovererVideoInfo {
pub fn get_bitrate(&self) -> u32 { pub fn get_bitrate(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_video_info_get_bitrate(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_video_info_get_bitrate(self.to_glib_none().0)
}
} }
pub fn get_depth(&self) -> u32 { pub fn get_depth(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_video_info_get_depth(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_video_info_get_depth(self.to_glib_none().0)
}
} }
pub fn get_height(&self) -> u32 { pub fn get_height(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_video_info_get_height(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_video_info_get_height(self.to_glib_none().0)
}
} }
pub fn get_max_bitrate(&self) -> u32 { pub fn get_max_bitrate(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_video_info_get_max_bitrate(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_video_info_get_max_bitrate(self.to_glib_none().0)
}
} }
pub fn get_width(&self) -> u32 { pub fn get_width(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_discoverer_video_info_get_width(self.to_glib_none().0) }
gst_pbutils_sys::gst_discoverer_video_info_get_width(self.to_glib_none().0)
}
} }
pub fn is_image(&self) -> bool { pub fn is_image(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_video_info_is_image(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_video_info_is_image(
self.to_glib_none().0,
))
} }
} }
pub fn is_interlaced(&self) -> bool { pub fn is_interlaced(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_discoverer_video_info_is_interlaced(self.to_glib_none().0)) from_glib(gst_pbutils_sys::gst_discoverer_video_info_is_interlaced(
self.to_glib_none().0,
))
} }
} }
} }

2
gstreamer-pbutils/src/auto/encoding_audio_profile.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use EncodingProfile;
use glib::translate::*; use glib::translate::*;
use gst_pbutils_sys; use gst_pbutils_sys;
use EncodingProfile;
glib_wrapper! { glib_wrapper! {
pub struct EncodingAudioProfile(Object<gst_pbutils_sys::GstEncodingAudioProfile, gst_pbutils_sys::GstEncodingAudioProfileClass, EncodingAudioProfileClass>) @extends EncodingProfile; pub struct EncodingAudioProfile(Object<gst_pbutils_sys::GstEncodingAudioProfile, gst_pbutils_sys::GstEncodingAudioProfileClass, EncodingAudioProfileClass>) @extends EncodingProfile;

13
gstreamer-pbutils/src/auto/encoding_container_profile.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use EncodingProfile;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use gst_pbutils_sys; use gst_pbutils_sys;
use EncodingProfile;
glib_wrapper! { glib_wrapper! {
pub struct EncodingContainerProfile(Object<gst_pbutils_sys::GstEncodingContainerProfile, gst_pbutils_sys::GstEncodingContainerProfileClass, EncodingContainerProfileClass>) @extends EncodingProfile; pub struct EncodingContainerProfile(Object<gst_pbutils_sys::GstEncodingContainerProfile, gst_pbutils_sys::GstEncodingContainerProfileClass, EncodingContainerProfileClass>) @extends EncodingProfile;
@ -18,13 +18,20 @@ glib_wrapper! {
impl EncodingContainerProfile { impl EncodingContainerProfile {
pub fn contains_profile<P: IsA<EncodingProfile>>(&self, profile: &P) -> bool { pub fn contains_profile<P: IsA<EncodingProfile>>(&self, profile: &P) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_encoding_container_profile_contains_profile(self.to_glib_none().0, profile.as_ref().to_glib_none().0)) from_glib(
gst_pbutils_sys::gst_encoding_container_profile_contains_profile(
self.to_glib_none().0,
profile.as_ref().to_glib_none().0,
),
)
} }
} }
pub fn get_profiles(&self) -> Vec<EncodingProfile> { pub fn get_profiles(&self) -> Vec<EncodingProfile> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_encoding_container_profile_get_profiles(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_pbutils_sys::gst_encoding_container_profile_get_profiles(self.to_glib_none().0),
)
} }
} }
} }

75
gstreamer-pbutils/src/auto/encoding_profile.rs
View file

@ -2,12 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use DiscovererInfo;
use glib::GString;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst; use gst;
use gst_pbutils_sys; use gst_pbutils_sys;
use DiscovererInfo;
glib_wrapper! { glib_wrapper! {
pub struct EncodingProfile(Object<gst_pbutils_sys::GstEncodingProfile, gst_pbutils_sys::GstEncodingProfileClass, EncodingProfileClass>); pub struct EncodingProfile(Object<gst_pbutils_sys::GstEncodingProfile, gst_pbutils_sys::GstEncodingProfileClass, EncodingProfileClass>);
@ -18,17 +18,27 @@ glib_wrapper! {
} }
impl EncodingProfile { impl EncodingProfile {
pub fn find(targetname: &str, profilename: Option<&str>, category: Option<&str>) -> Option<EncodingProfile> { pub fn find(
targetname: &str,
profilename: Option<&str>,
category: Option<&str>,
) -> Option<EncodingProfile> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_find(targetname.to_glib_none().0, profilename.to_glib_none().0, category.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_find(
targetname.to_glib_none().0,
profilename.to_glib_none().0,
category.to_glib_none().0,
))
} }
} }
pub fn from_discoverer(info: &DiscovererInfo) -> Option<EncodingProfile> { pub fn from_discoverer(info: &DiscovererInfo) -> Option<EncodingProfile> {
skip_assert_initialized!(); skip_assert_initialized!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_from_discoverer(info.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_from_discoverer(
info.to_glib_none().0,
))
} }
} }
} }
@ -73,43 +83,59 @@ impl<O: IsA<EncodingProfile>> EncodingProfileExt for O {
#[cfg(any(feature = "v1_12", feature = "dox"))] #[cfg(any(feature = "v1_12", feature = "dox"))]
fn copy(&self) -> EncodingProfile { fn copy(&self) -> EncodingProfile {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_copy(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_copy(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_allow_dynamic_output(&self) -> bool { fn get_allow_dynamic_output(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_encoding_profile_get_allow_dynamic_output(self.as_ref().to_glib_none().0)) from_glib(
gst_pbutils_sys::gst_encoding_profile_get_allow_dynamic_output(
self.as_ref().to_glib_none().0,
),
)
} }
} }
fn get_description(&self) -> Option<GString> { fn get_description(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_description(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_description(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_file_extension(&self) -> Option<GString> { fn get_file_extension(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_file_extension(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_file_extension(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_format(&self) -> gst::Caps { fn get_format(&self) -> gst::Caps {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_format(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_format(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_input_caps(&self) -> gst::Caps { fn get_input_caps(&self) -> gst::Caps {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_input_caps(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_input_caps(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_name(&self) -> Option<GString> { fn get_name(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_name(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_name(
self.as_ref().to_glib_none().0,
))
} }
} }
@ -121,37 +147,50 @@ impl<O: IsA<EncodingProfile>> EncodingProfileExt for O {
fn get_preset(&self) -> Option<GString> { fn get_preset(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_preset(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_preset(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_preset_name(&self) -> Option<GString> { fn get_preset_name(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_preset_name(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_preset_name(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_restriction(&self) -> Option<gst::Caps> { fn get_restriction(&self) -> Option<gst::Caps> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_restriction(self.as_ref().to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_profile_get_restriction(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_type_nick(&self) -> Option<GString> { fn get_type_nick(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_type_nick(self.as_ref().to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_profile_get_type_nick(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_enabled(&self) -> bool { fn is_enabled(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_encoding_profile_is_enabled(self.as_ref().to_glib_none().0)) from_glib(gst_pbutils_sys::gst_encoding_profile_is_enabled(
self.as_ref().to_glib_none().0,
))
} }
} }
fn is_equal<P: IsA<EncodingProfile>>(&self, b: &P) -> bool { fn is_equal<P: IsA<EncodingProfile>>(&self, b: &P) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_encoding_profile_is_equal(self.as_ref().to_glib_none().0, b.as_ref().to_glib_none().0)) from_glib(gst_pbutils_sys::gst_encoding_profile_is_equal(
self.as_ref().to_glib_none().0,
b.as_ref().to_glib_none().0,
))
} }
} }
} }

82
gstreamer-pbutils/src/auto/encoding_target.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use EncodingProfile;
use Error;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_pbutils_sys; use gst_pbutils_sys;
use std; use std;
use std::ptr; use std::ptr;
use EncodingProfile;
use Error;
glib_wrapper! { glib_wrapper! {
pub struct EncodingTarget(Object<gst_pbutils_sys::GstEncodingTarget, EncodingTargetClass>); pub struct EncodingTarget(Object<gst_pbutils_sys::GstEncodingTarget, EncodingTargetClass>);
@ -19,40 +19,61 @@ glib_wrapper! {
} }
impl EncodingTarget { impl EncodingTarget {
pub fn new(name: &str, category: &str, description: &str, profiles: &[EncodingProfile]) -> EncodingTarget { pub fn new(
name: &str,
category: &str,
description: &str,
profiles: &[EncodingProfile],
) -> EncodingTarget {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_target_new(name.to_glib_none().0, category.to_glib_none().0, description.to_glib_none().0, profiles.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_target_new(
name.to_glib_none().0,
category.to_glib_none().0,
description.to_glib_none().0,
profiles.to_glib_none().0,
))
} }
} }
pub fn get_category(&self) -> GString { pub fn get_category(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_target_get_category(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_target_get_category(
self.to_glib_none().0,
))
} }
} }
pub fn get_description(&self) -> GString { pub fn get_description(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_target_get_description(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_target_get_description(
self.to_glib_none().0,
))
} }
} }
pub fn get_name(&self) -> GString { pub fn get_name(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_pbutils_sys::gst_encoding_target_get_name(self.to_glib_none().0)) from_glib_none(gst_pbutils_sys::gst_encoding_target_get_name(
self.to_glib_none().0,
))
} }
} }
pub fn get_profile(&self, name: &str) -> Option<EncodingProfile> { pub fn get_profile(&self, name: &str) -> Option<EncodingProfile> {
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_encoding_target_get_profile(self.to_glib_none().0, name.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_encoding_target_get_profile(
self.to_glib_none().0,
name.to_glib_none().0,
))
} }
} }
pub fn get_profiles(&self) -> Vec<EncodingProfile> { pub fn get_profiles(&self) -> Vec<EncodingProfile> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_encoding_target_get_profiles(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(gst_pbutils_sys::gst_encoding_target_get_profiles(
self.to_glib_none().0,
))
} }
} }
@ -60,15 +81,27 @@ impl EncodingTarget {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_pbutils_sys::gst_encoding_target_save(self.to_glib_none().0, &mut error); let _ = gst_pbutils_sys::gst_encoding_target_save(self.to_glib_none().0, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
pub fn save_to_file<P: AsRef<std::path::Path>>(&self, filepath: P) -> Result<(), Error> { pub fn save_to_file<P: AsRef<std::path::Path>>(&self, filepath: P) -> Result<(), Error> {
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let _ = gst_pbutils_sys::gst_encoding_target_save_to_file(self.to_glib_none().0, filepath.as_ref().to_glib_none().0, &mut error); let _ = gst_pbutils_sys::gst_encoding_target_save_to_file(
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } self.to_glib_none().0,
filepath.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
} }
} }
@ -76,8 +109,16 @@ impl EncodingTarget {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_pbutils_sys::gst_encoding_target_load(name.to_glib_none().0, category.to_glib_none().0, &mut error); let ret = gst_pbutils_sys::gst_encoding_target_load(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } name.to_glib_none().0,
category.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
@ -85,8 +126,15 @@ impl EncodingTarget {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
let mut error = ptr::null_mut(); let mut error = ptr::null_mut();
let ret = gst_pbutils_sys::gst_encoding_target_load_from_file(filepath.as_ref().to_glib_none().0, &mut error); let ret = gst_pbutils_sys::gst_encoding_target_load_from_file(
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } filepath.as_ref().to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
} }
} }
} }

12
gstreamer-pbutils/src/auto/encoding_video_profile.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use EncodingProfile;
use glib::translate::*; use glib::translate::*;
use gst_pbutils_sys; use gst_pbutils_sys;
use EncodingProfile;
glib_wrapper! { glib_wrapper! {
pub struct EncodingVideoProfile(Object<gst_pbutils_sys::GstEncodingVideoProfile, gst_pbutils_sys::GstEncodingVideoProfileClass, EncodingVideoProfileClass>) @extends EncodingProfile; pub struct EncodingVideoProfile(Object<gst_pbutils_sys::GstEncodingVideoProfile, gst_pbutils_sys::GstEncodingVideoProfileClass, EncodingVideoProfileClass>) @extends EncodingProfile;
@ -16,14 +16,16 @@ glib_wrapper! {
impl EncodingVideoProfile { impl EncodingVideoProfile {
pub fn get_pass(&self) -> u32 { pub fn get_pass(&self) -> u32 {
unsafe { unsafe { gst_pbutils_sys::gst_encoding_video_profile_get_pass(self.to_glib_none().0) }
gst_pbutils_sys::gst_encoding_video_profile_get_pass(self.to_glib_none().0)
}
} }
pub fn get_variableframerate(&self) -> bool { pub fn get_variableframerate(&self) -> bool {
unsafe { unsafe {
from_glib(gst_pbutils_sys::gst_encoding_video_profile_get_variableframerate(self.to_glib_none().0)) from_glib(
gst_pbutils_sys::gst_encoding_video_profile_get_variableframerate(
self.to_glib_none().0,
),
)
} }
} }
} }

10
gstreamer-pbutils/src/auto/enums.rs
View file

@ -2,18 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_pbutils_sys; use gst_pbutils_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum DiscovererResult { pub enum DiscovererResult {
Ok, Ok,
UriInvalid, UriInvalid,
@ -37,7 +36,7 @@ impl ToGlib for DiscovererResult {
DiscovererResult::Timeout => gst_pbutils_sys::GST_DISCOVERER_TIMEOUT, DiscovererResult::Timeout => gst_pbutils_sys::GST_DISCOVERER_TIMEOUT,
DiscovererResult::Busy => gst_pbutils_sys::GST_DISCOVERER_BUSY, DiscovererResult::Busy => gst_pbutils_sys::GST_DISCOVERER_BUSY,
DiscovererResult::MissingPlugins => gst_pbutils_sys::GST_DISCOVERER_MISSING_PLUGINS, DiscovererResult::MissingPlugins => gst_pbutils_sys::GST_DISCOVERER_MISSING_PLUGINS,
DiscovererResult::__Unknown(value) => value DiscovererResult::__Unknown(value) => value,
} }
} }
} }
@ -81,4 +80,3 @@ impl SetValue for DiscovererResult {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
} }
} }

5
gstreamer-pbutils/src/auto/flags.rs
View file

@ -2,13 +2,13 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_pbutils_sys; use gst_pbutils_sys;
@ -62,4 +62,3 @@ impl SetValue for DiscovererSerializeFlags {
gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
} }
} }

29
gstreamer-pbutils/src/auto/functions.rs
View file

@ -2,45 +2,54 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use EncodingTarget;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_pbutils_sys; use gst_pbutils_sys;
use std::mem; use std::mem;
use EncodingTarget;
pub fn encoding_list_all_targets(categoryname: Option<&str>) -> Vec<EncodingTarget> { pub fn encoding_list_all_targets(categoryname: Option<&str>) -> Vec<EncodingTarget> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_encoding_list_all_targets(categoryname.to_glib_none().0)) FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_encoding_list_all_targets(
categoryname.to_glib_none().0,
))
} }
} }
pub fn encoding_list_available_categories() -> Vec<GString> { pub fn encoding_list_available_categories() -> Vec<GString> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
FromGlibPtrContainer::from_glib_full(gst_pbutils_sys::gst_encoding_list_available_categories()) FromGlibPtrContainer::from_glib_full(
gst_pbutils_sys::gst_encoding_list_available_categories(),
)
} }
} }
pub fn pb_utils_get_element_description(factory_name: &str) -> Option<GString> { pub fn pb_utils_get_element_description(factory_name: &str) -> Option<GString> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_pb_utils_get_element_description(factory_name.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_pb_utils_get_element_description(
factory_name.to_glib_none().0,
))
} }
} }
pub fn pb_utils_get_sink_description(protocol: &str) -> Option<GString> { pub fn pb_utils_get_sink_description(protocol: &str) -> Option<GString> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_pb_utils_get_sink_description(protocol.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_pb_utils_get_sink_description(
protocol.to_glib_none().0,
))
} }
} }
pub fn pb_utils_get_source_description(protocol: &str) -> Option<GString> { pub fn pb_utils_get_source_description(protocol: &str) -> Option<GString> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe {
from_glib_full(gst_pbutils_sys::gst_pb_utils_get_source_description(protocol.to_glib_none().0)) from_glib_full(gst_pbutils_sys::gst_pb_utils_get_source_description(
protocol.to_glib_none().0,
))
} }
} }
@ -58,7 +67,5 @@ pub fn plugins_base_version() -> (u32, u32, u32, u32) {
pub fn plugins_base_version_string() -> Option<GString> { pub fn plugins_base_version_string() -> Option<GString> {
assert_initialized_main_thread!(); assert_initialized_main_thread!();
unsafe { unsafe { from_glib_full(gst_pbutils_sys::gst_plugins_base_version_string()) }
from_glib_full(gst_pbutils_sys::gst_plugins_base_version_string())
}
} }

10
gstreamer-pbutils/src/auto/mod.rs
View file

@ -15,8 +15,10 @@ mod discoverer_info;
pub use self::discoverer_info::{DiscovererInfo, DiscovererInfoClass}; pub use self::discoverer_info::{DiscovererInfo, DiscovererInfoClass};
mod discoverer_stream_info; mod discoverer_stream_info;
pub use self::discoverer_stream_info::{DiscovererStreamInfo, DiscovererStreamInfoClass, NONE_DISCOVERER_STREAM_INFO};
pub use self::discoverer_stream_info::DiscovererStreamInfoExt; pub use self::discoverer_stream_info::DiscovererStreamInfoExt;
pub use self::discoverer_stream_info::{
DiscovererStreamInfo, DiscovererStreamInfoClass, NONE_DISCOVERER_STREAM_INFO,
};
mod discoverer_subtitle_info; mod discoverer_subtitle_info;
pub use self::discoverer_subtitle_info::{DiscovererSubtitleInfo, DiscovererSubtitleInfoClass}; pub use self::discoverer_subtitle_info::{DiscovererSubtitleInfo, DiscovererSubtitleInfoClass};
@ -28,11 +30,13 @@ mod encoding_audio_profile;
pub use self::encoding_audio_profile::{EncodingAudioProfile, EncodingAudioProfileClass}; pub use self::encoding_audio_profile::{EncodingAudioProfile, EncodingAudioProfileClass};
mod encoding_container_profile; mod encoding_container_profile;
pub use self::encoding_container_profile::{EncodingContainerProfile, EncodingContainerProfileClass}; pub use self::encoding_container_profile::{
EncodingContainerProfile, EncodingContainerProfileClass,
};
mod encoding_profile; mod encoding_profile;
pub use self::encoding_profile::{EncodingProfile, EncodingProfileClass, NONE_ENCODING_PROFILE};
pub use self::encoding_profile::EncodingProfileExt; pub use self::encoding_profile::EncodingProfileExt;
pub use self::encoding_profile::{EncodingProfile, EncodingProfileClass, NONE_ENCODING_PROFILE};
mod encoding_target; mod encoding_target;
pub use self::encoding_target::{EncodingTarget, EncodingTargetClass}; pub use self::encoding_target::{EncodingTarget, EncodingTargetClass};

1
gstreamer-pbutils/src/lib.rs
View file

@ -43,7 +43,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::functions::*; pub use auto::functions::*;
pub use auto::*; pub use auto::*;

35
gstreamer-player/src/auto/enums.rs
View file

@ -2,20 +2,19 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::Quark;
use glib::StaticType;
use glib::Type;
use glib::error::ErrorDomain; use glib::error::ErrorDomain;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::Quark;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_player_sys; use gst_player_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum PlayerColorBalanceType { pub enum PlayerColorBalanceType {
Hue, Hue,
Brightness, Brightness,
@ -32,10 +31,14 @@ impl ToGlib for PlayerColorBalanceType {
fn to_glib(&self) -> gst_player_sys::GstPlayerColorBalanceType { fn to_glib(&self) -> gst_player_sys::GstPlayerColorBalanceType {
match *self { match *self {
PlayerColorBalanceType::Hue => gst_player_sys::GST_PLAYER_COLOR_BALANCE_HUE, PlayerColorBalanceType::Hue => gst_player_sys::GST_PLAYER_COLOR_BALANCE_HUE,
PlayerColorBalanceType::Brightness => gst_player_sys::GST_PLAYER_COLOR_BALANCE_BRIGHTNESS, PlayerColorBalanceType::Brightness => {
PlayerColorBalanceType::Saturation => gst_player_sys::GST_PLAYER_COLOR_BALANCE_SATURATION, gst_player_sys::GST_PLAYER_COLOR_BALANCE_BRIGHTNESS
}
PlayerColorBalanceType::Saturation => {
gst_player_sys::GST_PLAYER_COLOR_BALANCE_SATURATION
}
PlayerColorBalanceType::Contrast => gst_player_sys::GST_PLAYER_COLOR_BALANCE_CONTRAST, PlayerColorBalanceType::Contrast => gst_player_sys::GST_PLAYER_COLOR_BALANCE_CONTRAST,
PlayerColorBalanceType::__Unknown(value) => value PlayerColorBalanceType::__Unknown(value) => value,
} }
} }
} }
@ -78,8 +81,7 @@ impl SetValue for PlayerColorBalanceType {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum PlayerError { pub enum PlayerError {
Failed, Failed,
#[doc(hidden)] #[doc(hidden)]
@ -93,7 +95,7 @@ impl ToGlib for PlayerError {
fn to_glib(&self) -> gst_player_sys::GstPlayerError { fn to_glib(&self) -> gst_player_sys::GstPlayerError {
match *self { match *self {
PlayerError::Failed => gst_player_sys::GST_PLAYER_ERROR_FAILED, PlayerError::Failed => gst_player_sys::GST_PLAYER_ERROR_FAILED,
PlayerError::__Unknown(value) => value PlayerError::__Unknown(value) => value,
} }
} }
} }
@ -152,8 +154,7 @@ impl SetValue for PlayerError {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum PlayerSnapshotFormat { pub enum PlayerSnapshotFormat {
RawNative, RawNative,
RawXrgb, RawXrgb,
@ -175,7 +176,7 @@ impl ToGlib for PlayerSnapshotFormat {
PlayerSnapshotFormat::RawBgrx => gst_player_sys::GST_PLAYER_THUMBNAIL_RAW_BGRx, PlayerSnapshotFormat::RawBgrx => gst_player_sys::GST_PLAYER_THUMBNAIL_RAW_BGRx,
PlayerSnapshotFormat::Jpg => gst_player_sys::GST_PLAYER_THUMBNAIL_JPG, PlayerSnapshotFormat::Jpg => gst_player_sys::GST_PLAYER_THUMBNAIL_JPG,
PlayerSnapshotFormat::Png => gst_player_sys::GST_PLAYER_THUMBNAIL_PNG, PlayerSnapshotFormat::Png => gst_player_sys::GST_PLAYER_THUMBNAIL_PNG,
PlayerSnapshotFormat::__Unknown(value) => value PlayerSnapshotFormat::__Unknown(value) => value,
} }
} }
} }
@ -195,8 +196,7 @@ impl FromGlib<gst_player_sys::GstPlayerSnapshotFormat> for PlayerSnapshotFormat
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum PlayerState { pub enum PlayerState {
Stopped, Stopped,
Buffering, Buffering,
@ -216,7 +216,7 @@ impl ToGlib for PlayerState {
PlayerState::Buffering => gst_player_sys::GST_PLAYER_STATE_BUFFERING, PlayerState::Buffering => gst_player_sys::GST_PLAYER_STATE_BUFFERING,
PlayerState::Paused => gst_player_sys::GST_PLAYER_STATE_PAUSED, PlayerState::Paused => gst_player_sys::GST_PLAYER_STATE_PAUSED,
PlayerState::Playing => gst_player_sys::GST_PLAYER_STATE_PLAYING, PlayerState::Playing => gst_player_sys::GST_PLAYER_STATE_PLAYING,
PlayerState::__Unknown(value) => value PlayerState::__Unknown(value) => value,
} }
} }
} }
@ -258,4 +258,3 @@ impl SetValue for PlayerState {
gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib()) gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
} }
} }

16
gstreamer-player/src/auto/mod.rs
View file

@ -9,18 +9,22 @@ mod player_audio_info;
pub use self::player_audio_info::{PlayerAudioInfo, PlayerAudioInfoClass}; pub use self::player_audio_info::{PlayerAudioInfo, PlayerAudioInfoClass};
mod player_gmain_context_signal_dispatcher; mod player_gmain_context_signal_dispatcher;
pub use self::player_gmain_context_signal_dispatcher::{PlayerGMainContextSignalDispatcher, PlayerGMainContextSignalDispatcherClass}; pub use self::player_gmain_context_signal_dispatcher::{
PlayerGMainContextSignalDispatcher, PlayerGMainContextSignalDispatcherClass,
};
mod player_media_info; mod player_media_info;
pub use self::player_media_info::{PlayerMediaInfo, PlayerMediaInfoClass}; pub use self::player_media_info::{PlayerMediaInfo, PlayerMediaInfoClass};
mod player_signal_dispatcher; mod player_signal_dispatcher;
pub use self::player_signal_dispatcher::{PlayerSignalDispatcher, NONE_PLAYER_SIGNAL_DISPATCHER};
pub use self::player_signal_dispatcher::PlayerSignalDispatcherExt; pub use self::player_signal_dispatcher::PlayerSignalDispatcherExt;
pub use self::player_signal_dispatcher::{PlayerSignalDispatcher, NONE_PLAYER_SIGNAL_DISPATCHER};
mod player_stream_info; mod player_stream_info;
pub use self::player_stream_info::{PlayerStreamInfo, PlayerStreamInfoClass, NONE_PLAYER_STREAM_INFO};
pub use self::player_stream_info::PlayerStreamInfoExt; pub use self::player_stream_info::PlayerStreamInfoExt;
pub use self::player_stream_info::{
PlayerStreamInfo, PlayerStreamInfoClass, NONE_PLAYER_STREAM_INFO,
};
mod player_subtitle_info; mod player_subtitle_info;
pub use self::player_subtitle_info::{PlayerSubtitleInfo, PlayerSubtitleInfoClass}; pub use self::player_subtitle_info::{PlayerSubtitleInfo, PlayerSubtitleInfoClass};
@ -29,11 +33,13 @@ mod player_video_info;
pub use self::player_video_info::{PlayerVideoInfo, PlayerVideoInfoClass}; pub use self::player_video_info::{PlayerVideoInfo, PlayerVideoInfoClass};
mod player_video_overlay_video_renderer; mod player_video_overlay_video_renderer;
pub use self::player_video_overlay_video_renderer::{PlayerVideoOverlayVideoRenderer, PlayerVideoOverlayVideoRendererClass}; pub use self::player_video_overlay_video_renderer::{
PlayerVideoOverlayVideoRenderer, PlayerVideoOverlayVideoRendererClass,
};
mod player_video_renderer; mod player_video_renderer;
pub use self::player_video_renderer::{PlayerVideoRenderer, NONE_PLAYER_VIDEO_RENDERER};
pub use self::player_video_renderer::PlayerVideoRendererExt; pub use self::player_video_renderer::PlayerVideoRendererExt;
pub use self::player_video_renderer::{PlayerVideoRenderer, NONE_PLAYER_VIDEO_RENDERER};
mod player_visualization; mod player_visualization;
pub use self::player_visualization::PlayerVisualization; pub use self::player_visualization::PlayerVisualization;

740
gstreamer-player/src/auto/player.rs
View file

File diff suppressed because it is too large Load diff

24
gstreamer-player/src/auto/player_audio_info.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use PlayerStreamInfo;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_player_sys; use gst_player_sys;
use PlayerStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct PlayerAudioInfo(Object<gst_player_sys::GstPlayerAudioInfo, gst_player_sys::GstPlayerAudioInfoClass, PlayerAudioInfoClass>) @extends PlayerStreamInfo; pub struct PlayerAudioInfo(Object<gst_player_sys::GstPlayerAudioInfo, gst_player_sys::GstPlayerAudioInfoClass, PlayerAudioInfoClass>) @extends PlayerStreamInfo;
@ -17,33 +17,27 @@ glib_wrapper! {
impl PlayerAudioInfo { impl PlayerAudioInfo {
pub fn get_bitrate(&self) -> i32 { pub fn get_bitrate(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_audio_info_get_bitrate(self.to_glib_none().0) }
gst_player_sys::gst_player_audio_info_get_bitrate(self.to_glib_none().0)
}
} }
pub fn get_channels(&self) -> i32 { pub fn get_channels(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_audio_info_get_channels(self.to_glib_none().0) }
gst_player_sys::gst_player_audio_info_get_channels(self.to_glib_none().0)
}
} }
pub fn get_language(&self) -> Option<GString> { pub fn get_language(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_audio_info_get_language(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_audio_info_get_language(
self.to_glib_none().0,
))
} }
} }
pub fn get_max_bitrate(&self) -> i32 { pub fn get_max_bitrate(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_audio_info_get_max_bitrate(self.to_glib_none().0) }
gst_player_sys::gst_player_audio_info_get_max_bitrate(self.to_glib_none().0)
}
} }
pub fn get_sample_rate(&self) -> i32 { pub fn get_sample_rate(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_audio_info_get_sample_rate(self.to_glib_none().0) }
gst_player_sys::gst_player_audio_info_get_sample_rate(self.to_glib_none().0)
}
} }
} }

12
gstreamer-player/src/auto/player_gmain_context_signal_dispatcher.rs
View file

@ -2,14 +2,14 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use PlayerSignalDispatcher;
use glib; use glib;
use glib::StaticType;
use glib::Value;
use glib::object::ObjectType as ObjectType_; use glib::object::ObjectType as ObjectType_;
use glib::translate::*; use glib::translate::*;
use glib::StaticType;
use glib::Value;
use gobject_sys; use gobject_sys;
use gst_player_sys; use gst_player_sys;
use PlayerSignalDispatcher;
glib_wrapper! { glib_wrapper! {
pub struct PlayerGMainContextSignalDispatcher(Object<gst_player_sys::GstPlayerGMainContextSignalDispatcher, gst_player_sys::GstPlayerGMainContextSignalDispatcherClass, PlayerGMainContextSignalDispatcherClass>) @implements PlayerSignalDispatcher; pub struct PlayerGMainContextSignalDispatcher(Object<gst_player_sys::GstPlayerGMainContextSignalDispatcher, gst_player_sys::GstPlayerGMainContextSignalDispatcherClass, PlayerGMainContextSignalDispatcherClass>) @implements PlayerSignalDispatcher;
@ -23,7 +23,11 @@ impl PlayerGMainContextSignalDispatcher {
pub fn get_property_application_context(&self) -> Option<glib::MainContext> { pub fn get_property_application_context(&self) -> Option<glib::MainContext> {
unsafe { unsafe {
let mut value = Value::from_type(<glib::MainContext as StaticType>::static_type()); let mut value = Value::from_type(<glib::MainContext as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"application-context\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"application-context\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }

60
gstreamer-player/src/auto/player_media_info.rs
View file

@ -2,14 +2,14 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::translate::*;
use glib::GString;
use gst;
use gst_player_sys;
use PlayerAudioInfo; use PlayerAudioInfo;
use PlayerStreamInfo; use PlayerStreamInfo;
use PlayerSubtitleInfo; use PlayerSubtitleInfo;
use PlayerVideoInfo; use PlayerVideoInfo;
use glib::GString;
use glib::translate::*;
use gst;
use gst_player_sys;
glib_wrapper! { glib_wrapper! {
pub struct PlayerMediaInfo(Object<gst_player_sys::GstPlayerMediaInfo, gst_player_sys::GstPlayerMediaInfoClass, PlayerMediaInfoClass>); pub struct PlayerMediaInfo(Object<gst_player_sys::GstPlayerMediaInfo, gst_player_sys::GstPlayerMediaInfoClass, PlayerMediaInfoClass>);
@ -22,25 +22,33 @@ glib_wrapper! {
impl PlayerMediaInfo { impl PlayerMediaInfo {
pub fn get_audio_streams(&self) -> Vec<PlayerAudioInfo> { pub fn get_audio_streams(&self) -> Vec<PlayerAudioInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_player_sys::gst_player_media_info_get_audio_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_player_sys::gst_player_media_info_get_audio_streams(self.to_glib_none().0),
)
} }
} }
pub fn get_container_format(&self) -> Option<GString> { pub fn get_container_format(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_media_info_get_container_format(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_media_info_get_container_format(
self.to_glib_none().0,
))
} }
} }
pub fn get_duration(&self) -> gst::ClockTime { pub fn get_duration(&self) -> gst::ClockTime {
unsafe { unsafe {
from_glib(gst_player_sys::gst_player_media_info_get_duration(self.to_glib_none().0)) from_glib(gst_player_sys::gst_player_media_info_get_duration(
self.to_glib_none().0,
))
} }
} }
pub fn get_image_sample(&self) -> Option<gst::Sample> { pub fn get_image_sample(&self) -> Option<gst::Sample> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_media_info_get_image_sample(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_media_info_get_image_sample(
self.to_glib_none().0,
))
} }
} }
@ -58,7 +66,9 @@ impl PlayerMediaInfo {
pub fn get_number_of_subtitle_streams(&self) -> u32 { pub fn get_number_of_subtitle_streams(&self) -> u32 {
unsafe { unsafe {
gst_player_sys::gst_player_media_info_get_number_of_subtitle_streams(self.to_glib_none().0) gst_player_sys::gst_player_media_info_get_number_of_subtitle_streams(
self.to_glib_none().0,
)
} }
} }
@ -70,49 +80,65 @@ impl PlayerMediaInfo {
pub fn get_stream_list(&self) -> Vec<PlayerStreamInfo> { pub fn get_stream_list(&self) -> Vec<PlayerStreamInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_player_sys::gst_player_media_info_get_stream_list(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_player_sys::gst_player_media_info_get_stream_list(self.to_glib_none().0),
)
} }
} }
pub fn get_subtitle_streams(&self) -> Vec<PlayerSubtitleInfo> { pub fn get_subtitle_streams(&self) -> Vec<PlayerSubtitleInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_player_sys::gst_player_media_info_get_subtitle_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_player_sys::gst_player_media_info_get_subtitle_streams(self.to_glib_none().0),
)
} }
} }
pub fn get_tags(&self) -> Option<gst::TagList> { pub fn get_tags(&self) -> Option<gst::TagList> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_media_info_get_tags(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_media_info_get_tags(
self.to_glib_none().0,
))
} }
} }
pub fn get_title(&self) -> Option<GString> { pub fn get_title(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_media_info_get_title(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_media_info_get_title(
self.to_glib_none().0,
))
} }
} }
pub fn get_uri(&self) -> GString { pub fn get_uri(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_media_info_get_uri(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_media_info_get_uri(
self.to_glib_none().0,
))
} }
} }
pub fn get_video_streams(&self) -> Vec<PlayerVideoInfo> { pub fn get_video_streams(&self) -> Vec<PlayerVideoInfo> {
unsafe { unsafe {
FromGlibPtrContainer::from_glib_none(gst_player_sys::gst_player_media_info_get_video_streams(self.to_glib_none().0)) FromGlibPtrContainer::from_glib_none(
gst_player_sys::gst_player_media_info_get_video_streams(self.to_glib_none().0),
)
} }
} }
pub fn is_live(&self) -> bool { pub fn is_live(&self) -> bool {
unsafe { unsafe {
from_glib(gst_player_sys::gst_player_media_info_is_live(self.to_glib_none().0)) from_glib(gst_player_sys::gst_player_media_info_is_live(
self.to_glib_none().0,
))
} }
} }
pub fn is_seekable(&self) -> bool { pub fn is_seekable(&self) -> bool {
unsafe { unsafe {
from_glib(gst_player_sys::gst_player_media_info_is_seekable(self.to_glib_none().0)) from_glib(gst_player_sys::gst_player_media_info_is_seekable(
self.to_glib_none().0,
))
} }
} }
} }

22
gstreamer-player/src/auto/player_stream_info.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::GString;
use glib::object::IsA; use glib::object::IsA;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst; use gst;
use gst_player_sys; use gst_player_sys;
@ -36,31 +36,41 @@ pub trait PlayerStreamInfoExt: 'static {
impl<O: IsA<PlayerStreamInfo>> PlayerStreamInfoExt for O { impl<O: IsA<PlayerStreamInfo>> PlayerStreamInfoExt for O {
fn get_caps(&self) -> Option<gst::Caps> { fn get_caps(&self) -> Option<gst::Caps> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_stream_info_get_caps(const_override(self.as_ref().to_glib_none().0))) from_glib_none(gst_player_sys::gst_player_stream_info_get_caps(
const_override(self.as_ref().to_glib_none().0),
))
} }
} }
fn get_codec(&self) -> Option<GString> { fn get_codec(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_stream_info_get_codec(const_override(self.as_ref().to_glib_none().0))) from_glib_none(gst_player_sys::gst_player_stream_info_get_codec(
const_override(self.as_ref().to_glib_none().0),
))
} }
} }
fn get_index(&self) -> i32 { fn get_index(&self) -> i32 {
unsafe { unsafe {
gst_player_sys::gst_player_stream_info_get_index(const_override(self.as_ref().to_glib_none().0)) gst_player_sys::gst_player_stream_info_get_index(const_override(
self.as_ref().to_glib_none().0,
))
} }
} }
fn get_stream_type(&self) -> GString { fn get_stream_type(&self) -> GString {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_stream_info_get_stream_type(const_override(self.as_ref().to_glib_none().0))) from_glib_none(gst_player_sys::gst_player_stream_info_get_stream_type(
const_override(self.as_ref().to_glib_none().0),
))
} }
} }
fn get_tags(&self) -> Option<gst::TagList> { fn get_tags(&self) -> Option<gst::TagList> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_stream_info_get_tags(const_override(self.as_ref().to_glib_none().0))) from_glib_none(gst_player_sys::gst_player_stream_info_get_tags(
const_override(self.as_ref().to_glib_none().0),
))
} }
} }
} }

8
gstreamer-player/src/auto/player_subtitle_info.rs
View file

@ -2,10 +2,10 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use PlayerStreamInfo;
use glib::GString;
use glib::translate::*; use glib::translate::*;
use glib::GString;
use gst_player_sys; use gst_player_sys;
use PlayerStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct PlayerSubtitleInfo(Object<gst_player_sys::GstPlayerSubtitleInfo, gst_player_sys::GstPlayerSubtitleInfoClass, PlayerSubtitleInfoClass>) @extends PlayerStreamInfo; pub struct PlayerSubtitleInfo(Object<gst_player_sys::GstPlayerSubtitleInfo, gst_player_sys::GstPlayerSubtitleInfoClass, PlayerSubtitleInfoClass>) @extends PlayerStreamInfo;
@ -18,7 +18,9 @@ glib_wrapper! {
impl PlayerSubtitleInfo { impl PlayerSubtitleInfo {
pub fn get_language(&self) -> Option<GString> { pub fn get_language(&self) -> Option<GString> {
unsafe { unsafe {
from_glib_none(gst_player_sys::gst_player_subtitle_info_get_language(self.to_glib_none().0)) from_glib_none(gst_player_sys::gst_player_subtitle_info_get_language(
self.to_glib_none().0,
))
} }
} }
} }

18
gstreamer-player/src/auto/player_video_info.rs
View file

@ -2,9 +2,9 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use PlayerStreamInfo;
use glib::translate::*; use glib::translate::*;
use gst_player_sys; use gst_player_sys;
use PlayerStreamInfo;
glib_wrapper! { glib_wrapper! {
pub struct PlayerVideoInfo(Object<gst_player_sys::GstPlayerVideoInfo, gst_player_sys::GstPlayerVideoInfoClass, PlayerVideoInfoClass>) @extends PlayerStreamInfo; pub struct PlayerVideoInfo(Object<gst_player_sys::GstPlayerVideoInfo, gst_player_sys::GstPlayerVideoInfoClass, PlayerVideoInfoClass>) @extends PlayerStreamInfo;
@ -16,27 +16,19 @@ glib_wrapper! {
impl PlayerVideoInfo { impl PlayerVideoInfo {
pub fn get_bitrate(&self) -> i32 { pub fn get_bitrate(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_video_info_get_bitrate(self.to_glib_none().0) }
gst_player_sys::gst_player_video_info_get_bitrate(self.to_glib_none().0)
}
} }
pub fn get_height(&self) -> i32 { pub fn get_height(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_video_info_get_height(self.to_glib_none().0) }
gst_player_sys::gst_player_video_info_get_height(self.to_glib_none().0)
}
} }
pub fn get_max_bitrate(&self) -> i32 { pub fn get_max_bitrate(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_video_info_get_max_bitrate(self.to_glib_none().0) }
gst_player_sys::gst_player_video_info_get_max_bitrate(self.to_glib_none().0)
}
} }
pub fn get_width(&self) -> i32 { pub fn get_width(&self) -> i32 {
unsafe { unsafe { gst_player_sys::gst_player_video_info_get_width(self.to_glib_none().0) }
gst_player_sys::gst_player_video_info_get_width(self.to_glib_none().0)
}
} }
} }

84
gstreamer-player/src/auto/player_video_overlay_video_renderer.rs
View file

@ -2,13 +2,12 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use PlayerVideoRenderer; use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType; use glib::StaticType;
use glib::Value; use glib::Value;
use glib::object::ObjectType as ObjectType_;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_sys; use glib_sys;
use gobject_sys; use gobject_sys;
use gst; use gst;
@ -16,6 +15,7 @@ use gst_player_sys;
use std::boxed::Box as Box_; use std::boxed::Box as Box_;
use std::mem; use std::mem;
use std::mem::transmute; use std::mem::transmute;
use PlayerVideoRenderer;
glib_wrapper! { glib_wrapper! {
pub struct PlayerVideoOverlayVideoRenderer(Object<gst_player_sys::GstPlayerVideoOverlayVideoRenderer, gst_player_sys::GstPlayerVideoOverlayVideoRendererClass, PlayerVideoOverlayVideoRendererClass>) @implements PlayerVideoRenderer; pub struct PlayerVideoOverlayVideoRenderer(Object<gst_player_sys::GstPlayerVideoOverlayVideoRenderer, gst_player_sys::GstPlayerVideoOverlayVideoRendererClass, PlayerVideoOverlayVideoRendererClass>) @implements PlayerVideoRenderer;
@ -38,7 +38,13 @@ impl PlayerVideoOverlayVideoRenderer {
let mut y = mem::uninitialized(); let mut y = mem::uninitialized();
let mut width = mem::uninitialized(); let mut width = mem::uninitialized();
let mut height = mem::uninitialized(); let mut height = mem::uninitialized();
gst_player_sys::gst_player_video_overlay_video_renderer_get_render_rectangle(self.to_glib_none().0, &mut x, &mut y, &mut width, &mut height); gst_player_sys::gst_player_video_overlay_video_renderer_get_render_rectangle(
self.to_glib_none().0,
&mut x,
&mut y,
&mut width,
&mut height,
);
(x, y, width, height) (x, y, width, height)
} }
} }
@ -49,7 +55,13 @@ impl PlayerVideoOverlayVideoRenderer {
pub fn set_render_rectangle(&self, x: i32, y: i32, width: i32, height: i32) { pub fn set_render_rectangle(&self, x: i32, y: i32, width: i32, height: i32) {
unsafe { unsafe {
gst_player_sys::gst_player_video_overlay_video_renderer_set_render_rectangle(self.to_glib_none().0, x, y, width, height); gst_player_sys::gst_player_video_overlay_video_renderer_set_render_rectangle(
self.to_glib_none().0,
x,
y,
width,
height,
);
} }
} }
@ -60,14 +72,22 @@ impl PlayerVideoOverlayVideoRenderer {
pub fn get_property_video_sink(&self) -> Option<gst::Element> { pub fn get_property_video_sink(&self) -> Option<gst::Element> {
unsafe { unsafe {
let mut value = Value::from_type(<gst::Element as StaticType>::static_type()); let mut value = Value::from_type(<gst::Element as StaticType>::static_type());
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"video-sink\0".as_ptr() as *const _, value.to_glib_none_mut().0); gobject_sys::g_object_get_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"video-sink\0".as_ptr() as *const _,
value.to_glib_none_mut().0,
);
value.get() value.get()
} }
} }
pub fn set_property_video_sink(&self, video_sink: Option<&gst::Element>) { pub fn set_property_video_sink(&self, video_sink: Option<&gst::Element>) {
unsafe { unsafe {
gobject_sys::g_object_set_property(self.as_ptr() as *mut gobject_sys::GObject, b"video-sink\0".as_ptr() as *const _, Value::from(video_sink).to_glib_none().0); gobject_sys::g_object_set_property(
self.as_ptr() as *mut gobject_sys::GObject,
b"video-sink\0".as_ptr() as *const _,
Value::from(video_sink).to_glib_none().0,
);
} }
} }
@ -79,27 +99,57 @@ impl PlayerVideoOverlayVideoRenderer {
// unsafe { TODO: call gst_player_sys:gst_player_video_overlay_video_renderer_new_with_sink() } // unsafe { TODO: call gst_player_sys:gst_player_video_overlay_video_renderer_new_with_sink() }
//} //}
pub fn connect_property_video_sink_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_video_sink_notify<
unsafe extern "C" fn notify_video_sink_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_video_sink_trampoline<
F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static,
>(
this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::video-sink\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_video_sink_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::video-sink\0".as_ptr() as *const _,
Some(transmute(notify_video_sink_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
pub fn connect_property_window_handle_notify<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId { pub fn connect_property_window_handle_notify<
unsafe extern "C" fn notify_window_handle_trampoline<F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static>(this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer, _param_spec: glib_sys::gpointer, f: glib_sys::gpointer) { F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static,
>(
&self,
f: F,
) -> SignalHandlerId {
unsafe extern "C" fn notify_window_handle_trampoline<
F: Fn(&PlayerVideoOverlayVideoRenderer) + Send + Sync + 'static,
>(
this: *mut gst_player_sys::GstPlayerVideoOverlayVideoRenderer,
_param_spec: glib_sys::gpointer,
f: glib_sys::gpointer,
) {
let f: &F = &*(f as *const F); let f: &F = &*(f as *const F);
f(&from_glib_borrow(this)) f(&from_glib_borrow(this))
} }
unsafe { unsafe {
let f: Box_<F> = Box_::new(f); let f: Box_<F> = Box_::new(f);
connect_raw(self.as_ptr() as *mut _, b"notify::window-handle\0".as_ptr() as *const _, connect_raw(
Some(transmute(notify_window_handle_trampoline::<F> as usize)), Box_::into_raw(f)) self.as_ptr() as *mut _,
b"notify::window-handle\0".as_ptr() as *const _,
Some(transmute(notify_window_handle_trampoline::<F> as usize)),
Box_::into_raw(f),
)
} }
} }
} }

1
gstreamer-player/src/lib.rs
View file

@ -33,7 +33,6 @@ pub use glib::{Cast, Continue, Error, IsA, StaticType, ToValue, Type, TypedValue
#[allow(clippy::match_same_arms)] #[allow(clippy::match_same_arms)]
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
#[rustfmt::skip]
mod auto; mod auto;
pub use auto::*; pub use auto::*;

43
gstreamer-rtsp-server/src/auto/enums.rs
View file

@ -2,18 +2,17 @@
// from gir-files (https://github.com/gtk-rs/gir-files) // from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT // DO NOT EDIT
use glib::StaticType;
use glib::Type;
use glib::translate::*; use glib::translate::*;
use glib::value::FromValue; use glib::value::FromValue;
use glib::value::FromValueOptional; use glib::value::FromValueOptional;
use glib::value::SetValue; use glib::value::SetValue;
use glib::value::Value; use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys; use gobject_sys;
use gst_rtsp_server_sys; use gst_rtsp_server_sys;
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPAddressPoolResult { pub enum RTSPAddressPoolResult {
Ok, Ok,
Einval, Einval,
@ -32,10 +31,12 @@ impl ToGlib for RTSPAddressPoolResult {
match *self { match *self {
RTSPAddressPoolResult::Ok => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_OK, RTSPAddressPoolResult::Ok => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_OK,
RTSPAddressPoolResult::Einval => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_EINVAL, RTSPAddressPoolResult::Einval => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_EINVAL,
RTSPAddressPoolResult::Ereserved => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ERESERVED, RTSPAddressPoolResult::Ereserved => {
gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ERESERVED
}
RTSPAddressPoolResult::Erange => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ERANGE, RTSPAddressPoolResult::Erange => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ERANGE,
RTSPAddressPoolResult::Elast => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ELAST, RTSPAddressPoolResult::Elast => gst_rtsp_server_sys::GST_RTSP_ADDRESS_POOL_ELAST,
RTSPAddressPoolResult::__Unknown(value) => value RTSPAddressPoolResult::__Unknown(value) => value,
} }
} }
} }
@ -55,8 +56,7 @@ impl FromGlib<gst_rtsp_server_sys::GstRTSPAddressPoolResult> for RTSPAddressPool
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPFilterResult { pub enum RTSPFilterResult {
Remove, Remove,
Keep, Keep,
@ -74,7 +74,7 @@ impl ToGlib for RTSPFilterResult {
RTSPFilterResult::Remove => gst_rtsp_server_sys::GST_RTSP_FILTER_REMOVE, RTSPFilterResult::Remove => gst_rtsp_server_sys::GST_RTSP_FILTER_REMOVE,
RTSPFilterResult::Keep => gst_rtsp_server_sys::GST_RTSP_FILTER_KEEP, RTSPFilterResult::Keep => gst_rtsp_server_sys::GST_RTSP_FILTER_KEEP,
RTSPFilterResult::Ref => gst_rtsp_server_sys::GST_RTSP_FILTER_REF, RTSPFilterResult::Ref => gst_rtsp_server_sys::GST_RTSP_FILTER_REF,
RTSPFilterResult::__Unknown(value) => value RTSPFilterResult::__Unknown(value) => value,
} }
} }
} }
@ -92,8 +92,7 @@ impl FromGlib<gst_rtsp_server_sys::GstRTSPFilterResult> for RTSPFilterResult {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPMediaStatus { pub enum RTSPMediaStatus {
Unprepared, Unprepared,
Unpreparing, Unpreparing,
@ -117,7 +116,7 @@ impl ToGlib for RTSPMediaStatus {
RTSPMediaStatus::Prepared => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_PREPARED, RTSPMediaStatus::Prepared => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_PREPARED,
RTSPMediaStatus::Suspended => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_SUSPENDED, RTSPMediaStatus::Suspended => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_SUSPENDED,
RTSPMediaStatus::Error => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_ERROR, RTSPMediaStatus::Error => gst_rtsp_server_sys::GST_RTSP_MEDIA_STATUS_ERROR,
RTSPMediaStatus::__Unknown(value) => value RTSPMediaStatus::__Unknown(value) => value,
} }
} }
} }
@ -138,8 +137,7 @@ impl FromGlib<gst_rtsp_server_sys::GstRTSPMediaStatus> for RTSPMediaStatus {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPPublishClockMode { pub enum RTSPPublishClockMode {
None, None,
Clock, Clock,
@ -156,8 +154,10 @@ impl ToGlib for RTSPPublishClockMode {
match *self { match *self {
RTSPPublishClockMode::None => gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_NONE, RTSPPublishClockMode::None => gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_NONE,
RTSPPublishClockMode::Clock => gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK, RTSPPublishClockMode::Clock => gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK,
RTSPPublishClockMode::ClockAndOffset => gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET, RTSPPublishClockMode::ClockAndOffset => {
RTSPPublishClockMode::__Unknown(value) => value gst_rtsp_server_sys::GST_RTSP_PUBLISH_CLOCK_MODE_CLOCK_AND_OFFSET
}
RTSPPublishClockMode::__Unknown(value) => value,
} }
} }
} }
@ -199,8 +199,7 @@ impl SetValue for RTSPPublishClockMode {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPSuspendMode { pub enum RTSPSuspendMode {
None, None,
Pause, Pause,
@ -218,7 +217,7 @@ impl ToGlib for RTSPSuspendMode {
RTSPSuspendMode::None => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_NONE, RTSPSuspendMode::None => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_NONE,
RTSPSuspendMode::Pause => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_PAUSE, RTSPSuspendMode::Pause => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_PAUSE,
RTSPSuspendMode::Reset => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_RESET, RTSPSuspendMode::Reset => gst_rtsp_server_sys::GST_RTSP_SUSPEND_MODE_RESET,
RTSPSuspendMode::__Unknown(value) => value RTSPSuspendMode::__Unknown(value) => value,
} }
} }
} }
@ -260,8 +259,7 @@ impl SetValue for RTSPSuspendMode {
} }
} }
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[derive(Clone, Copy)]
pub enum RTSPThreadType { pub enum RTSPThreadType {
Client, Client,
Media, Media,
@ -277,7 +275,7 @@ impl ToGlib for RTSPThreadType {
match *self { match *self {
RTSPThreadType::Client => gst_rtsp_server_sys::GST_RTSP_THREAD_TYPE_CLIENT, RTSPThreadType::Client => gst_rtsp_server_sys::GST_RTSP_THREAD_TYPE_CLIENT,
RTSPThreadType::Media => gst_rtsp_server_sys::GST_RTSP_THREAD_TYPE_MEDIA, RTSPThreadType::Media => gst_rtsp_server_sys::GST_RTSP_THREAD_TYPE_MEDIA,
RTSPThreadType::__Unknown(value) => value RTSPThreadType::__Unknown(value) => value,
} }
} }
} }
@ -293,4 +291,3 @@ impl FromGlib<gst_rtsp_server_sys::GstRTSPThreadType> for RTSPThreadType {
} }
} }
} }

Some files were not shown because too many files have changed in this diff Show more