// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use ffi;
use glib;
use glib::StaticType;
use glib::Value;
use glib::object::Downcast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use gst;
use gst_ffi;
use std::boxed::Box as Box_;
use std::mem;
use std::mem::transmute;
use std::ptr;

glib_wrapper! {
    /// `BaseSink` is the base class for sink elements in GStreamer, such as
    /// xvimagesink or filesink. It is a layer on top of `gst::Element` that provides a
    /// simplified interface to plugin writers. `BaseSink` handles many details
    /// for you, for example: preroll, clock synchronization, state changes,
    /// activation in push or pull mode, and queries.
    ///
    /// In most cases, when writing sink elements, there is no need to implement
    /// class methods from `gst::Element` or to set functions on pads, because the
    /// `BaseSink` infrastructure should be sufficient.
    ///
    /// `BaseSink` provides support for exactly one sink pad, which should be
    /// named "sink". A sink implementation (subclass of `BaseSink`) should
    /// install a pad template in its class_init function, like so:
    ///
    /// ```C
    /// static void
    /// my_element_class_init (GstMyElementClass *klass)
    /// {
    ///   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
    ///
    ///   // sinktemplate should be a #GstStaticPadTemplate with direction
    ///   // %GST_PAD_SINK and name "sink"
    ///   gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate);
    ///
    ///   gst_element_class_set_static_metadata (gstelement_class,
    ///       "Sink name",
    ///       "Sink",
    ///       "My Sink element",
    ///       "The author <my.sink@my.email>");
    /// }
    /// ```
    ///
    /// `BaseSink` will handle the prerolling correctly. This means that it will
    /// return `gst::StateChangeReturn::Async` from a state change to PAUSED until the first
    /// buffer arrives in this element. The base class will call the
    /// `BaseSinkClass.preroll`() vmethod with this preroll buffer and will then
    /// commit the state change to the next asynchronously pending state.
    ///
    /// When the element is set to PLAYING, `BaseSink` will synchronise on the
    /// clock using the times returned from `BaseSinkClass.get_times`(). If this
    /// function returns `GST_CLOCK_TIME_NONE` for the start time, no synchronisation
    /// will be done. Synchronisation can be disabled entirely by setting the object
    /// `BaseSink:sync` property to `false`.
    ///
    /// After synchronisation the virtual method `BaseSinkClass.render`() will be
    /// called. Subclasses should minimally implement this method.
    ///
    /// Subclasses that synchronise on the clock in the `BaseSinkClass.render`()
    /// method are supported as well. These classes typically receive a buffer in
    /// the render method and can then potentially block on the clock while
    /// rendering. A typical example is an audiosink.
    /// These subclasses can use `BaseSinkExt::wait_preroll` to perform the
    /// blocking wait.
    ///
    /// Upon receiving the EOS event in the PLAYING state, `BaseSink` will wait
    /// for the clock to reach the time indicated by the stop time of the last
    /// `BaseSinkClass.get_times`() call before posting an EOS message. When the
    /// element receives EOS in PAUSED, preroll completes, the event is queued and an
    /// EOS message is posted when going to PLAYING.
    ///
    /// `BaseSink` will internally use the `gst::EventType::Segment` events to schedule
    /// synchronisation and clipping of buffers. Buffers that fall completely outside
    /// of the current segment are dropped. Buffers that fall partially in the
    /// segment are rendered (and prerolled). Subclasses should do any subbuffer
    /// clipping themselves when needed.
    ///
    /// `BaseSink` will by default report the current playback position in
    /// `gst::Format::Time` based on the current clock time and segment information.
    /// If no clock has been set on the element, the query will be forwarded
    /// upstream.
    ///
    /// The `BaseSinkClass.set_caps`() function will be called when the subclass
    /// should configure itself to process a specific media type.
    ///
    /// The `BaseSinkClass.start`() and `BaseSinkClass.stop`() virtual methods
    /// will be called when resources should be allocated. Any
    /// `BaseSinkClass.preroll`(), `BaseSinkClass.render`() and
    /// `BaseSinkClass.set_caps`() function will be called between the
    /// `BaseSinkClass.start`() and `BaseSinkClass.stop`() calls.
    ///
    /// The `BaseSinkClass.event`() virtual method will be called when an event is
    /// received by `BaseSink`. Normally this method should only be overridden by
    /// very specific elements (such as file sinks) which need to handle the
    /// newsegment event specially.
    ///
    /// The `BaseSinkClass.unlock`() method is called when the elements should
    /// unblock any blocking operations they perform in the
    /// `BaseSinkClass.render`() method. This is mostly useful when the
    /// `BaseSinkClass.render`() method performs a blocking write on a file
    /// descriptor, for example.
    ///
    /// The `BaseSink:max-lateness` property affects how the sink deals with
    /// buffers that arrive too late in the sink. A buffer arrives too late in the
    /// sink when the presentation time (as a combination of the last segment, buffer
    /// timestamp and element base_time) plus the duration is before the current
    /// time of the clock.
    /// If the frame is later than max-lateness, the sink will drop the buffer
    /// without calling the render method.
    /// This feature is disabled if sync is disabled, the
    /// `BaseSinkClass.get_times`() method does not return a valid start time or
    /// max-lateness is set to -1 (the default).
    /// Subclasses can use `BaseSinkExt::set_max_lateness` to configure the
    /// max-lateness value.
    ///
    /// The `BaseSink:qos` property will enable the quality-of-service features of
    /// the basesink which gather statistics about the real-time performance of the
    /// clock synchronisation. For each buffer received in the sink, statistics are
    /// gathered and a QOS event is sent upstream with these numbers. This
    /// information can then be used by upstream elements to reduce their processing
    /// rate, for example.
    ///
    /// The `BaseSink:async` property can be used to instruct the sink to never
    /// perform an ASYNC state change. This feature is mostly usable when dealing
    /// with non-synchronized streams or sparse streams.
    ///
    /// # Implements
    ///
    /// [`BaseSinkExt`](trait.BaseSinkExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct BaseSink(Object<ffi::GstBaseSink, ffi::GstBaseSinkClass>): [
        gst::Element => gst_ffi::GstElement,
        gst::Object => gst_ffi::GstObject,
    ];

    match fn {
        get_type => || ffi::gst_base_sink_get_type(),
    }
}

unsafe impl Send for BaseSink {}
unsafe impl Sync for BaseSink {}

/// Trait containing all `BaseSink` methods.
///
/// # Implementors
///
/// [`BaseSink`](struct.BaseSink.html)
pub trait BaseSinkExt {
    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> gst::FlowReturn;

    /// Get the number of bytes that the sink will pull when it is operating in pull
    /// mode.
    ///
    /// # Returns
    ///
    /// the number of bytes `self` will pull in pull mode.
    fn get_blocksize(&self) -> u32;

    /// Checks if `self` is currently configured to drop buffers which are outside
    /// the current segment
    ///
    /// Feature: `v1_12`
    ///
    ///
    /// # Returns
    ///
    /// `true` if the sink is configured to drop buffers outside the
    /// current segment.
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn get_drop_out_of_segment(&self) -> bool;

    /// Get the last sample that arrived in the sink and was used for preroll or for
    /// rendering. This property can be used to generate thumbnails.
    ///
    /// The `gst::Caps` on the sample can be used to determine the type of the buffer.
    ///
    /// Free-function: gst_sample_unref
    ///
    /// # Returns
    ///
    /// a `gst::Sample`. `gst_sample_unref` after
    ///  usage. This function returns `None` when no buffer has arrived in the
    ///  sink yet or when the sink is not in PAUSED or PLAYING.
    fn get_last_sample(&self) -> Option<gst::Sample>;

    /// Get the currently configured latency.
    ///
    /// # Returns
    ///
    /// The configured latency.
    fn get_latency(&self) -> gst::ClockTime;

    /// Get the maximum amount of bits per second that the sink will render.
    ///
    /// # Returns
    ///
    /// the maximum number of bits per second `self` will render.
    fn get_max_bitrate(&self) -> u64;

    /// Gets the max lateness value. See `BaseSinkExt::set_max_lateness` for
    /// more details.
    ///
    /// # Returns
    ///
    /// The maximum time in nanoseconds that a buffer can be late
    /// before it is dropped and not rendered. A value of -1 means an
    /// unlimited time.
    fn get_max_lateness(&self) -> i64;

    /// Get the render delay of `self`. see `BaseSinkExt::set_render_delay` for more
    /// information about the render delay.
    ///
    /// # Returns
    ///
    /// the render delay of `self`.
    fn get_render_delay(&self) -> gst::ClockTime;

    /// Checks if `self` is currently configured to synchronize against the
    /// clock.
    ///
    /// # Returns
    ///
    /// `true` if the sink is configured to synchronize against the clock.
    fn get_sync(&self) -> bool;

    /// Get the time that will be inserted between frames to control the
    /// maximum buffers per second.
    ///
    /// # Returns
    ///
    /// the number of nanoseconds `self` will put between frames.
    fn get_throttle_time(&self) -> u64;

    /// Get the synchronisation offset of `self`.
    ///
    /// # Returns
    ///
    /// The synchronisation offset.
    fn get_ts_offset(&self) -> gst::ClockTimeDiff;

    /// Checks if `self` is currently configured to perform asynchronous state
    /// changes to PAUSED.
    ///
    /// # Returns
    ///
    /// `true` if the sink is configured to perform asynchronous state
    /// changes.
    fn is_async_enabled(&self) -> bool;

    /// Checks if `self` is currently configured to store the last received sample in
    /// the last-sample property.
    ///
    /// # Returns
    ///
    /// `true` if the sink is configured to store the last received sample.
    fn is_last_sample_enabled(&self) -> bool;

    /// Checks if `self` is currently configured to send Quality-of-Service events
    /// upstream.
    ///
    /// # Returns
    ///
    /// `true` if the sink is configured to perform Quality-of-Service.
    fn is_qos_enabled(&self) -> bool;

    /// Query the sink for the latency parameters. The latency will be queried from
    /// the upstream elements. `live` will be `true` if `self` is configured to
    /// synchronize against the clock. `upstream_live` will be `true` if an upstream
    /// element is live.
    ///
    /// If both `live` and `upstream_live` are `true`, the sink will want to compensate
    /// for the latency introduced by the upstream elements by setting the
    /// `min_latency` to a strictly positive value.
    ///
    /// This function is mostly used by subclasses.
    /// ## `live`
    /// if the sink is live
    /// ## `upstream_live`
    /// if an upstream element is live
    /// ## `min_latency`
    /// the min latency of the upstream elements
    /// ## `max_latency`
    /// the max latency of the upstream elements
    ///
    /// # Returns
    ///
    /// `true` if the query succeeded.
    fn query_latency(&self) -> Option<(bool, bool, gst::ClockTime, gst::ClockTime)>;

    /// Configures `self` to perform all state changes asynchronously. When async is
    /// disabled, the sink will immediately go to PAUSED instead of waiting for a
    /// preroll buffer. This feature is useful if the sink does not synchronize
    /// against the clock or when it is dealing with sparse streams.
    /// ## `enabled`
    /// the new async value.
    fn set_async_enabled(&self, enabled: bool);

    /// Set the number of bytes that the sink will pull when it is operating in pull
    /// mode.
    /// ## `blocksize`
    /// the blocksize in bytes
    fn set_blocksize(&self, blocksize: u32);

    /// Configure `self` to drop buffers which are outside the current segment
    ///
    /// Feature: `v1_12`
    ///
    /// ## `drop_out_of_segment`
    /// drop buffers outside the segment
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn set_drop_out_of_segment(&self, drop_out_of_segment: bool);

    /// Configures `self` to store the last received sample in the last-sample
    /// property.
    /// ## `enabled`
    /// the new enable-last-sample value.
    fn set_last_sample_enabled(&self, enabled: bool);

    /// Set the maximum amount of bits per second that the sink will render.
    /// ## `max_bitrate`
    /// the max_bitrate in bits per second
    fn set_max_bitrate(&self, max_bitrate: u64);

    /// Sets the new max lateness value to `max_lateness`. This value is
    /// used to decide if a buffer should be dropped or not based on the
    /// buffer timestamp and the current clock time. A value of -1 means
    /// an unlimited time.
    /// ## `max_lateness`
    /// the new max lateness value.
    fn set_max_lateness(&self, max_lateness: i64);

    /// Configures `self` to send Quality-of-Service events upstream.
    /// ## `enabled`
    /// the new qos value.
    fn set_qos_enabled(&self, enabled: bool);

    /// Set the render delay in `self` to `delay`. The render delay is the time
    /// between actual rendering of a buffer and its synchronisation time. Some
    /// devices might delay media rendering which can be compensated for with this
    /// function.
    ///
    /// After calling this function, this sink will report additional latency and
    /// other sinks will adjust their latency to delay the rendering of their media.
    ///
    /// This function is usually called by subclasses.
    /// ## `delay`
    /// the new delay
    fn set_render_delay(&self, delay: gst::ClockTime);

    /// Configures `self` to synchronize on the clock or not. When
    /// `sync` is `false`, incoming samples will be played as fast as
    /// possible. If `sync` is `true`, the timestamps of the incoming
    /// buffers will be used to schedule the exact render time of its
    /// contents.
    /// ## `sync`
    /// the new sync value.
    fn set_sync(&self, sync: bool);

    /// Set the time that will be inserted between rendered buffers. This
    /// can be used to control the maximum buffers per second that the sink
    /// will render.
    /// ## `throttle`
    /// the throttle time in nanoseconds
    fn set_throttle_time(&self, throttle: u64);

    /// Adjust the synchronisation of `self` with `offset`. A negative value will
    /// render buffers earlier than their timestamp. A positive value will delay
    /// rendering. This function can be used to fix playback of badly timestamped
    /// buffers.
    /// ## `offset`
    /// the new offset
    fn set_ts_offset(&self, offset: gst::ClockTimeDiff);

    /// This function will wait for preroll to complete and will then block until `time`
    /// is reached. It is usually called by subclasses that use their own internal
    /// synchronisation but want to let some synchronization (like EOS) be handled
    /// by the base class.
    ///
    /// This function should only be called with the PREROLL_LOCK held (like when
    /// receiving an EOS event in the ::event vmethod or when handling buffers in
    /// ::render).
    ///
    /// The `time` argument should be the running_time of when the timeout should happen
    /// and will be adjusted with any latency and offset configured in the sink.
    /// ## `time`
    /// the running_time to be reached
    /// ## `jitter`
    /// the jitter to be filled with time diff, or `None`
    ///
    /// # Returns
    ///
    /// `gst::FlowReturn`
    fn wait(&self, time: gst::ClockTime) -> (gst::FlowReturn, gst::ClockTimeDiff);

    /// This function will block until `time` is reached. It is usually called by
    /// subclasses that use their own internal synchronisation.
    ///
    /// If `time` is not valid, no synchronisation is done and `gst::ClockReturn::Badtime` is
    /// returned. Likewise, if synchronisation is disabled in the element or there
    /// is no clock, no synchronisation is done and `gst::ClockReturn::Badtime` is returned.
    ///
    /// This function should only be called with the PREROLL_LOCK held, like when
    /// receiving an EOS event in the `BaseSinkClass.event`() vmethod or when
    /// receiving a buffer in
    /// the `BaseSinkClass.render`() vmethod.
    ///
    /// The `time` argument should be the running_time of when this method should
    /// return and is not adjusted with any latency or offset configured in the
    /// sink.
    /// ## `time`
    /// the running_time to be reached
    /// ## `jitter`
    /// the jitter to be filled with time diff, or `None`
    ///
    /// # Returns
    ///
    /// `gst::ClockReturn`
    fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff);

    /// If the `BaseSinkClass.render`() method performs its own synchronisation
    /// against the clock it must unblock when going from PLAYING to the PAUSED state
    /// and call this method before continuing to render the remaining data.
    ///
    /// If the `BaseSinkClass.render`() method can block on something else than
    /// the clock, it must also be ready to unblock immediately on
    /// the `BaseSinkClass.unlock`() method and cause the
    /// `BaseSinkClass.render`() method to immediately call this function.
    /// In this case, the subclass must be prepared to continue rendering where it
    /// left off if this function returns `gst::FlowReturn::Ok`.
    ///
    /// This function will block until a state change to PLAYING happens (in which
    /// case this function returns `gst::FlowReturn::Ok`) or the processing must be stopped due
    /// to a state change to READY or a FLUSH event (in which case this function
    /// returns `gst::FlowReturn::Flushing`).
    ///
    /// This function should only be called with the PREROLL_LOCK held, like in the
    /// render function.
    ///
    /// # Returns
    ///
    /// `gst::FlowReturn::Ok` if the preroll completed and processing can
    /// continue. Any other return value should be returned from the render vmethod.
    fn wait_preroll(&self) -> gst::FlowReturn;

    /// If set to `true`, the basesink will perform asynchronous state changes.
    /// When set to `false`, the sink will not signal the parent when it prerolls.
    /// Use this option when dealing with sparse streams or when synchronisation is
    /// not required.
    fn get_property_async(&self) -> bool;

    /// If set to `true`, the basesink will perform asynchronous state changes.
    /// When set to `false`, the sink will not signal the parent when it prerolls.
    /// Use this option when dealing with sparse streams or when synchronisation is
    /// not required.
    fn set_property_async(&self, async: bool);

    fn get_property_enable_last_sample(&self) -> bool;

    fn set_property_enable_last_sample(&self, enable_last_sample: bool);

    fn get_property_qos(&self) -> bool;

    fn set_property_qos(&self, qos: bool);

    fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<BaseSink> + IsA<glib::object::Object>> BaseSinkExt for O {
    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> gst::FlowReturn {
    //    unsafe { TODO: call ffi::gst_base_sink_do_preroll() }
    //}

    fn get_blocksize(&self) -> u32 {
        unsafe {
            ffi::gst_base_sink_get_blocksize(self.to_glib_none().0)
        }
    }

    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn get_drop_out_of_segment(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_get_drop_out_of_segment(self.to_glib_none().0))
        }
    }

    fn get_last_sample(&self) -> Option<gst::Sample> {
        unsafe {
            from_glib_full(ffi::gst_base_sink_get_last_sample(self.to_glib_none().0))
        }
    }

    fn get_latency(&self) -> gst::ClockTime {
        unsafe {
            from_glib(ffi::gst_base_sink_get_latency(self.to_glib_none().0))
        }
    }

    fn get_max_bitrate(&self) -> u64 {
        unsafe {
            ffi::gst_base_sink_get_max_bitrate(self.to_glib_none().0)
        }
    }

    fn get_max_lateness(&self) -> i64 {
        unsafe {
            ffi::gst_base_sink_get_max_lateness(self.to_glib_none().0)
        }
    }

    fn get_render_delay(&self) -> gst::ClockTime {
        unsafe {
            from_glib(ffi::gst_base_sink_get_render_delay(self.to_glib_none().0))
        }
    }

    fn get_sync(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_get_sync(self.to_glib_none().0))
        }
    }

    fn get_throttle_time(&self) -> u64 {
        unsafe {
            ffi::gst_base_sink_get_throttle_time(self.to_glib_none().0)
        }
    }

    fn get_ts_offset(&self) -> gst::ClockTimeDiff {
        unsafe {
            ffi::gst_base_sink_get_ts_offset(self.to_glib_none().0)
        }
    }

    fn is_async_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_is_async_enabled(self.to_glib_none().0))
        }
    }

    fn is_last_sample_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_is_last_sample_enabled(self.to_glib_none().0))
        }
    }

    fn is_qos_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_is_qos_enabled(self.to_glib_none().0))
        }
    }

    fn query_latency(&self) -> Option<(bool, bool, gst::ClockTime, gst::ClockTime)> {
        unsafe {
            let mut live = mem::uninitialized();
            let mut upstream_live = mem::uninitialized();
            let mut min_latency = mem::uninitialized();
            let mut max_latency = mem::uninitialized();
            let ret = from_glib(ffi::gst_base_sink_query_latency(self.to_glib_none().0, &mut live, &mut upstream_live, &mut min_latency, &mut max_latency));
            if ret { Some((from_glib(live), from_glib(upstream_live), from_glib(min_latency), from_glib(max_latency))) } else { None }
        }
    }

    fn set_async_enabled(&self, enabled: bool) {
        unsafe {
            ffi::gst_base_sink_set_async_enabled(self.to_glib_none().0, enabled.to_glib());
        }
    }

    fn set_blocksize(&self, blocksize: u32) {
        unsafe {
            ffi::gst_base_sink_set_blocksize(self.to_glib_none().0, blocksize);
        }
    }

    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn set_drop_out_of_segment(&self, drop_out_of_segment: bool) {
        unsafe {
            ffi::gst_base_sink_set_drop_out_of_segment(self.to_glib_none().0, drop_out_of_segment.to_glib());
        }
    }

    fn set_last_sample_enabled(&self, enabled: bool) {
        unsafe {
            ffi::gst_base_sink_set_last_sample_enabled(self.to_glib_none().0, enabled.to_glib());
        }
    }

    fn set_max_bitrate(&self, max_bitrate: u64) {
        unsafe {
            ffi::gst_base_sink_set_max_bitrate(self.to_glib_none().0, max_bitrate);
        }
    }

    fn set_max_lateness(&self, max_lateness: i64) {
        unsafe {
            ffi::gst_base_sink_set_max_lateness(self.to_glib_none().0, max_lateness);
        }
    }

    fn set_qos_enabled(&self, enabled: bool) {
        unsafe {
            ffi::gst_base_sink_set_qos_enabled(self.to_glib_none().0, enabled.to_glib());
        }
    }

    fn set_render_delay(&self, delay: gst::ClockTime) {
        unsafe {
            ffi::gst_base_sink_set_render_delay(self.to_glib_none().0, delay.to_glib());
        }
    }

    fn set_sync(&self, sync: bool) {
        unsafe {
            ffi::gst_base_sink_set_sync(self.to_glib_none().0, sync.to_glib());
        }
    }

    fn set_throttle_time(&self, throttle: u64) {
        unsafe {
            ffi::gst_base_sink_set_throttle_time(self.to_glib_none().0, throttle);
        }
    }

    fn set_ts_offset(&self, offset: gst::ClockTimeDiff) {
        unsafe {
            ffi::gst_base_sink_set_ts_offset(self.to_glib_none().0, offset);
        }
    }

    fn wait(&self, time: gst::ClockTime) -> (gst::FlowReturn, gst::ClockTimeDiff) {
        unsafe {
            let mut jitter = mem::uninitialized();
            let ret = from_glib(ffi::gst_base_sink_wait(self.to_glib_none().0, time.to_glib(), &mut jitter));
            (ret, jitter)
        }
    }

    fn wait_clock(&self, time: gst::ClockTime) -> (gst::ClockReturn, gst::ClockTimeDiff) {
        unsafe {
            let mut jitter = mem::uninitialized();
            let ret = from_glib(ffi::gst_base_sink_wait_clock(self.to_glib_none().0, time.to_glib(), &mut jitter));
            (ret, jitter)
        }
    }

    fn wait_preroll(&self) -> gst::FlowReturn {
        unsafe {
            from_glib(ffi::gst_base_sink_wait_preroll(self.to_glib_none().0))
        }
    }

    fn get_property_async(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_ffi::g_object_get_property(self.to_glib_none().0, "async".to_glib_none().0, value.to_glib_none_mut().0);
            value.get().unwrap()
        }
    }

    fn set_property_async(&self, async: bool) {
        unsafe {
            gobject_ffi::g_object_set_property(self.to_glib_none().0, "async".to_glib_none().0, Value::from(&async).to_glib_none().0);
        }
    }

    fn get_property_enable_last_sample(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_ffi::g_object_get_property(self.to_glib_none().0, "enable-last-sample".to_glib_none().0, value.to_glib_none_mut().0);
            value.get().unwrap()
        }
    }

    fn set_property_enable_last_sample(&self, enable_last_sample: bool) {
        unsafe {
            gobject_ffi::g_object_set_property(self.to_glib_none().0, "enable-last-sample".to_glib_none().0, Value::from(&enable_last_sample).to_glib_none().0);
        }
    }

    fn get_property_qos(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_ffi::g_object_get_property(self.to_glib_none().0, "qos".to_glib_none().0, value.to_glib_none_mut().0);
            value.get().unwrap()
        }
    }

    fn set_property_qos(&self, qos: bool) {
        unsafe {
            gobject_ffi::g_object_set_property(self.to_glib_none().0, "qos".to_glib_none().0, Value::from(&qos).to_glib_none().0);
        }
    }

    fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::async",
                transmute(notify_async_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::blocksize",
                transmute(notify_blocksize_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::enable-last-sample",
                transmute(notify_enable_last_sample_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::last-sample",
                transmute(notify_last_sample_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::max-bitrate",
                transmute(notify_max_bitrate_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::max-lateness",
                transmute(notify_max_lateness_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::qos",
                transmute(notify_qos_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::render-delay",
                transmute(notify_render_delay_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::sync",
                transmute(notify_sync_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::throttle-time",
                transmute(notify_throttle_time_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }

    fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Self) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::ts-offset",
                transmute(notify_ts_offset_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
        }
    }
}

unsafe extern "C" fn notify_async_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_blocksize_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_enable_last_sample_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_last_sample_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_max_bitrate_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_max_lateness_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_qos_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_render_delay_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_sync_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_throttle_time_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}

unsafe extern "C" fn notify_ts_offset_trampoline<P>(this: *mut ffi::GstBaseSink, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<BaseSink> {
    let f: &&(Fn(&P) + Send + Sync + 'static) = transmute(f);
    f(&BaseSink::from_glib_borrow(this).downcast_unchecked())
}