gstreamer-rs/gstreamer/src/pad.rs

// 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 Pad;
use PadProbeType;
use PadProbeReturn;
use Buffer;
use BufferList;
use FlowReturn;
use Query;
use QueryRef;
use Event;
use miniobject::MiniObject;

use std::mem::transmute;
use std::ptr;
use std::mem;
use std::cell::RefCell;

use glib;
use glib::{IsA, StaticType};
use glib::translate::{from_glib, from_glib_borrow, from_glib_full, from_glib_none, FromGlib,
                      ToGlib, ToGlibPtr};
use glib::source::CallbackGuard;
use glib_ffi;
use glib_ffi::gpointer;
use glib::Object;

use libc;

use ffi;

#[derive(Debug, Default, PartialEq, Eq)]
pub struct PadProbeId(libc::c_ulong);
pub const PAD_PROBE_ID_INVALID: PadProbeId = PadProbeId(0);

impl ToGlib for PadProbeId {
    type GlibType = libc::c_ulong;

    fn to_glib(&self) -> libc::c_ulong {
        self.0
    }
}

impl FromGlib<libc::c_ulong> for PadProbeId {
    fn from_glib(val: libc::c_ulong) -> PadProbeId {
        skip_assert_initialized!();
        PadProbeId(val)
    }
}

pub struct PadProbeInfo<'a> {
    pub mask: PadProbeType,
    pub id: PadProbeId,
    pub offset: u64,
    pub size: u32,
    pub data: Option<PadProbeData<'a>>,
}

pub enum PadProbeData<'a> {
    Buffer(Buffer),
    BufferList(BufferList),
    Query(&'a mut QueryRef),
    Event(Event),
    Unknown,
}

pub struct StreamLock(Pad);
impl Drop for StreamLock {
    fn drop(&mut self) {
        unsafe {
            let pad: *mut ffi::GstPad = self.0.to_glib_none().0;
            glib_ffi::g_rec_mutex_unlock(&mut (*pad).stream_rec_lock);
        }
    }
}

pub trait PadExtManual {
    fn add_probe<F>(&self, mask: PadProbeType, func: F) -> PadProbeId
    where
        F: Fn(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static;
    fn remove_probe(&self, id: PadProbeId);

    fn chain(&self, buffer: Buffer) -> FlowReturn;
    fn push(&self, buffer: Buffer) -> FlowReturn;

    fn chain_list(&self, list: BufferList) -> FlowReturn;
    fn push_list(&self, list: BufferList) -> FlowReturn;

    fn pull_range(&self, offset: u64, size: u32) -> Result<Buffer, FlowReturn>;
    fn get_range(&self, offset: u64, size: u32) -> Result<Buffer, FlowReturn>;

    fn peer_query(&self, query: &mut QueryRef) -> bool;
    fn query(&self, query: &mut QueryRef) -> bool;
    fn query_default<'a, P: IsA<Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
        query: &mut QueryRef,
    ) -> bool;
    fn proxy_query_caps(&self, query: &mut QueryRef) -> bool;
    fn proxy_query_accept_caps(&self, query: &mut QueryRef) -> bool;

    fn event_default<'a, P: IsA<::Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
        event: Event,
    ) -> bool;
    fn push_event(&self, event: Event) -> bool;
    fn send_event(&self, event: Event) -> bool;

    fn iterate_internal_links(&self) -> ::Iterator<Pad>;
    fn iterate_internal_links_default<'a, P: IsA<::Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
    ) -> ::Iterator<Pad>;

    fn stream_lock(&self) -> StreamLock;

    fn set_activate_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) -> bool + Send + Sync + 'static;

    fn set_activatemode_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::PadMode, bool) -> bool + Send + Sync + 'static;

    fn set_chain_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Buffer) -> ::FlowReturn + Send + Sync + 'static;

    fn set_chain_list_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::BufferList) -> ::FlowReturn + Send + Sync + 'static;

    fn set_event_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Event) -> bool + Send + Sync + 'static;

    fn set_event_full_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Event) -> ::FlowReturn + Send + Sync + 'static;

    fn set_getrange_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, u64, u32)
            -> Result<::Buffer, ::FlowReturn>
            + Send
            + Sync
            + 'static;

    fn set_iterate_internal_links_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) -> ::Iterator<Pad> + Send + Sync + 'static;

    fn set_link_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, &Pad) -> ::PadLinkReturn + Send + Sync + 'static;

    fn set_query_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, &mut ::QueryRef) -> bool + Send + Sync + 'static;

    fn set_unlink_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) + Send + Sync + 'static;

    fn start_task<F: FnMut() + Send + 'static>(&self, func: F) -> Result<(), glib::BoolError>;
}

impl<O: IsA<Pad>> PadExtManual for O {
    fn add_probe<F>(&self, mask: PadProbeType, func: F) -> PadProbeId
    where
        F: Fn(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static,
            > = Box::new(func);
            let id = ffi::gst_pad_add_probe(
                self.to_glib_none().0,
                mask.to_glib(),
                Some(trampoline_pad_probe),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );

            from_glib(id)
        }
    }

    fn remove_probe(&self, id: PadProbeId) {
        unsafe {
            ffi::gst_pad_remove_probe(self.to_glib_none().0, id.to_glib());
        }
    }

    fn chain(&self, buffer: Buffer) -> FlowReturn {
        unsafe { from_glib(ffi::gst_pad_chain(self.to_glib_none().0, buffer.into_ptr())) }
    }

    fn push(&self, buffer: Buffer) -> FlowReturn {
        unsafe { from_glib(ffi::gst_pad_push(self.to_glib_none().0, buffer.into_ptr())) }
    }

    fn chain_list(&self, list: BufferList) -> FlowReturn {
        unsafe {
            from_glib(ffi::gst_pad_chain_list(
                self.to_glib_none().0,
                list.into_ptr(),
            ))
        }
    }

    fn push_list(&self, list: BufferList) -> FlowReturn {
        unsafe {
            from_glib(ffi::gst_pad_push_list(
                self.to_glib_none().0,
                list.into_ptr(),
            ))
        }
    }

    fn get_range(&self, offset: u64, size: u32) -> Result<Buffer, FlowReturn> {
        unsafe {
            let mut buffer = ptr::null_mut();
            let ret = from_glib(ffi::gst_pad_get_range(
                self.to_glib_none().0,
                offset,
                size,
                &mut buffer,
            ));
            if ret == FlowReturn::Ok {
                Ok(from_glib_full(buffer))
            } else {
                Err(ret)
            }
        }
    }

    fn pull_range(&self, offset: u64, size: u32) -> Result<Buffer, FlowReturn> {
        unsafe {
            let mut buffer = ptr::null_mut();
            let ret = from_glib(ffi::gst_pad_pull_range(
                self.to_glib_none().0,
                offset,
                size,
                &mut buffer,
            ));
            if ret == FlowReturn::Ok {
                Ok(from_glib_full(buffer))
            } else {
                Err(ret)
            }
        }
    }

    fn query(&self, query: &mut QueryRef) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_query(
                self.to_glib_none().0,
                query.as_mut_ptr(),
            ))
        }
    }

    fn peer_query(&self, query: &mut QueryRef) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_peer_query(
                self.to_glib_none().0,
                query.as_mut_ptr(),
            ))
        }
    }

    fn query_default<'a, P: IsA<Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
        query: &mut QueryRef,
    ) -> bool {
        skip_assert_initialized!();
        let parent = parent.into();
        let parent = parent.to_glib_none();
        unsafe {
            from_glib(ffi::gst_pad_query_default(
                self.to_glib_none().0,
                parent.0 as *mut _,
                query.as_mut_ptr(),
            ))
        }
    }

    fn proxy_query_accept_caps(&self, query: &mut QueryRef) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_proxy_query_accept_caps(
                self.to_glib_none().0,
                query.as_mut_ptr(),
            ))
        }
    }

    fn proxy_query_caps(&self, query: &mut QueryRef) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_proxy_query_accept_caps(
                self.to_glib_none().0,
                query.as_mut_ptr(),
            ))
        }
    }

    fn event_default<'a, P: IsA<::Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
        event: Event,
    ) -> bool {
        skip_assert_initialized!();
        let parent = parent.into();
        let parent = parent.to_glib_none();
        unsafe {
            from_glib(ffi::gst_pad_event_default(
                self.to_glib_none().0,
                parent.0,
                event.into_ptr(),
            ))
        }
    }

    fn push_event(&self, event: Event) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_push_event(
                self.to_glib_none().0,
                event.into_ptr(),
            ))
        }
    }

    fn send_event(&self, event: Event) -> bool {
        unsafe {
            from_glib(ffi::gst_pad_send_event(
                self.to_glib_none().0,
                event.into_ptr(),
            ))
        }
    }

    fn iterate_internal_links(&self) -> ::Iterator<Pad> {
        unsafe { from_glib_full(ffi::gst_pad_iterate_internal_links(self.to_glib_none().0)) }
    }

    fn iterate_internal_links_default<'a, P: IsA<::Object> + 'a, Q: Into<Option<&'a P>>>(
        &self,
        parent: Q,
    ) -> ::Iterator<Pad> {
        let parent = parent.into();
        let parent = parent.to_glib_none();
        unsafe {
            from_glib_full(ffi::gst_pad_iterate_internal_links_default(
                self.to_glib_none().0,
                parent.0,
            ))
        }
    }

    fn stream_lock(&self) -> StreamLock {
        unsafe {
            let pad = self.to_glib_none().0;
            glib_ffi::g_rec_mutex_lock(&mut (*pad).stream_rec_lock);
            StreamLock(from_glib_none(pad))
        }
    }

    fn set_activate_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) -> bool + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>) -> bool + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_activate_function_full(
                self.to_glib_none().0,
                Some(trampoline_activate_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_activatemode_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::PadMode, bool) -> bool + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, ::PadMode, bool) -> bool + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_activatemode_function_full(
                self.to_glib_none().0,
                Some(trampoline_activatemode_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_chain_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Buffer) -> ::FlowReturn + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, ::Buffer) -> ::FlowReturn + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_chain_function_full(
                self.to_glib_none().0,
                Some(trampoline_chain_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_chain_list_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::BufferList) -> ::FlowReturn + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, ::BufferList) -> ::FlowReturn + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_chain_list_function_full(
                self.to_glib_none().0,
                Some(trampoline_chain_list_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_event_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Event) -> bool + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, ::Event) -> bool + Send + Sync + 'static,
            > = Box::new(func);
            let func_ptr = Box::into_raw(Box::new(func_box)) as gpointer;

            println!("before {:?}", func_ptr);

            ffi::gst_pad_set_event_function_full(
                self.to_glib_none().0,
                Some(trampoline_event_function),
                func_ptr,
                Some(destroy_closure),
            );
        }
    }

    fn set_event_full_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, ::Event) -> ::FlowReturn + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, ::Event) -> ::FlowReturn + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_event_full_function_full(
                self.to_glib_none().0,
                Some(trampoline_event_full_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_getrange_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, u64, u32)
            -> Result<::Buffer, ::FlowReturn>
            + Send
            + Sync
            + 'static,
    {
        unsafe {
            #[cfg_attr(feature = "cargo-clippy", allow(type_complexity))]
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, u64, u32)
                    -> Result<::Buffer, ::FlowReturn>
                    + Send
                    + Sync
                    + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_getrange_function_full(
                self.to_glib_none().0,
                Some(trampoline_getrange_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_iterate_internal_links_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) -> ::Iterator<Pad> + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>) -> ::Iterator<Pad> + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_iterate_internal_links_function_full(
                self.to_glib_none().0,
                Some(trampoline_iterate_internal_links_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_link_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, &Pad) -> ::PadLinkReturn + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, &Pad) -> ::PadLinkReturn + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_link_function_full(
                self.to_glib_none().0,
                Some(trampoline_link_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_query_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>, &mut ::QueryRef) -> bool + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<
                Fn(&Pad, &Option<::Object>, &mut ::QueryRef) -> bool + Send + Sync + 'static,
            > = Box::new(func);
            ffi::gst_pad_set_query_function_full(
                self.to_glib_none().0,
                Some(trampoline_query_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn set_unlink_function<F>(&self, func: F)
    where
        F: Fn(&Pad, &Option<::Object>) + Send + Sync + 'static,
    {
        unsafe {
            let func_box: Box<Fn(&Pad, &Option<::Object>) + Send + Sync + 'static> = Box::new(func);
            ffi::gst_pad_set_unlink_function_full(
                self.to_glib_none().0,
                Some(trampoline_unlink_function),
                Box::into_raw(Box::new(func_box)) as gpointer,
                Some(destroy_closure),
            );
        }
    }

    fn start_task<F: FnMut() + Send + 'static>(&self, func: F) -> Result<(), glib::BoolError> {
        unsafe {
            glib::error::BoolError::from_glib(
                ffi::gst_pad_start_task(
                    self.to_glib_none().0,
                    Some(trampoline_pad_task),
                    into_raw_pad_task(func),
                    Some(destroy_closure_pad_task),
                ),
                "Failed to start pad task",
            )
        }
    }
}

unsafe extern "C" fn trampoline_pad_probe(
    pad: *mut ffi::GstPad,
    info: *mut ffi::GstPadProbeInfo,
    func: gpointer,
) -> ffi::GstPadProbeReturn {
    let _guard = CallbackGuard::new();
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &mut PadProbeInfo) -> PadProbeReturn + Send + Sync + 'static) =
        transmute(func);
    let mut data_type = None;

    let mut probe_info = PadProbeInfo {
        mask: from_glib((*info).type_),
        id: PadProbeId((*info).id),
        offset: (*info).offset,
        size: (*info).size,
        data: if (*info).data.is_null() {
            None
        } else {
            let data = (*info).data as *const ffi::GstMiniObject;
            if (*data).type_ == Buffer::static_type().to_glib() {
                data_type = Some(Buffer::static_type());
                Some(PadProbeData::Buffer(
                    from_glib_none(data as *const ffi::GstBuffer),
                ))
            } else if (*data).type_ == BufferList::static_type().to_glib() {
                data_type = Some(BufferList::static_type());
                Some(PadProbeData::BufferList(
                    from_glib_none(data as *const ffi::GstBufferList),
                ))
            } else if (*data).type_ == Query::static_type().to_glib() {
                data_type = Some(Query::static_type());
                Some(PadProbeData::Query(
                    QueryRef::from_mut_ptr(data as *mut ffi::GstQuery),
                ))
            } else if (*data).type_ == Event::static_type().to_glib() {
                data_type = Some(Event::static_type());
                Some(PadProbeData::Event(
                    from_glib_none(data as *const ffi::GstEvent),
                ))
            } else {
                Some(PadProbeData::Unknown)
            }
        },
    };

    let ret = func(&from_glib_borrow(pad), &mut probe_info).to_glib();

    match probe_info.data {
        Some(PadProbeData::Buffer(buffer)) => {
            assert_eq!(data_type, Some(Buffer::static_type()));
            if (*info).data != buffer.as_mut_ptr() as *mut _ {
                ffi::gst_mini_object_unref((*info).data as *mut _);
                (*info).data = buffer.into_ptr() as *mut libc::c_void;
            }
        }
        Some(PadProbeData::BufferList(bufferlist)) => {
            assert_eq!(data_type, Some(BufferList::static_type()));
            if (*info).data != bufferlist.as_mut_ptr() as *mut _ {
                ffi::gst_mini_object_unref((*info).data as *mut _);
                (*info).data = bufferlist.into_ptr() as *mut libc::c_void;
            }
        }
        Some(PadProbeData::Event(event)) => {
            assert_eq!(data_type, Some(Event::static_type()));
            if (*info).data != event.as_mut_ptr() as *mut _ {
                ffi::gst_mini_object_unref((*info).data as *mut _);
                (*info).data = event.into_ptr() as *mut libc::c_void;
            }
        }
        None => {
            assert_ne!(data_type, Some(Query::static_type()));
            if !(*info).data.is_null() {
                ffi::gst_mini_object_unref((*info).data as *mut _);
                (*info).data = ptr::null_mut();
            }
        }
        _ => (),
    }

    ret
}

// FIXME: Workaround for GHookList being truncated in the -sys bindings
macro_rules! pad_member_offset(
    ($pad:ident, $member:ident) => {{
        let probes_addr = &(*$pad).probes as *const _ as usize;
        let mode_addr = &(*$pad).mode as *const _ as usize;
        let member_addr = &(*$pad).$member as *const _ as usize;
        let hooklist_size = mem::size_of::<libc::c_ulong>()
            // 16+1 bits, next is pointer => pointer alignment padding
            + mem::size_of::<*const libc::c_void>()
            + 5 * mem::size_of::<*const libc::c_void>();
        let real_member_addr = member_addr - (mode_addr - probes_addr) + hooklist_size;

        *(real_member_addr as *const *const libc::c_void)
    }}
);

unsafe extern "C" fn trampoline_activate_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
) -> glib_ffi::gboolean {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, activatedata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>) -> bool + Send + Sync + 'static) = transmute(func);

    func(&from_glib_borrow(pad), &from_glib_borrow(parent)).to_glib()
}

unsafe extern "C" fn trampoline_activatemode_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    mode: ffi::GstPadMode,
    active: glib_ffi::gboolean,
) -> glib_ffi::gboolean {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, activatemodedata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, ::PadMode, bool) -> bool
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        from_glib(mode),
        from_glib(active),
    ).to_glib()
}

unsafe extern "C" fn trampoline_chain_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    buffer: *mut ffi::GstBuffer,
) -> ffi::GstFlowReturn {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, chaindata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, ::Buffer) -> ::FlowReturn
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        from_glib_full(buffer),
    ).to_glib()
}

unsafe extern "C" fn trampoline_chain_list_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    list: *mut ffi::GstBufferList,
) -> ffi::GstFlowReturn {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, chainlistdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, ::BufferList) -> ::FlowReturn
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        from_glib_full(list),
    ).to_glib()
}

unsafe extern "C" fn trampoline_event_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    event: *mut ffi::GstEvent,
) -> glib_ffi::gboolean {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, eventdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, ::Event) -> bool + Send + Sync + 'static) =
        transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        from_glib_full(event),
    ).to_glib()
}

unsafe extern "C" fn trampoline_event_full_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    event: *mut ffi::GstEvent,
) -> ffi::GstFlowReturn {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, eventdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, ::Event) -> ::FlowReturn
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        from_glib_full(event),
    ).to_glib()
}

unsafe extern "C" fn trampoline_getrange_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    offset: u64,
    length: u32,
    buffer: *mut *mut ffi::GstBuffer,
) -> ffi::GstFlowReturn {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, getrangedata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, u64, u32)
        -> Result<::Buffer, ::FlowReturn>
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    match func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        offset,
        length,
    ) {
        Ok(new_buffer) => {
            *buffer = new_buffer.into_ptr();
            ::FlowReturn::Ok.to_glib()
        }
        Err(ret) => ret.to_glib(),
    }
}

unsafe extern "C" fn trampoline_iterate_internal_links_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
) -> *mut ffi::GstIterator {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, iterintlinkdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>) -> ::Iterator<Pad> + Send + Sync + 'static) =
        transmute(func);

    // Steal the iterator and return it
    let ret = func(&from_glib_borrow(pad), &from_glib_borrow(parent));
    let ptr = ret.to_glib_none().0;
    mem::forget(ret);

    ptr as *mut _
}

unsafe extern "C" fn trampoline_link_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    peer: *mut ffi::GstPad,
) -> ffi::GstPadLinkReturn {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, linkdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, &::Pad) -> ::PadLinkReturn
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        &from_glib_borrow(peer),
    ).to_glib()
}

unsafe extern "C" fn trampoline_query_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
    query: *mut ffi::GstQuery,
) -> glib_ffi::gboolean {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, querydata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>, &mut ::QueryRef) -> bool
                         + Send
                         + Sync
                         + 'static) = transmute(func);

    func(
        &from_glib_borrow(pad),
        &from_glib_borrow(parent),
        ::QueryRef::from_mut_ptr(query),
    ).to_glib()
}

unsafe extern "C" fn trampoline_unlink_function(
    pad: *mut ffi::GstPad,
    parent: *mut ffi::GstObject,
) {
    let _guard = CallbackGuard::new();
    let func = pad_member_offset!(pad, unlinkdata);
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &&(Fn(&Pad, &Option<::Object>) + Send + Sync + 'static) = transmute(func);

    func(&from_glib_borrow(pad), &from_glib_borrow(parent))
}

unsafe extern "C" fn destroy_closure(ptr: gpointer) {
    let _guard = CallbackGuard::new();
    Box::<Box<Fn()>>::from_raw(ptr as *mut _);
}

unsafe extern "C" fn trampoline_pad_task(func: gpointer) {
    let _guard = CallbackGuard::new();
    #[cfg_attr(feature = "cargo-clippy", allow(transmute_ptr_to_ref))]
    let func: &RefCell<Box<FnMut() + Send + 'static>> = transmute(func);
    (&mut *func.borrow_mut())()
}

unsafe extern "C" fn destroy_closure_pad_task(ptr: gpointer) {
    let _guard = CallbackGuard::new();
    Box::<RefCell<Box<FnMut() + Send + 'static>>>::from_raw(ptr as *mut _);
}

fn into_raw_pad_task<F: FnMut() + Send + 'static>(func: F) -> gpointer {
    #[cfg_attr(feature = "cargo-clippy", allow(type_complexity))]
    let func: Box<RefCell<Box<FnMut() + Send + 'static>>> = Box::new(RefCell::new(Box::new(func)));
    Box::into_raw(func) as gpointer
}

#[cfg(test)]
mod tests {
    use super::*;
    use prelude::*;
    use std::sync::{Arc, Mutex};
    use std::sync::mpsc::channel;

    #[test]
    fn test_event_chain_functions() {
        ::init().unwrap();

        let pad = ::Pad::new("sink", ::PadDirection::Sink);

        let events = Arc::new(Mutex::new(Vec::new()));
        let events_clone = events.clone();
        pad.set_event_function(move |_, _, event| {
            let mut events = events_clone.lock().unwrap();
            events.push(event);

            true
        });

        let buffers = Arc::new(Mutex::new(Vec::new()));
        let buffers_clone = buffers.clone();
        pad.set_chain_function(move |_, _, buffer| {
            let mut buffers = buffers_clone.lock().unwrap();
            buffers.push(buffer);

            ::FlowReturn::Ok
        });

        pad.set_active(true).unwrap();

        assert!(pad.send_event(::Event::new_stream_start("test").build()));
        let mut segment = ::Segment::default();
        segment.init(::Format::Time);
        assert!(pad.send_event(::Event::new_segment(&segment).build()));

        assert_eq!(pad.chain(::Buffer::new()), ::FlowReturn::Ok);

        let events = events.lock().unwrap();
        let buffers = buffers.lock().unwrap();
        assert_eq!(events.len(), 2);
        assert_eq!(buffers.len(), 1);

        match events[0].view() {
            ::EventView::StreamStart(..) => (),
            _ => unreachable!(),
        }

        match events[1].view() {
            ::EventView::Segment(..) => (),
            _ => unreachable!(),
        }
    }

    #[test]
    fn test_task() {
        ::init().unwrap();

        let pad = ::Pad::new("sink", ::PadDirection::Sink);
        let (sender, receiver) = channel();

        let mut i = 0;
        let pad_clone = pad.clone();
        pad.start_task(move || {
            i += 1;
            if i == 3 {
                sender.send(i).unwrap();
                pad_clone.pause_task().unwrap();
            }
        }).unwrap();

        assert_eq!(receiver.recv().unwrap(), 3);
    }
}