Add BaseTransform support

gst-plugin/src/base_transform.rs

@@ -0,0 +1,696 @@
+// Copyright (C) 2017 Sebastian Dröge <sebastian@centricular.com>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::ptr;
+use std::mem;
+
+use glib_ffi;
+use gobject_ffi;
+use gst_ffi;
+use gst_base_ffi;
+
+use glib;
+use glib::translate::*;
+use gst;
+use gst::prelude::*;
+use gst_base;
+use gst_base::prelude::*;
+
+use object::*;
+use element::*;
+use anyimpl::*;
+
+pub trait BaseTransformImpl<T: BaseTransform>
+    : AnyImpl + ObjectImpl<T> + ElementImpl<T> + Send + Sync + 'static {
+    fn start(&self, _element: &T) -> bool {
+        true
+    }
+
+    fn stop(&self, _element: &T) -> bool {
+        true
+    }
+
+    fn transform_caps(
+        &self,
+        element: &T,
+        direction: gst::PadDirection,
+        caps: gst::Caps,
+        filter: Option<&gst::Caps>,
+    ) -> gst::Caps {
+        element.parent_transform_caps(direction, caps, filter)
+    }
+
+    fn fixate_caps(
+        &self,
+        element: &T,
+        direction: gst::PadDirection,
+        caps: &gst::Caps,
+        othercaps: gst::Caps,
+    ) -> gst::Caps {
+        element.parent_fixate_caps(direction, caps, othercaps)
+    }
+
+    fn set_caps(&self, _element: &T, _incaps: &gst::Caps, _outcaps: &gst::Caps) -> bool {
+        true
+    }
+
+    fn accept_caps(&self, element: &T, direction: gst::PadDirection, caps: &gst::Caps) -> bool {
+        element.parent_accept_caps(direction, caps)
+    }
+
+    fn query(&self, element: &T, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool {
+        element.parent_query(direction, query)
+    }
+
+    fn transform_size(
+        &self,
+        element: &T,
+        direction: gst::PadDirection,
+        caps: &gst::Caps,
+        size: usize,
+        othercaps: &gst::Caps,
+    ) -> Option<usize> {
+        element.parent_transform_size(direction, caps, size, othercaps)
+    }
+
+    fn get_unit_size(&self, _element: &T, _caps: &gst::Caps) -> Option<usize> {
+        unimplemented!();
+    }
+
+    fn sink_event(&self, element: &T, event: gst::Event) -> bool {
+        element.parent_sink_event(event)
+    }
+
+    fn src_event(&self, element: &T, event: gst::Event) -> bool {
+        element.parent_src_event(event)
+    }
+
+    fn transform(
+        &self,
+        _element: &T,
+        _inbuf: &gst::Buffer,
+        _outbuf: &gst::Buffer,
+    ) -> gst::FlowReturn {
+        unimplemented!();
+    }
+
+    fn transform_ip(&self, _element: &T, _buf: &gst::Buffer) -> gst::FlowReturn {
+        unimplemented!();
+    }
+}
+
+any_impl!(BaseTransform, BaseTransformImpl);
+
+pub unsafe trait BaseTransform
+    : IsA<gst::Element> + IsA<gst_base::BaseTransform> + ObjectType {
+    fn parent_transform_caps(
+        &self,
+        direction: gst::PadDirection,
+        caps: gst::Caps,
+        filter: Option<&gst::Caps>,
+    ) -> gst::Caps {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            match (*parent_klass).transform_caps {
+                Some(f) => from_glib_full(f(
+                    self.to_glib_none().0,
+                    direction.to_glib(),
+                    caps.into_ptr(),
+                    filter.to_glib_none().0,
+                )),
+                None => caps,
+            }
+        }
+    }
+
+    fn parent_fixate_caps(
+        &self,
+        direction: gst::PadDirection,
+        caps: &gst::Caps,
+        othercaps: gst::Caps,
+    ) -> gst::Caps {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            match (*parent_klass).fixate_caps {
+                Some(f) => from_glib_full(f(
+                    self.to_glib_none().0,
+                    direction.to_glib(),
+                    caps.to_glib_none().0,
+                    othercaps.into_ptr(),
+                )),
+                None => othercaps,
+            }
+        }
+    }
+
+    fn parent_accept_caps(&self, direction: gst::PadDirection, caps: &gst::Caps) -> bool {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            (*parent_klass)
+                .accept_caps
+                .map(|f| {
+                    from_glib(f(
+                        self.to_glib_none().0,
+                        direction.to_glib(),
+                        caps.to_glib_none().0,
+                    ))
+                })
+                .unwrap_or(false)
+        }
+    }
+
+    fn parent_query(&self, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            (*parent_klass)
+                .query
+                .map(|f| {
+                    from_glib(f(
+                        self.to_glib_none().0,
+                        direction.to_glib(),
+                        query.as_mut_ptr(),
+                    ))
+                })
+                .unwrap_or(false)
+        }
+    }
+
+    fn parent_transform_size(
+        &self,
+        direction: gst::PadDirection,
+        caps: &gst::Caps,
+        size: usize,
+        othercaps: &gst::Caps,
+    ) -> Option<usize> {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            (*parent_klass)
+                .transform_size
+                .map(|f| {
+                    let mut othersize = 0;
+                    let res: bool = from_glib(f(
+                        self.to_glib_none().0,
+                        direction.to_glib(),
+                        caps.to_glib_none().0,
+                        size,
+                        othercaps.to_glib_none().0,
+                        &mut othersize,
+                    ));
+                    if res {
+                        Some(othersize)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or(None)
+        }
+    }
+
+    fn parent_sink_event(&self, event: gst::Event) -> bool {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            (*parent_klass)
+                .sink_event
+                .map(|f| from_glib(f(self.to_glib_none().0, event.into_ptr())))
+                .unwrap_or(false)
+        }
+    }
+
+    fn parent_src_event(&self, event: gst::Event) -> bool {
+        unsafe {
+            let klass = self.get_class();
+            let parent_klass =
+                (*klass).get_parent_class() as *const gst_base_ffi::GstBaseTransformClass;
+            (*parent_klass)
+                .src_event
+                .map(|f| from_glib(f(self.to_glib_none().0, event.into_ptr())))
+                .unwrap_or(false)
+        }
+    }
+}
+
+pub enum BaseTransformMode {
+    AlwaysInPlace,
+    NeverInPlace,
+    Both,
+}
+
+pub unsafe trait BaseTransformClass<T: BaseTransform>
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    fn configure(
+        &mut self,
+        mode: BaseTransformMode,
+        passthrough_on_same_caps: bool,
+        transform_ip_on_passthrough: bool,
+    ) {
+        unsafe {
+            let klass = &mut *(self as *const Self as *mut gst_base_ffi::GstBaseTransformClass);
+
+            klass.passthrough_on_same_caps = passthrough_on_same_caps.to_glib();
+            klass.transform_ip_on_passthrough = transform_ip_on_passthrough.to_glib();
+
+            match mode {
+                BaseTransformMode::AlwaysInPlace => {
+                    klass.transform_ip = Some(base_transform_transform_ip::<T>);
+                }
+                BaseTransformMode::NeverInPlace => {
+                    klass.transform = Some(base_transform_transform::<T>);
+                }
+                BaseTransformMode::Both => {
+                    klass.transform = Some(base_transform_transform::<T>);
+                    klass.transform_ip = Some(base_transform_transform_ip::<T>);
+                }
+            }
+        }
+    }
+
+    fn override_vfuncs(&mut self, _: &ClassInitToken) {
+        unsafe {
+            let klass = &mut *(self as *const Self as *mut gst_base_ffi::GstBaseTransformClass);
+            klass.start = Some(base_transform_start::<T>);
+            klass.stop = Some(base_transform_stop::<T>);
+            klass.transform_caps = Some(base_transform_transform_caps::<T>);
+            klass.fixate_caps = Some(base_transform_fixate_caps::<T>);
+            klass.set_caps = Some(base_transform_set_caps::<T>);
+            klass.accept_caps = Some(base_transform_accept_caps::<T>);
+            klass.query = Some(base_transform_query::<T>);
+            klass.transform_size = Some(base_transform_transform_size::<T>);
+            klass.get_unit_size = Some(base_transform_get_unit_size::<T>);
+            klass.sink_event = Some(base_transform_sink_event::<T>);
+            klass.src_event = Some(base_transform_src_event::<T>);
+        }
+    }
+}
+
+glib_wrapper! {
+    pub struct RsBaseTransform(Object<InstanceStruct<RsBaseTransform>>): [gst_base::BaseTransform => gst_base_ffi::GstBaseTransform,
+                                                              gst::Element => gst_ffi::GstElement,
+                                                              gst::Object => gst_ffi::GstObject];
+
+    match fn {
+        get_type => || get_type::<RsBaseTransform>(),
+    }
+}
+
+unsafe impl<T: IsA<gst::Element> + IsA<gst_base::BaseTransform> + ObjectType> BaseTransform for T {}
+pub type RsBaseTransformClass = ClassStruct<RsBaseTransform>;
+
+// FIXME: Boilerplate
+unsafe impl BaseTransformClass<RsBaseTransform> for RsBaseTransformClass {}
+unsafe impl ElementClass<RsBaseTransform> for RsBaseTransformClass {}
+
+#[macro_export]
+macro_rules! box_base_transform_impl(
+    ($name:ident) => {
+        box_element_impl!($name);
+
+        impl<T: BaseTransform> BaseTransformImpl<T> for Box<$name<T>> {
+            fn start(&self, element: &T) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.start(element)
+            }
+
+            fn stop(&self, element: &T) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.stop(element)
+            }
+
+            fn transform_caps(&self, element: &T, direction: gst::PadDirection, caps: gst::Caps, filter: Option<&gst::Caps>) -> gst::Caps {
+                let imp: &$name<T> = self.as_ref();
+                imp.transform_caps(element, direction, caps, filter)
+            }
+
+            fn fixate_caps(&self, element: &T, direction: gst::PadDirection, caps: &gst::Caps, othercaps: gst::Caps) -> gst::Caps {
+                let imp: &$name<T> = self.as_ref();
+                imp.fixate_caps(element, direction, caps, othercaps)
+            }
+
+            fn set_caps(&self, element: &T, incaps: &gst::Caps, outcaps: &gst::Caps) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.set_caps(element, incaps, outcaps)
+            }
+
+            fn accept_caps(&self, element: &T, direction: gst::PadDirection, caps: &gst::Caps) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.accept_caps(element, direction, caps)
+            }
+
+            fn query(&self, element: &T, direction: gst::PadDirection, query: &mut gst::QueryRef) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                BaseTransformImpl::query(imp, element, direction, query)
+            }
+
+            fn transform_size(&self, element: &T, direction: gst::PadDirection, caps: &gst::Caps, size: usize, othercaps: &gst::Caps) -> Option<usize> {
+                let imp: &$name<T> = self.as_ref();
+                imp.transform_size(element, direction, caps, size, othercaps)
+            }
+
+            fn get_unit_size(&self, element: &T, caps: &gst::Caps) -> Option<usize> {
+                let imp: &$name<T> = self.as_ref();
+                imp.get_unit_size(element, caps)
+            }
+
+            fn sink_event(&self, element: &T, event: gst::Event) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.sink_event(element, event)
+            }
+
+            fn src_event(&self, element: &T, event: gst::Event) -> bool {
+                let imp: &$name<T> = self.as_ref();
+                imp.src_event(element, event)
+            }
+
+            fn transform(&self, element: &T, inbuf: &gst::Buffer, outbuf: &gst::Buffer) -> gst::FlowReturn {
+                let imp: &$name<T> = self.as_ref();
+                imp.transform(element, inbuf, outbuf)
+            }
+
+            fn transform_ip(&self, element: &T, buf: &gst::Buffer) -> gst::FlowReturn {
+                let imp: &$name<T> = self.as_ref();
+                imp.transform_ip(element, buf)
+            }
+        }
+    };
+);
+box_base_transform_impl!(BaseTransformImpl);
+
+impl ObjectType for RsBaseTransform {
+    const NAME: &'static str = "RsBaseTransform";
+    type GlibType = gst_base_ffi::GstBaseTransform;
+    type GlibClassType = gst_base_ffi::GstBaseTransformClass;
+    type ImplType = Box<BaseTransformImpl<Self>>;
+
+    fn glib_type() -> glib::Type {
+        unsafe { from_glib(gst_base_ffi::gst_base_transform_get_type()) }
+    }
+
+    fn class_init(token: &ClassInitToken, klass: &mut RsBaseTransformClass) {
+        ElementClass::override_vfuncs(klass, token);
+        BaseTransformClass::override_vfuncs(klass, token);
+    }
+
+    object_type_fns!();
+}
+
+unsafe extern "C" fn base_transform_start<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, { imp.start(&wrap) }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_stop<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, { imp.stop(&wrap) }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_transform_caps<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    direction: gst_ffi::GstPadDirection,
+    caps: *mut gst_ffi::GstCaps,
+    filter: *mut gst_ffi::GstCaps,
+) -> *mut gst_ffi::GstCaps
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
+        let filter = if filter.is_null() {
+            None
+        } else {
+            Some(from_glib_borrow(filter))
+        };
+
+
+        imp.transform_caps(
+            &wrap,
+            from_glib(direction),
+            from_glib_full(caps),
+            filter.as_ref(),
+        )
+    }).into_ptr()
+}
+
+unsafe extern "C" fn base_transform_fixate_caps<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    direction: gst_ffi::GstPadDirection,
+    caps: *mut gst_ffi::GstCaps,
+    othercaps: *mut gst_ffi::GstCaps,
+) -> *mut gst_ffi::GstCaps
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, gst::Caps::new_empty(), {
+        imp.fixate_caps(
+            &wrap,
+            from_glib(direction),
+            &from_glib_borrow(caps),
+            from_glib_full(othercaps),
+        )
+    }).into_ptr()
+}
+
+unsafe extern "C" fn base_transform_set_caps<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    incaps: *mut gst_ffi::GstCaps,
+    outcaps: *mut gst_ffi::GstCaps,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        imp.set_caps(&wrap, &from_glib_borrow(incaps), &from_glib_borrow(outcaps))
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_accept_caps<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    direction: gst_ffi::GstPadDirection,
+    caps: *mut gst_ffi::GstCaps,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        imp.accept_caps(&wrap, from_glib(direction), &from_glib_borrow(caps))
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_query<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    direction: gst_ffi::GstPadDirection,
+    query: *mut gst_ffi::GstQuery,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        BaseTransformImpl::query(
+            imp,
+            &wrap,
+            from_glib(direction),
+            gst::QueryRef::from_mut_ptr(query),
+        )
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_transform_size<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    direction: gst_ffi::GstPadDirection,
+    caps: *mut gst_ffi::GstCaps,
+    size: usize,
+    othercaps: *mut gst_ffi::GstCaps,
+    othersize: *mut usize,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        match imp.transform_size(
+            &wrap,
+            from_glib(direction),
+            &from_glib_borrow(caps),
+            size,
+            &from_glib_borrow(othercaps),
+        ) {
+            Some(s) => {
+                *othersize = s;
+                true
+            }
+            None => false,
+        }
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_get_unit_size<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    caps: *mut gst_ffi::GstCaps,
+    size: *mut usize,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        match imp.get_unit_size(&wrap, &from_glib_borrow(caps)) {
+            Some(s) => {
+                *size = s;
+                true
+            }
+            None => false,
+        }
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_sink_event<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    event: *mut gst_ffi::GstEvent,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        imp.sink_event(&wrap, from_glib_full(event))
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_src_event<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    event: *mut gst_ffi::GstEvent,
+) -> glib_ffi::gboolean
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, false, {
+        imp.src_event(&wrap, from_glib_full(event))
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_transform<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    inbuf: *mut gst_ffi::GstBuffer,
+    outbuf: *mut gst_ffi::GstBuffer,
+) -> gst_ffi::GstFlowReturn
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
+        imp.transform(&wrap, &from_glib_borrow(inbuf), &from_glib_borrow(outbuf))
+    }).to_glib()
+}
+
+unsafe extern "C" fn base_transform_transform_ip<T: BaseTransform>(
+    ptr: *mut gst_base_ffi::GstBaseTransform,
+    buf: *mut *mut gst_ffi::GstBuffer,
+) -> gst_ffi::GstFlowReturn
+where
+    T::ImplType: BaseTransformImpl<T>,
+{
+    callback_guard!();
+    floating_reference_guard!(ptr);
+    let element = &*(ptr as *mut InstanceStruct<T>);
+    let wrap: T = from_glib_borrow(ptr as *mut InstanceStruct<T>);
+    let imp = &*element.imp;
+
+    // FIXME: Wrong signature in FFI
+    let buf = buf as *mut gst_ffi::GstBuffer;
+
+    panic_to_error!(&wrap, &element.panicked, gst::FlowReturn::Error, {
+        imp.transform_ip(&wrap, &from_glib_borrow(buf))
+    }).to_glib()
+}

gst-plugin/src/lib.rs

@@ -79,4 +79,6 @@ pub mod element;
 pub mod base_src;
 #[macro_use]
 pub mod base_sink;
+#[macro_use]
+pub mod base_transform;
 pub mod uri_handler;