// 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 glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use gst;
use gst_base_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;

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 `BaseSink::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<gst_base_sys::GstBaseSink, gst_base_sys::GstBaseSinkClass, BaseSinkClass>) @extends gst::Element, gst::Object;

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

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

pub const NONE_BASE_SINK: Option<&BaseSink> = None;

/// Trait containing all `BaseSink` methods.
///
/// # Implementors
///
/// [`BaseSink`](struct.BaseSink.html)
pub trait BaseSinkExt: 'static {
    //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 processing deadline of `self`. see
    /// `BaseSinkExt::set_processing_deadline` for more information about
    /// the processing deadline.
    ///
    /// Feature: `v1_16`
    ///
    ///
    /// # Returns
    ///
    /// the processing deadline
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn get_processing_deadline(&self) -> gst::ClockTime;

    /// 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;

    /// 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);

    /// Maximum amount of time (in nanoseconds) that the pipeline can take
    /// for processing the buffer. This is added to the latency of live
    /// pipelines.
    ///
    /// This function is usually called by subclasses.
    ///
    /// Feature: `v1_16`
    ///
    /// ## `processing_deadline`
    /// the new processing deadline in nanoseconds.
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn set_processing_deadline(&self, processing_deadline: gst::ClockTime);

    /// 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);

    /// 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);

    /// Enable the last-sample property. If `false`, basesink doesn't keep a
    /// reference to the last buffer arrived and the last-sample property is always
    /// set to `None`. This can be useful if you need buffers to be released as soon
    /// as possible, eg. if you're using a buffer pool.
    fn get_property_enable_last_sample(&self) -> bool;

    /// Enable the last-sample property. If `false`, basesink doesn't keep a
    /// reference to the last buffer arrived and the last-sample property is always
    /// set to `None`. This can be useful if you need buffers to be released as soon
    /// as possible, eg. if you're using a buffer pool.
    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;

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    fn connect_property_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>> BaseSinkExt for O {
    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> gst::FlowReturn {
    //    unsafe { TODO: call gst_base_sys:gst_base_sink_do_preroll() }
    //}

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

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

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

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

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

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

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn get_processing_deadline(&self) -> gst::ClockTime {
        unsafe {
            from_glib(gst_base_sys::gst_base_sink_get_processing_deadline(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

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

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

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

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

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

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

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

    fn set_blocksize(&self, blocksize: u32) {
        unsafe {
            gst_base_sys::gst_base_sink_set_blocksize(self.as_ref().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 {
            gst_base_sys::gst_base_sink_set_drop_out_of_segment(
                self.as_ref().to_glib_none().0,
                drop_out_of_segment.to_glib(),
            );
        }
    }

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

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

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

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn set_processing_deadline(&self, processing_deadline: gst::ClockTime) {
        unsafe {
            gst_base_sys::gst_base_sink_set_processing_deadline(
                self.as_ref().to_glib_none().0,
                processing_deadline.to_glib(),
            );
        }
    }

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

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

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

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

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

    fn get_property_async(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"async\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `async` getter")
                .unwrap()
        }
    }

    fn set_property_async(&self, async: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"async\0".as_ptr() as *const _,
                Value::from(&async).to_glib_none().0,
            );
        }
    }

    fn get_property_enable_last_sample(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"enable-last-sample\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `enable-last-sample` getter")
                .unwrap()
        }
    }

    fn set_property_enable_last_sample(&self, enable_last_sample: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"enable-last-sample\0".as_ptr() as *const _,
                Value::from(&enable_last_sample).to_glib_none().0,
            );
        }
    }

    fn get_property_qos(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"qos\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `qos` getter")
                .unwrap()
        }
    }

    fn set_property_qos(&self, qos: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"qos\0".as_ptr() as *const _,
                Value::from(&qos).to_glib_none().0,
            );
        }
    }

    fn connect_property_async_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_async_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::async\0".as_ptr() as *const _,
                Some(transmute(notify_async_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_blocksize_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::blocksize\0".as_ptr() as *const _,
                Some(transmute(notify_blocksize_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_last_sample_trampoline<
            P,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-last-sample\0".as_ptr() as *const _,
                Some(transmute(
                    notify_enable_last_sample_trampoline::<Self, F> as usize,
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_last_sample_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::last-sample\0".as_ptr() as *const _,
                Some(transmute(notify_last_sample_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_max_bitrate_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::max-bitrate\0".as_ptr() as *const _,
                Some(transmute(notify_max_bitrate_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_max_lateness_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::max-lateness\0".as_ptr() as *const _,
                Some(transmute(
                    notify_max_lateness_trampoline::<Self, F> as usize,
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn connect_property_processing_deadline_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_processing_deadline_trampoline<
            P,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::processing-deadline\0".as_ptr() as *const _,
                Some(transmute(
                    notify_processing_deadline_trampoline::<Self, F> as usize,
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_qos_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::qos\0".as_ptr() as *const _,
                Some(transmute(notify_qos_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_render_delay_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::render-delay\0".as_ptr() as *const _,
                Some(transmute(
                    notify_render_delay_trampoline::<Self, F> as usize,
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_sync_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::sync\0".as_ptr() as *const _,
                Some(transmute(notify_sync_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_throttle_time_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::throttle-time\0".as_ptr() as *const _,
                Some(transmute(
                    notify_throttle_time_trampoline::<Self, F> as usize,
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_ts_offset_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_ts_offset_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_base_sys::GstBaseSink,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::ts-offset\0".as_ptr() as *const _,
                Some(transmute(notify_ts_offset_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }
}