mirrors/gst-plugins-rs
mirrors/gst-plugins-rs
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git synced 2024-09-27 06:20:03 +00:00
Code Issues Projects Releases Wiki Activity

Make calls into the parent class struct safer and use more useful object wrapper type (T) for virtual methods

Browse source
This commit is contained in:
Sebastian Dröge 2017-09-26 01:43:56 +03:00
parent a354116336
commit 41d6343682
8 changed files with 189 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
gst-plugin/src/base_sink.rs
View file

@ -25,36 +25,32 @@ use gst_base::prelude::*;
use object::*; use object::*;
use element::*; use element::*;
pub trait BaseSinkImpl<T: ObjectType> pub trait BaseSinkImpl<T: BaseSink>
: mopa::Any + ObjectImpl<T> + ElementImpl<T> + Send + Sync + 'static { : mopa::Any + ObjectImpl<T> + ElementImpl<T> + Send + Sync + 'static {
fn start(&self, _element: &gst_base::BaseSink) -> bool { fn start(&self, _element: &T) -> bool {
true true
} }
fn stop(&self, _element: &gst_base::BaseSink) -> bool { fn stop(&self, _element: &T) -> bool {
true true
} }
fn render(&self, element: &gst_base::BaseSink, buffer: &gst::BufferRef) -> gst::FlowReturn; fn render(&self, element: &T, buffer: &gst::BufferRef) -> gst::FlowReturn;
fn query(&self, element: &gst_base::BaseSink, query: &mut gst::QueryRef) -> bool { fn query(&self, element: &T, query: &mut gst::QueryRef) -> bool {
element.parent_query(query) element.parent_query(query)
} }
fn event(&self, element: &gst_base::BaseSink, event: &gst::Event) -> bool { fn event(&self, element: &T, event: &gst::Event) -> bool {
element.parent_event(event) element.parent_event(event)
} }
} }
mopafy_object_impl!(BaseSinkImpl); mopafy_object_impl!(BaseSink, BaseSinkImpl);
pub unsafe trait BaseSink: IsA<gst_base::BaseSink> { pub unsafe trait BaseSink
: IsA<gst::Element> + IsA<gst_base::BaseSink> + ObjectType {
fn parent_query(&self, query: &mut gst::QueryRef) -> bool { fn parent_query(&self, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_base_ffi::GstBaseSinkClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_base_ffi::GstBaseSinkClass);
parent_klass
.query .query
.map(|f| from_glib(f(self.to_glib_none().0, query.as_mut_ptr()))) .map(|f| from_glib(f(self.to_glib_none().0, query.as_mut_ptr())))
.unwrap_or(false) .unwrap_or(false)
@ -63,14 +59,9 @@ pub unsafe trait BaseSink: IsA<gst_base::BaseSink> {
fn parent_event(&self, event: &gst::Event) -> bool { fn parent_event(&self, event: &gst::Event) -> bool {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_base_ffi::GstBaseSinkClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_base_ffi::GstBaseSinkClass);
parent_klass
.event .event
.map(|f| { .map(|f| {
from_glib(f(self.to_glib_none().0, event.to_glib_none().0)) from_glib(f(self.to_glib_none().0, event.to_glib_none().0))
@ -80,9 +71,8 @@ pub unsafe trait BaseSink: IsA<gst_base::BaseSink> {
} }
} }
pub unsafe trait BaseSinkClass<T: ObjectType> pub unsafe trait BaseSinkClass<T: BaseSink>
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
fn override_vfuncs(&mut self) { fn override_vfuncs(&mut self) {
@ -107,7 +97,7 @@ glib_wrapper! {
} }
} }
unsafe impl<T: IsA<gst_base::BaseSink>> BaseSink for T {} unsafe impl<T: IsA<gst::Element> + IsA<gst_base::BaseSink> + ObjectType> BaseSink for T {}
pub type RsBaseSinkClass = ClassStruct<RsBaseSink>; pub type RsBaseSinkClass = ClassStruct<RsBaseSink>;
// FIXME: Boilerplate // FIXME: Boilerplate
@ -119,27 +109,27 @@ macro_rules! box_base_sink_impl(
($name:ident) => { ($name:ident) => {
box_element_impl!($name); box_element_impl!($name);
impl<T: ObjectType> BaseSinkImpl<T> for Box<$name<T>> { impl<T: BaseSink> BaseSinkImpl<T> for Box<$name<T>> {
fn start(&self, element: &gst_base::BaseSink) -> bool { fn start(&self, element: &T) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.start(element) imp.start(element)
} }
fn stop(&self, element: &gst_base::BaseSink) -> bool { fn stop(&self, element: &T) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.stop(element) imp.stop(element)
} }
fn render(&self, element: &gst_base::BaseSink, buffer: &gst::BufferRef) -> gst::FlowReturn { fn render(&self, element: &T, buffer: &gst::BufferRef) -> gst::FlowReturn {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.render(element, buffer) imp.render(element, buffer)
} }
fn query(&self, element: &gst_base::BaseSink, query: &mut gst::QueryRef) -> bool { fn query(&self, element: &T, query: &mut gst::QueryRef) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.query(element, query) imp.query(element, query)
} }
fn event(&self, element: &gst_base::BaseSink, event: &gst::Event) -> bool { fn event(&self, element: &T, event: &gst::Event) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.event(element, event) imp.event(element, event)
} }
@ -163,52 +153,51 @@ impl ObjectType for RsBaseSink {
ElementClass::override_vfuncs(klass); ElementClass::override_vfuncs(klass);
BaseSinkClass::override_vfuncs(klass); BaseSinkClass::override_vfuncs(klass);
} }
object_type_fns!();
} }
unsafe extern "C" fn base_sink_start<T: ObjectType>( unsafe extern "C" fn base_sink_start<T: BaseSink>(
ptr: *mut gst_base_ffi::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSink = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
} }
unsafe extern "C" fn base_sink_stop<T: ObjectType>( unsafe extern "C" fn base_sink_stop<T: BaseSink>(
ptr: *mut gst_base_ffi::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSink = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
} }
unsafe extern "C" fn base_sink_render<T: ObjectType>( unsafe extern "C" fn base_sink_render<T: BaseSink>(
ptr: *mut gst_base_ffi::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
buffer: *mut gst_ffi::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst_ffi::GstFlowReturn ) -> gst_ffi::GstFlowReturn
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSink = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
let buffer = gst::BufferRef::from_ptr(buffer); let buffer = gst::BufferRef::from_ptr(buffer);
@ -217,36 +206,34 @@ where
}).to_glib() }).to_glib()
} }
unsafe extern "C" fn base_sink_query<T: ObjectType>( unsafe extern "C" fn base_sink_query<T: BaseSink>(
ptr: *mut gst_base_ffi::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
query_ptr: *mut gst_ffi::GstQuery, query_ptr: *mut gst_ffi::GstQuery,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSink = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
let query = gst::QueryRef::from_mut_ptr(query_ptr); let query = gst::QueryRef::from_mut_ptr(query_ptr);
panic_to_error!(&wrap, &element.panicked, false, { imp.query(&wrap, query) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.query(&wrap, query) }).to_glib()
} }
unsafe extern "C" fn base_sink_event<T: ObjectType>( unsafe extern "C" fn base_sink_event<T: BaseSink>(
ptr: *mut gst_base_ffi::GstBaseSink, ptr: *mut gst_base_ffi::GstBaseSink,
event_ptr: *mut gst_ffi::GstEvent, event_ptr: *mut gst_ffi::GstEvent,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSink>,
T::ImplType: BaseSinkImpl<T>, T::ImplType: BaseSinkImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSink = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { panic_to_error!(&wrap, &element.panicked, false, {

121
gst-plugin/src/base_src.rs
View file

@ -25,51 +25,47 @@ use gst_base::prelude::*;
use object::*; use object::*;
use element::*; use element::*;
pub trait BaseSrcImpl<T: ObjectType> pub trait BaseSrcImpl<T: BaseSrc>
: mopa::Any + ObjectImpl<T> + ElementImpl<T> + Send + Sync + 'static { : mopa::Any + ObjectImpl<T> + ElementImpl<T> + Send + Sync + 'static {
fn start(&self, _element: &gst_base::BaseSrc) -> bool { fn start(&self, _element: &T) -> bool {
true true
} }
fn stop(&self, _element: &gst_base::BaseSrc) -> bool { fn stop(&self, _element: &T) -> bool {
true true
} }
fn is_seekable(&self, _element: &gst_base::BaseSrc) -> bool { fn is_seekable(&self, _element: &T) -> bool {
false false
} }
fn get_size(&self, _element: &gst_base::BaseSrc) -> Option<u64> { fn get_size(&self, _element: &T) -> Option<u64> {
None None
} }
fn fill( fn fill(
&self, &self,
element: &gst_base::BaseSrc, element: &T,
offset: u64, offset: u64,
length: u32, length: u32,
buffer: &mut gst::BufferRef, buffer: &mut gst::BufferRef,
) -> gst::FlowReturn; ) -> gst::FlowReturn;
fn do_seek(&self, element: &gst_base::BaseSrc, segment: &mut gst::Segment) -> bool { fn do_seek(&self, element: &T, segment: &mut gst::Segment) -> bool {
element.parent_do_seek(segment) element.parent_do_seek(segment)
} }
fn query(&self, element: &gst_base::BaseSrc, query: &mut gst::QueryRef) -> bool { fn query(&self, element: &T, query: &mut gst::QueryRef) -> bool {
element.parent_query(query) element.parent_query(query)
} }
fn event(&self, element: &gst_base::BaseSrc, event: &gst::Event) -> bool { fn event(&self, element: &T, event: &gst::Event) -> bool {
element.parent_event(event) element.parent_event(event)
} }
} }
mopafy_object_impl!(BaseSrcImpl); mopafy_object_impl!(BaseSrc, BaseSrcImpl);
pub unsafe trait BaseSrc: IsA<gst_base::BaseSrc> { pub unsafe trait BaseSrc
: IsA<gst::Element> + IsA<gst_base::BaseSrc> + ObjectType {
fn parent_do_seek(&self, segment: &mut gst::Segment) -> bool { fn parent_do_seek(&self, segment: &mut gst::Segment) -> bool {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_base_ffi::GstBaseSrcClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_base_ffi::GstBaseSrcClass);
parent_klass
.do_seek .do_seek
.map(|f| { .map(|f| {
from_glib(f(self.to_glib_none().0, segment.to_glib_none_mut().0)) from_glib(f(self.to_glib_none().0, segment.to_glib_none_mut().0))
@ -80,14 +76,9 @@ pub unsafe trait BaseSrc: IsA<gst_base::BaseSrc> {
fn parent_query(&self, query: &mut gst::QueryRef) -> bool { fn parent_query(&self, query: &mut gst::QueryRef) -> bool {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_base_ffi::GstBaseSrcClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_base_ffi::GstBaseSrcClass);
parent_klass
.query .query
.map(|f| from_glib(f(self.to_glib_none().0, query.as_mut_ptr()))) .map(|f| from_glib(f(self.to_glib_none().0, query.as_mut_ptr())))
.unwrap_or(false) .unwrap_or(false)
@ -96,14 +87,9 @@ pub unsafe trait BaseSrc: IsA<gst_base::BaseSrc> {
fn parent_event(&self, event: &gst::Event) -> bool { fn parent_event(&self, event: &gst::Event) -> bool {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_base_ffi::GstBaseSrcClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_base_ffi::GstBaseSrcClass);
parent_klass
.event .event
.map(|f| { .map(|f| {
from_glib(f(self.to_glib_none().0, event.to_glib_none().0)) from_glib(f(self.to_glib_none().0, event.to_glib_none().0))
@ -113,9 +99,8 @@ pub unsafe trait BaseSrc: IsA<gst_base::BaseSrc> {
} }
} }
pub unsafe trait BaseSrcClass<T: ObjectType> pub unsafe trait BaseSrcClass<T: BaseSrc>
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
fn override_vfuncs(&mut self) { fn override_vfuncs(&mut self) {
@ -144,7 +129,7 @@ glib_wrapper! {
} }
// FIXME: This is wrong: it must be a basesrc but also backed by ObjectType<T> // FIXME: This is wrong: it must be a basesrc but also backed by ObjectType<T>
unsafe impl<T: IsA<gst_base::BaseSrc>> BaseSrc for T {} unsafe impl<T: IsA<gst::Element> + IsA<gst_base::BaseSrc> + ObjectType> BaseSrc for T {}
pub type RsBaseSrcClass = ClassStruct<RsBaseSrc>; pub type RsBaseSrcClass = ClassStruct<RsBaseSrc>;
// FIXME: Boilerplate // FIXME: Boilerplate
@ -156,30 +141,30 @@ macro_rules! box_base_src_impl(
($name:ident) => { ($name:ident) => {
box_element_impl!($name); box_element_impl!($name);
impl<T: ObjectType> BaseSrcImpl<T> for Box<$name<T>> { impl<T: BaseSrc> BaseSrcImpl<T> for Box<$name<T>> {
fn start(&self, element: &gst_base::BaseSrc) -> bool { fn start(&self, element: &T) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.start(element) imp.start(element)
} }
fn stop(&self, element: &gst_base::BaseSrc) -> bool { fn stop(&self, element: &T) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.stop(element) imp.stop(element)
} }
fn is_seekable(&self, element: &gst_base::BaseSrc) -> bool { fn is_seekable(&self, element: &T) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.is_seekable(element) imp.is_seekable(element)
} }
fn get_size(&self, element: &gst_base::BaseSrc) -> Option<u64> { fn get_size(&self, element: &T) -> Option<u64> {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.get_size(element) imp.get_size(element)
} }
fn fill( fn fill(
&self, &self,
element: &gst_base::BaseSrc, element: &T,
offset: u64, offset: u64,
length: u32, length: u32,
buffer: &mut gst::BufferRef, buffer: &mut gst::BufferRef,
@ -188,16 +173,16 @@ macro_rules! box_base_src_impl(
imp.fill(element, offset, length, buffer) imp.fill(element, offset, length, buffer)
} }
fn do_seek(&self, element: &gst_base::BaseSrc, segment: &mut gst::Segment) -> bool { fn do_seek(&self, element: &T, segment: &mut gst::Segment) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.do_seek(element, segment) imp.do_seek(element, segment)
} }
fn query(&self, element: &gst_base::BaseSrc, query: &mut gst::QueryRef) -> bool { fn query(&self, element: &T, query: &mut gst::QueryRef) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.query(element, query) imp.query(element, query)
} }
fn event(&self, element: &gst_base::BaseSrc, event: &gst::Event) -> bool { fn event(&self, element: &T, event: &gst::Event) -> bool {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
imp.event(element, event) imp.event(element, event)
} }
@ -220,68 +205,66 @@ impl ObjectType for RsBaseSrc {
ElementClass::override_vfuncs(klass); ElementClass::override_vfuncs(klass);
BaseSrcClass::override_vfuncs(klass); BaseSrcClass::override_vfuncs(klass);
} }
object_type_fns!();
} }
unsafe extern "C" fn base_src_start<T: ObjectType>( unsafe extern "C" fn base_src_start<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
} }
unsafe extern "C" fn base_src_stop<T: ObjectType>( unsafe extern "C" fn base_src_stop<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
} }
unsafe extern "C" fn base_src_is_seekable<T: ObjectType>( unsafe extern "C" fn base_src_is_seekable<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { imp.is_seekable(&wrap) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.is_seekable(&wrap) }).to_glib()
} }
unsafe extern "C" fn base_src_get_size<T: ObjectType>( unsafe extern "C" fn base_src_get_size<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
size: *mut u64, size: *mut u64,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { panic_to_error!(&wrap, &element.panicked, false, {
@ -295,20 +278,19 @@ where
}).to_glib() }).to_glib()
} }
unsafe extern "C" fn base_src_fill<T: ObjectType>( unsafe extern "C" fn base_src_fill<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
offset: u64, offset: u64,
length: u32, length: u32,
buffer: *mut gst_ffi::GstBuffer, buffer: *mut gst_ffi::GstBuffer,
) -> gst_ffi::GstFlowReturn ) -> gst_ffi::GstFlowReturn
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
let buffer = gst::BufferRef::from_mut_ptr(buffer); let buffer = gst::BufferRef::from_mut_ptr(buffer);
@ -317,18 +299,17 @@ where
}).to_glib() }).to_glib()
} }
unsafe extern "C" fn base_src_do_seek<T: ObjectType>( unsafe extern "C" fn base_src_do_seek<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
segment: *mut gst_ffi::GstSegment, segment: *mut gst_ffi::GstSegment,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { panic_to_error!(&wrap, &element.panicked, false, {
@ -336,36 +317,34 @@ where
}).to_glib() }).to_glib()
} }
unsafe extern "C" fn base_src_query<T: ObjectType>( unsafe extern "C" fn base_src_query<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
query_ptr: *mut gst_ffi::GstQuery, query_ptr: *mut gst_ffi::GstQuery,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
let query = gst::QueryRef::from_mut_ptr(query_ptr); let query = gst::QueryRef::from_mut_ptr(query_ptr);
panic_to_error!(&wrap, &element.panicked, false, { imp.query(&wrap, query) }).to_glib() panic_to_error!(&wrap, &element.panicked, false, { imp.query(&wrap, query) }).to_glib()
} }
unsafe extern "C" fn base_src_event<T: ObjectType>( unsafe extern "C" fn base_src_event<T: BaseSrc>(
ptr: *mut gst_base_ffi::GstBaseSrc, ptr: *mut gst_base_ffi::GstBaseSrc,
event_ptr: *mut gst_ffi::GstEvent, event_ptr: *mut gst_ffi::GstEvent,
) -> glib_ffi::gboolean ) -> glib_ffi::gboolean
where where
T: IsA<gst_base::BaseSrc>,
T::ImplType: BaseSrcImpl<T>, T::ImplType: BaseSrcImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst_base::BaseSrc = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, false, { panic_to_error!(&wrap, &element.panicked, false, {

2
gst-plugin/src/demuxer.rs
View file

@ -643,7 +643,7 @@ impl ObjectImpl<RsElement> for Demuxer {}
impl ElementImpl<RsElement> for Demuxer { impl ElementImpl<RsElement> for Demuxer {
fn change_state( fn change_state(
&self, &self,
element: &gst::Element, element: &RsElement,
transition: gst::StateChange, transition: gst::StateChange,
) -> gst::StateChangeReturn { ) -> gst::StateChangeReturn {
let mut ret = gst::StateChangeReturn::Success; let mut ret = gst::StateChangeReturn::Success;

49
gst-plugin/src/element.rs
View file

@ -21,30 +21,21 @@ use gst::prelude::*;
use object::*; use object::*;
pub trait ElementImpl<T: ObjectType> pub trait ElementImpl<T: Element>
: ObjectImpl<T> + mopa::Any + Send + Sync + 'static { : ObjectImpl<T> + mopa::Any + Send + Sync + 'static {
fn change_state( fn change_state(&self, element: &T, transition: gst::StateChange) -> gst::StateChangeReturn {
&self,
element: &gst::Element,
transition: gst::StateChange,
) -> gst::StateChangeReturn {
element.parent_change_state(transition) element.parent_change_state(transition)
} }
} }
mopafy_object_impl!(ElementImpl); mopafy_object_impl!(Element, ElementImpl);
pub unsafe trait Element: IsA<gst::Element> { pub unsafe trait Element: IsA<gst::Element> + ObjectType {
fn parent_change_state(&self, transition: gst::StateChange) -> gst::StateChangeReturn { fn parent_change_state(&self, transition: gst::StateChange) -> gst::StateChangeReturn {
unsafe { unsafe {
// Our class let klass = self.get_class();
let klass = *(self.to_glib_none().0 as *const glib_ffi::gpointer); let parent_klass = (*klass).get_parent_class() as *const gst_ffi::GstElementClass;
// The parent class, RsElement or any other first-level Rust implementation (*parent_klass)
let parent_klass = gobject_ffi::g_type_class_peek_parent(klass);
// The actual parent class as defined in C
let parent_klass = &*(gobject_ffi::g_type_class_peek_parent(parent_klass) as
*const gst_ffi::GstElementClass);
parent_klass
.change_state .change_state
.map(|f| { .map(|f| {
from_glib(f(self.to_glib_none().0, transition.to_glib())) from_glib(f(self.to_glib_none().0, transition.to_glib()))
@ -54,9 +45,8 @@ pub unsafe trait Element: IsA<gst::Element> {
} }
} }
pub unsafe trait ElementClass<T: ObjectType> pub unsafe trait ElementClass<T: Element>
where where
T: IsA<gst::Element>,
T::ImplType: ElementImpl<T>, T::ImplType: ElementImpl<T>,
{ {
fn add_pad_template(&mut self, pad_template: gst::PadTemplate) { fn add_pad_template(&mut self, pad_template: gst::PadTemplate) {
@ -103,17 +93,7 @@ glib_wrapper! {
} }
} }
impl RsElement { unsafe impl<T: IsA<gst::Element> + ObjectType> Element for T {}
pub fn get_impl(&self) -> &ElementImpl<RsElement> {
unsafe {
let stash = self.to_glib_none();
let ptr: *mut InstanceStruct<RsElement> = stash.0;
(*ptr).get_impl().as_ref()
}
}
}
unsafe impl<T: IsA<gst::Element>> Element for T {}
pub type RsElementClass = ClassStruct<RsElement>; pub type RsElementClass = ClassStruct<RsElement>;
// FIXME: Boilerplate // FIXME: Boilerplate
@ -124,10 +104,10 @@ macro_rules! box_element_impl(
($name:ident) => { ($name:ident) => {
box_object_impl!($name); box_object_impl!($name);
impl<T: ObjectType> ElementImpl<T> for Box<$name<T>> { impl<T: Element> ElementImpl<T> for Box<$name<T>> {
fn change_state( fn change_state(
&self, &self,
element: &gst::Element, element: &T,
transition: gst::StateChange, transition: gst::StateChange,
) -> gst::StateChangeReturn { ) -> gst::StateChangeReturn {
let imp: &$name<T> = self.as_ref(); let imp: &$name<T> = self.as_ref();
@ -152,20 +132,21 @@ impl ObjectType for RsElement {
fn class_init(klass: &mut RsElementClass) { fn class_init(klass: &mut RsElementClass) {
klass.override_vfuncs(); klass.override_vfuncs();
} }
object_type_fns!();
} }
unsafe extern "C" fn element_change_state<T: ObjectType>( unsafe extern "C" fn element_change_state<T: Element>(
ptr: *mut gst_ffi::GstElement, ptr: *mut gst_ffi::GstElement,
transition: gst_ffi::GstStateChange, transition: gst_ffi::GstStateChange,
) -> gst_ffi::GstStateChangeReturn ) -> gst_ffi::GstStateChangeReturn
where where
T: IsA<gst::Element>,
T::ImplType: ElementImpl<T>, T::ImplType: ElementImpl<T>,
{ {
callback_guard!(); callback_guard!();
floating_reference_guard!(ptr); floating_reference_guard!(ptr);
let element = &*(ptr as *mut InstanceStruct<T>); let element = &*(ptr as *mut InstanceStruct<T>);
let wrap: gst::Element = from_glib_borrow(ptr); let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
let imp = &*element.imp; let imp = &*element.imp;
panic_to_error!(&wrap, &element.panicked, gst::StateChangeReturn::Failure, { panic_to_error!(&wrap, &element.panicked, gst::StateChangeReturn::Failure, {

5
gst-plugin/src/lib.rs
View file

@ -12,7 +12,6 @@ extern crate gstreamer_base_sys as gst_base_ffi;
#[macro_use] #[macro_use]
extern crate lazy_static; extern crate lazy_static;
extern crate libc; extern crate libc;
#[macro_use]
extern crate mopa; extern crate mopa;
extern crate url; extern crate url;
pub extern crate glib_sys as glib_ffi; pub extern crate glib_sys as glib_ffi;
@ -62,8 +61,8 @@ impl Drop for FloatingReferenceGuard {
// mopafy! macro to work with generic traits over T: ObjectType // mopafy! macro to work with generic traits over T: ObjectType
macro_rules! mopafy_object_impl { macro_rules! mopafy_object_impl {
($trait:ident) => { ($bound:ident, $trait:ident) => {
impl<T: ObjectType> $trait<T> { impl<T: $bound> $trait<T> {
#[inline] #[inline]
pub fn downcast_ref<U: $trait<T>>(&self) -> Option<&U> { pub fn downcast_ref<U: $trait<T>>(&self) -> Option<&U> {
if self.is::<U>() { if self.is::<U>() {

38
gst-plugin/src/object.rs
View file

@ -84,8 +84,27 @@ where
fn get_property(_obj: &Self, _id: u32) -> Result<glib::Value, ()> { fn get_property(_obj: &Self, _id: u32) -> Result<glib::Value, ()> {
unimplemented!() unimplemented!()
} }
unsafe fn get_instance(&self) -> *mut InstanceStruct<Self>;
fn get_impl(&self) -> &Self::ImplType {
unsafe { (*self.get_instance()).get_impl() }
}
unsafe fn get_class(&self) -> *const ClassStruct<Self> {
(*self.get_instance()).get_class()
}
} }
#[macro_export]
macro_rules! object_type_fns(
() => {
unsafe fn get_instance(&self) -> *mut InstanceStruct<Self> {
self.to_glib_none().0
}
}
);
#[repr(C)] #[repr(C)]
pub struct InstanceStruct<T: ObjectType> { pub struct InstanceStruct<T: ObjectType> {
pub parent: T::GlibType, pub parent: T::GlibType,
@ -97,15 +116,26 @@ impl<T: ObjectType> InstanceStruct<T> {
pub fn get_impl(&self) -> &T::ImplType { pub fn get_impl(&self) -> &T::ImplType {
unsafe { &*self.imp } unsafe { &*self.imp }
} }
pub unsafe fn get_class(&self) -> *const ClassStruct<T> {
*(self as *const _ as *const *const ClassStruct<T>)
}
} }
#[repr(C)] #[repr(C)]
pub struct ClassStruct<T: ObjectType> { pub struct ClassStruct<T: ObjectType> {
pub parent: T::GlibClassType, pub parent: T::GlibClassType,
pub imp_static: *const Box<ImplTypeStatic<T>>, pub imp_static: *const Box<ImplTypeStatic<T>>,
pub parent_class: *const T::GlibClassType,
pub interfaces_static: *const Vec<(glib_ffi::GType, glib_ffi::gpointer)>, pub interfaces_static: *const Vec<(glib_ffi::GType, glib_ffi::gpointer)>,
} }
impl<T: ObjectType> ClassStruct<T> {
pub unsafe fn get_parent_class(&self) -> *const T::GlibClassType {
self.parent_class
}
}
impl<T: ObjectType> ClassStruct<T> { impl<T: ObjectType> ClassStruct<T> {
pub fn get_interface_static(&self, type_: glib_ffi::GType) -> glib_ffi::gpointer { pub fn get_interface_static(&self, type_: glib_ffi::GType) -> glib_ffi::gpointer {
unsafe { unsafe {
@ -346,7 +376,13 @@ unsafe extern "C" fn class_init<T: ObjectType>(
gobject_klass.get_property = Some(get_property::<T>); gobject_klass.get_property = Some(get_property::<T>);
} }
T::class_init(&mut *(klass as *mut ClassStruct<T>)); {
let klass = &mut *(klass as *mut ClassStruct<T>);
klass.parent_class = gobject_ffi::g_type_class_peek_parent(
klass as *mut _ as glib_ffi::gpointer,
) as *const T::GlibClassType;
T::class_init(klass);
}
} }
unsafe extern "C" fn finalize<T: ObjectType>(obj: *mut gobject_ffi::GObject) { unsafe extern "C" fn finalize<T: ObjectType>(obj: *mut gobject_ffi::GObject) {

42
gst-plugin/src/sink.rs
View file

@ -158,10 +158,8 @@ impl ObjectImpl<RsBaseSink> for Sink {
impl ElementImpl<RsBaseSink> for Sink {} impl ElementImpl<RsBaseSink> for Sink {}
impl BaseSinkImpl<RsBaseSink> for Sink { impl BaseSinkImpl<RsBaseSink> for Sink {
fn start(&self, element: &gst_base::BaseSink) -> bool { fn start(&self, sink: &RsBaseSink) -> bool {
let sink = element.clone().downcast::<RsBaseSink>().unwrap(); gst_debug!(self.cat, obj: sink, "Starting");
gst_debug!(self.cat, obj: &sink, "Starting");
// Don't keep the URI locked while we call start later // Don't keep the URI locked while we call start later
let uri = match *self.uri.lock().unwrap() { let uri = match *self.uri.lock().unwrap() {
@ -170,62 +168,60 @@ impl BaseSinkImpl<RsBaseSink> for Sink {
uri.clone() uri.clone()
} }
(None, _) => { (None, _) => {
gst_error!(self.cat, obj: &sink, "No URI given"); gst_error!(self.cat, obj: sink, "No URI given");
error_msg!(gst::ResourceError::OpenRead, ["No URI given"]).post(&sink); error_msg!(gst::ResourceError::OpenRead, ["No URI given"]).post(sink);
return false; return false;
} }
}; };
let sink_impl = &mut self.imp.lock().unwrap(); let sink_impl = &mut self.imp.lock().unwrap();
match sink_impl.start(&sink, uri) { match sink_impl.start(sink, uri) {
Ok(..) => { Ok(..) => {
gst_trace!(self.cat, obj: &sink, "Started successfully"); gst_trace!(self.cat, obj: sink, "Started successfully");
true true
} }
Err(ref msg) => { Err(ref msg) => {
gst_error!(self.cat, obj: &sink, "Failed to start: {:?}", msg); gst_error!(self.cat, obj: sink, "Failed to start: {:?}", msg);
self.uri.lock().unwrap().1 = false; self.uri.lock().unwrap().1 = false;
msg.post(&sink); msg.post(sink);
false false
} }
} }
} }
fn stop(&self, element: &gst_base::BaseSink) -> bool { fn stop(&self, sink: &RsBaseSink) -> bool {
let sink = element.clone().downcast::<RsBaseSink>().unwrap();
let sink_impl = &mut self.imp.lock().unwrap(); let sink_impl = &mut self.imp.lock().unwrap();
gst_debug!(self.cat, obj: &sink, "Stopping"); gst_debug!(self.cat, obj: sink, "Stopping");
match sink_impl.stop(&sink) { match sink_impl.stop(sink) {
Ok(..) => { Ok(..) => {
gst_trace!(self.cat, obj: &sink, "Stopped successfully"); gst_trace!(self.cat, obj: sink, "Stopped successfully");
self.uri.lock().unwrap().1 = false; self.uri.lock().unwrap().1 = false;
true true
} }
Err(ref msg) => { Err(ref msg) => {
gst_error!(self.cat, obj: &sink, "Failed to stop: {:?}", msg); gst_error!(self.cat, obj: sink, "Failed to stop: {:?}", msg);
msg.post(&sink); msg.post(sink);
false false
} }
} }
} }
fn render(&self, element: &gst_base::BaseSink, buffer: &gst::BufferRef) -> gst::FlowReturn { fn render(&self, sink: &RsBaseSink, buffer: &gst::BufferRef) -> gst::FlowReturn {
let sink = element.clone().downcast::<RsBaseSink>().unwrap();
let sink_impl = &mut self.imp.lock().unwrap(); let sink_impl = &mut self.imp.lock().unwrap();
gst_trace!(self.cat, obj: &sink, "Rendering buffer {:?}", buffer,); gst_trace!(self.cat, obj: sink, "Rendering buffer {:?}", buffer,);
match sink_impl.render(&sink, buffer) { match sink_impl.render(sink, buffer) {
Ok(()) => gst::FlowReturn::Ok, Ok(()) => gst::FlowReturn::Ok,
Err(flow_error) => { Err(flow_error) => {
gst_error!(self.cat, obj: &sink, "Failed to render: {:?}", flow_error); gst_error!(self.cat, obj: sink, "Failed to render: {:?}", flow_error);
match flow_error { match flow_error {
FlowError::NotNegotiated(ref msg) | FlowError::Error(ref msg) => { FlowError::NotNegotiated(ref msg) | FlowError::Error(ref msg) => {
msg.post(&sink); msg.post(sink);
} }
_ => (), _ => (),
} }

67
gst-plugin/src/source.rs
View file

@ -172,10 +172,8 @@ impl ObjectImpl<RsBaseSrc> for Source {
impl ElementImpl<RsBaseSrc> for Source {} impl ElementImpl<RsBaseSrc> for Source {}
impl BaseSrcImpl<RsBaseSrc> for Source { impl BaseSrcImpl<RsBaseSrc> for Source {
fn start(&self, element: &gst_base::BaseSrc) -> bool { fn start(&self, src: &RsBaseSrc) -> bool {
let src = element.clone().downcast::<RsBaseSrc>().unwrap(); gst_debug!(self.cat, obj: src, "Starting");
gst_debug!(self.cat, obj: &src, "Starting");
// Don't keep the URI locked while we call start later // Don't keep the URI locked while we call start later
let uri = match *self.uri.lock().unwrap() { let uri = match *self.uri.lock().unwrap() {
@ -184,50 +182,49 @@ impl BaseSrcImpl<RsBaseSrc> for Source {
uri.clone() uri.clone()
} }
(None, _) => { (None, _) => {
gst_error!(self.cat, obj: &src, "No URI given"); gst_error!(self.cat, obj: src, "No URI given");
error_msg!(gst::ResourceError::OpenRead, ["No URI given"]).post(&src); error_msg!(gst::ResourceError::OpenRead, ["No URI given"]).post(src);
return false; return false;
} }
}; };
let source_impl = &mut self.imp.lock().unwrap(); let source_impl = &mut self.imp.lock().unwrap();
match source_impl.start(&src, uri) { match source_impl.start(src, uri) {
Ok(..) => { Ok(..) => {
gst_trace!(self.cat, obj: &src, "Started successfully"); gst_trace!(self.cat, obj: src, "Started successfully");
true true
} }
Err(ref msg) => { Err(ref msg) => {
gst_error!(self.cat, obj: &src, "Failed to start: {:?}", msg); gst_error!(self.cat, obj: src, "Failed to start: {:?}", msg);
self.uri.lock().unwrap().1 = false; self.uri.lock().unwrap().1 = false;
msg.post(&src); msg.post(src);
false false
} }
} }
} }
fn stop(&self, element: &gst_base::BaseSrc) -> bool { fn stop(&self, src: &RsBaseSrc) -> bool {
let src = element.clone().downcast::<RsBaseSrc>().unwrap();
let source_impl = &mut self.imp.lock().unwrap(); let source_impl = &mut self.imp.lock().unwrap();
gst_debug!(self.cat, obj: &src, "Stopping"); gst_debug!(self.cat, obj: src, "Stopping");
match source_impl.stop(&src) { match source_impl.stop(src) {
Ok(..) => { Ok(..) => {
gst_trace!(self.cat, obj: &src, "Stopped successfully"); gst_trace!(self.cat, obj: src, "Stopped successfully");
self.uri.lock().unwrap().1 = false; self.uri.lock().unwrap().1 = false;
true true
} }
Err(ref msg) => { Err(ref msg) => {
gst_error!(self.cat, obj: &src, "Failed to stop: {:?}", msg); gst_error!(self.cat, obj: src, "Failed to stop: {:?}", msg);
msg.post(&src); msg.post(src);
false false
} }
} }
} }
fn query(&self, element: &gst_base::BaseSrc, query: &mut gst::QueryRef) -> bool { fn query(&self, src: &RsBaseSrc, query: &mut gst::QueryRef) -> bool {
use gst::QueryView; use gst::QueryView;
match query.view_mut() { match query.view_mut() {
@ -239,35 +236,34 @@ impl BaseSrcImpl<RsBaseSrc> for Source {
_ => (), _ => (),
} }
element.parent_query(query) src.parent_query(query)
} }
fn fill( fn fill(
&self, &self,
element: &gst_base::BaseSrc, src: &RsBaseSrc,
offset: u64, offset: u64,
length: u32, length: u32,
buffer: &mut gst::BufferRef, buffer: &mut gst::BufferRef,
) -> gst::FlowReturn { ) -> gst::FlowReturn {
let src = element.clone().downcast::<RsBaseSrc>().unwrap();
let source_impl = &mut self.imp.lock().unwrap(); let source_impl = &mut self.imp.lock().unwrap();
gst_trace!( gst_trace!(
self.cat, self.cat,
obj: &src, obj: src,
"Filling buffer {:?} with offset {} and length {}", "Filling buffer {:?} with offset {} and length {}",
buffer, buffer,
offset, offset,
length length
); );
match source_impl.fill(&src, offset, length, buffer) { match source_impl.fill(src, offset, length, buffer) {
Ok(()) => gst::FlowReturn::Ok, Ok(()) => gst::FlowReturn::Ok,
Err(flow_error) => { Err(flow_error) => {
gst_error!(self.cat, obj: &src, "Failed to fill: {:?}", flow_error); gst_error!(self.cat, obj: src, "Failed to fill: {:?}", flow_error);
match flow_error { match flow_error {
FlowError::NotNegotiated(ref msg) | FlowError::Error(ref msg) => { FlowError::NotNegotiated(ref msg) | FlowError::Error(ref msg) => {
msg.post(&src); msg.post(src);
} }
_ => (), _ => (),
} }
@ -276,8 +272,7 @@ impl BaseSrcImpl<RsBaseSrc> for Source {
} }
} }
fn do_seek(&self, element: &gst_base::BaseSrc, segment: &mut gst::Segment) -> bool { fn do_seek(&self, src: &RsBaseSrc, segment: &mut gst::Segment) -> bool {
let src = element.clone().downcast::<RsBaseSrc>().unwrap();
let source_impl = &mut self.imp.lock().unwrap(); let source_impl = &mut self.imp.lock().unwrap();
let start = segment.get_start(); let start = segment.get_start();
@ -286,28 +281,26 @@ impl BaseSrcImpl<RsBaseSrc> for Source {
stop @ _ => Some(stop), stop @ _ => Some(stop),
}; };
gst_debug!(self.cat, obj: &src, "Seeking to {:?}-{:?}", start, stop); gst_debug!(self.cat, obj: src, "Seeking to {:?}-{:?}", start, stop);
match source_impl.seek(&src, start, stop) { match source_impl.seek(src, start, stop) {
Ok(..) => true, Ok(..) => true,
Err(ref msg) => { Err(ref msg) => {
gst_error!(self.cat, obj: &src, "Failed to seek {:?}", msg); gst_error!(self.cat, obj: src, "Failed to seek {:?}", msg);
msg.post(&src); msg.post(src);
false false
} }
} }
} }
fn is_seekable(&self, element: &gst_base::BaseSrc) -> bool { fn is_seekable(&self, src: &RsBaseSrc) -> bool {
let src = element.clone().downcast::<RsBaseSrc>().unwrap();
let source_impl = &self.imp.lock().unwrap(); let source_impl = &self.imp.lock().unwrap();
source_impl.is_seekable(&src) source_impl.is_seekable(src)
} }
fn get_size(&self, element: &gst_base::BaseSrc) -> Option<u64> { fn get_size(&self, src: &RsBaseSrc) -> Option<u64> {
let src = element.clone().downcast::<RsBaseSrc>().unwrap();
let source_impl = &self.imp.lock().unwrap(); let source_impl = &self.imp.lock().unwrap();
source_impl.get_size(&src) source_impl.get_size(src)
} }
} }