// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// 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::ToValue;
use std::boxed::Box as Box_;
use std::mem;
use std::mem::transmute;

glib::wrapper! {
    /// [`crate::BaseSink`] is the base class for sink elements in GStreamer, such as
    /// xvimagesink or filesink. It is a layer on top of [`crate::gst::Element`] that provides a
    /// simplified interface to plugin writers. [`crate::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 [`crate::gst::Element`] or to set functions on pads, because the
    /// [`crate::BaseSink`] infrastructure should be sufficient.
    ///
    /// [`crate::BaseSink`] provides support for exactly one sink pad, which should be
    /// named "sink". A sink implementation (subclass of [`crate::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>");
    /// }
    /// ```
    ///
    /// [`crate::BaseSink`] will handle the prerolling correctly. This means that it will
    /// return [`crate::gst::StateChangeReturn::Async`] from a state change to PAUSED until the first
    /// buffer arrives in this element. The base class will call the
    /// [`crate::GstBaseSinkClass.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, [`crate::BaseSink`] will synchronise on the
    /// clock using the times returned from [`crate::GstBaseSinkClass.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
    /// [`crate::BaseSink:sync`] property to [`false`].
    ///
    /// After synchronisation the virtual method [`crate::GstBaseSinkClass.render()`] will be
    /// called. Subclasses should minimally implement this method.
    ///
    /// Subclasses that synchronise on the clock in the [`crate::GstBaseSinkClass.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 [`crate::prelude::BaseSinkExt::wait_preroll()`] to perform the
    /// blocking wait.
    ///
    /// Upon receiving the EOS event in the PLAYING state, [`crate::BaseSink`] will wait
    /// for the clock to reach the time indicated by the stop time of the last
    /// [`crate::GstBaseSinkClass.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.
    ///
    /// [`crate::BaseSink`] will internally use the [`crate::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.
    ///
    /// [`crate::BaseSink`] will by default report the current playback position in
    /// [`crate::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 [`crate::GstBaseSinkClass.set_caps()`] function will be called when the subclass
    /// should configure itself to process a specific media type.
    ///
    /// The [`crate::GstBaseSinkClass.start()`] and [`crate::GstBaseSinkClass.stop()`] virtual methods
    /// will be called when resources should be allocated. Any
    /// [`crate::GstBaseSinkClass.preroll()`], [`crate::GstBaseSinkClass.render()`] and
    /// [`crate::GstBaseSinkClass.set_caps()`] function will be called between the
    /// [`crate::GstBaseSinkClass.start()`] and [`crate::GstBaseSinkClass.stop()`] calls.
    ///
    /// The [`crate::GstBaseSinkClass.event()`] virtual method will be called when an event is
    /// received by [`crate::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 [`crate::GstBaseSinkClass.unlock()`] method is called when the elements should
    /// unblock any blocking operations they perform in the
    /// [`crate::GstBaseSinkClass.render()`] method. This is mostly useful when the
    /// [`crate::GstBaseSinkClass.render()`] method performs a blocking write on a file
    /// descriptor, for example.
    ///
    /// The [`crate::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
    /// [`crate::GstBaseSinkClass.get_times()`] method does not return a valid start time or
    /// max-lateness is set to -1 (the default).
    /// Subclasses can use [`crate::prelude::BaseSinkExt::set_max_lateness()`] to configure the
    /// max-lateness value.
    ///
    /// The [`crate::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 [`crate::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.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`trait@crate::prelude::BaseSinkExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::ObjectExt`], [`trait@glib::object::ObjectExt`], [`trait@crate::prelude::BaseSinkExtManual`]
    pub struct BaseSink(Object<ffi::GstBaseSink, ffi::GstBaseSinkClass>) @extends gst::Element, gst::Object;

    match fn {
        type_ => || ffi::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
///
/// [`struct@crate::BaseSink`]
pub trait BaseSinkExt: 'static {
    //#[doc(alias = "gst_base_sink_do_preroll")]
    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> Result<gst::FlowSuccess, gst::FlowError>;

    /// 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.
    #[doc(alias = "gst_base_sink_get_blocksize")]
    #[doc(alias = "get_blocksize")]
    fn blocksize(&self) -> u32;

    /// Checks if `self` is currently configured to drop buffers which are outside
    /// the current segment
    ///
    /// # Returns
    ///
    /// [`true`] if the sink is configured to drop buffers outside the
    /// current segment.
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
    #[doc(alias = "gst_base_sink_get_drop_out_of_segment")]
    #[doc(alias = "get_drop_out_of_segment")]
    fn is_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 [`crate::gst::Caps`] on the sample can be used to determine the type of the buffer.
    ///
    /// Free-function: gst_sample_unref
    ///
    /// # Returns
    ///
    /// a [`crate::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.
    #[doc(alias = "gst_base_sink_get_last_sample")]
    #[doc(alias = "get_last_sample")]
    fn last_sample(&self) -> Option<gst::Sample>;

    /// Get the currently configured latency.
    ///
    /// # Returns
    ///
    /// The configured latency.
    #[doc(alias = "gst_base_sink_get_latency")]
    #[doc(alias = "get_latency")]
    fn 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.
    #[doc(alias = "gst_base_sink_get_max_bitrate")]
    #[doc(alias = "get_max_bitrate")]
    fn max_bitrate(&self) -> u64;

    /// Gets the max lateness value. See [`Self::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.
    #[doc(alias = "gst_base_sink_get_max_lateness")]
    #[doc(alias = "get_max_lateness")]
    fn max_lateness(&self) -> i64;

    /// Get the processing deadline of `self`. see
    /// [`Self::set_processing_deadline()`] for more information about
    /// the processing deadline.
    ///
    /// # Returns
    ///
    /// the processing deadline
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_base_sink_get_processing_deadline")]
    #[doc(alias = "get_processing_deadline")]
    fn processing_deadline(&self) -> gst::ClockTime;

    /// Get the render delay of `self`. see [`Self::set_render_delay()`] for more
    /// information about the render delay.
    ///
    /// # Returns
    ///
    /// the render delay of `self`.
    #[doc(alias = "gst_base_sink_get_render_delay")]
    #[doc(alias = "get_render_delay")]
    fn render_delay(&self) -> gst::ClockTime;

    /// Return various [`crate::BaseSink`] statistics. This function returns a [`crate::gst::Structure`]
    /// with name `application/x-gst-base-sink-stats` with the following fields:
    ///
    /// - "average-rate" G_TYPE_DOUBLE average frame rate
    /// - "dropped" G_TYPE_UINT64 Number of dropped frames
    /// - "rendered" G_TYPE_UINT64 Number of rendered frames
    ///
    /// # Returns
    ///
    /// pointer to [`crate::gst::Structure`]
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_base_sink_get_stats")]
    #[doc(alias = "get_stats")]
    fn stats(&self) -> gst::Structure;

    /// Checks if `self` is currently configured to synchronize against the
    /// clock.
    ///
    /// # Returns
    ///
    /// [`true`] if the sink is configured to synchronize against the clock.
    #[doc(alias = "gst_base_sink_get_sync")]
    #[doc(alias = "get_sync")]
    fn is_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.
    #[doc(alias = "gst_base_sink_get_throttle_time")]
    #[doc(alias = "get_throttle_time")]
    fn throttle_time(&self) -> u64;

    /// Get the synchronisation offset of `self`.
    ///
    /// # Returns
    ///
    /// The synchronisation offset.
    #[doc(alias = "gst_base_sink_get_ts_offset")]
    #[doc(alias = "get_ts_offset")]
    fn 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.
    #[doc(alias = "gst_base_sink_is_async_enabled")]
    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.
    #[doc(alias = "gst_base_sink_is_last_sample_enabled")]
    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.
    #[doc(alias = "gst_base_sink_is_qos_enabled")]
    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.
    #[doc(alias = "gst_base_sink_set_async_enabled")]
    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
    #[doc(alias = "gst_base_sink_set_blocksize")]
    fn set_blocksize(&self, blocksize: u32);

    /// Configure `self` to drop buffers which are outside the current segment
    /// ## `drop_out_of_segment`
    /// drop buffers outside the segment
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_12")))]
    #[doc(alias = "gst_base_sink_set_drop_out_of_segment")]
    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.
    #[doc(alias = "gst_base_sink_set_last_sample_enabled")]
    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
    #[doc(alias = "gst_base_sink_set_max_bitrate")]
    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.
    #[doc(alias = "gst_base_sink_set_max_lateness")]
    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.
    /// ## `processing_deadline`
    /// the new processing deadline in nanoseconds.
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_base_sink_set_processing_deadline")]
    fn set_processing_deadline(&self, processing_deadline: gst::ClockTime);

    /// Configures `self` to send Quality-of-Service events upstream.
    /// ## `enabled`
    /// the new qos value.
    #[doc(alias = "gst_base_sink_set_qos_enabled")]
    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
    #[doc(alias = "gst_base_sink_set_render_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.
    #[doc(alias = "gst_base_sink_set_sync")]
    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
    #[doc(alias = "gst_base_sink_set_throttle_time")]
    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
    #[doc(alias = "gst_base_sink_set_ts_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
    ///
    /// [`crate::gst::FlowReturn`]
    #[doc(alias = "gst_base_sink_wait")]
    fn wait(
        &self,
        time: gst::ClockTime,
    ) -> (Result<gst::FlowSuccess, gst::FlowError>, 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 [`crate::gst::ClockReturn::Badtime`] is
    /// returned. Likewise, if synchronisation is disabled in the element or there
    /// is no clock, no synchronisation is done and [`crate::gst::ClockReturn::Badtime`] is returned.
    ///
    /// This function should only be called with the PREROLL_LOCK held, like when
    /// receiving an EOS event in the [`crate::GstBaseSinkClass.event()`] vmethod or when
    /// receiving a buffer in
    /// the [`crate::GstBaseSinkClass.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
    ///
    /// [`crate::gst::ClockReturn`]
    #[doc(alias = "gst_base_sink_wait_clock")]
    fn wait_clock(
        &self,
        time: gst::ClockTime,
    ) -> (
        Result<gst::ClockSuccess, gst::ClockError>,
        gst::ClockTimeDiff,
    );

    /// If the [`crate::GstBaseSinkClass.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 [`crate::GstBaseSinkClass.render()`] method can block on something else than
    /// the clock, it must also be ready to unblock immediately on
    /// the [`crate::GstBaseSinkClass.unlock()`] method and cause the
    /// [`crate::GstBaseSinkClass.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 [`crate::gst::FlowReturn::Ok`].
    ///
    /// This function will block until a state change to PLAYING happens (in which
    /// case this function returns [`crate::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 [`crate::gst::FlowReturn::Flushing`]).
    ///
    /// This function should only be called with the PREROLL_LOCK held, like in the
    /// render function.
    ///
    /// # Returns
    ///
    /// [`crate::gst::FlowReturn::Ok`] if the preroll completed and processing can
    /// continue. Any other return value should be returned from the render vmethod.
    #[doc(alias = "gst_base_sink_wait_preroll")]
    fn wait_preroll(&self) -> Result<gst::FlowSuccess, gst::FlowError>;

    #[doc(alias = "async")]
    fn is_async(&self) -> bool;

    #[doc(alias = "async")]
    fn set_async(&self, async_: bool);

    #[doc(alias = "enable-last-sample")]
    fn enables_last_sample(&self) -> bool;

    #[doc(alias = "enable-last-sample")]
    fn set_enable_last_sample(&self, enable_last_sample: bool);

    fn is_qos(&self) -> bool;

    fn set_qos(&self, qos: bool);

    #[doc(alias = "async")]
    fn connect_async_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "blocksize")]
    fn connect_blocksize_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "enable-last-sample")]
    fn connect_enable_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "last-sample")]
    fn connect_last_sample_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "max-bitrate")]
    fn connect_max_bitrate_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "max-lateness")]
    fn connect_max_lateness_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

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

    #[doc(alias = "qos")]
    fn connect_qos_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "render-delay")]
    fn connect_render_delay_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "stats")]
    fn connect_stats_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "sync")]
    fn connect_sync_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "throttle-time")]
    fn connect_throttle_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "ts-offset")]
    fn connect_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) -> Result<gst::FlowSuccess, gst::FlowError> {
    //    unsafe { TODO: call ffi:gst_base_sink_do_preroll() }
    //}

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

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

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

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

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

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

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

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

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn stats(&self) -> gst::Structure {
        unsafe { from_glib_full(ffi::gst_base_sink_get_stats(self.as_ref().to_glib_none().0)) }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn wait(
        &self,
        time: gst::ClockTime,
    ) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff) {
        unsafe {
            let mut jitter = mem::MaybeUninit::uninit();
            let ret = gst::FlowSuccess::try_from_glib(ffi::gst_base_sink_wait(
                self.as_ref().to_glib_none().0,
                time.into_glib(),
                jitter.as_mut_ptr(),
            ));
            let jitter = jitter.assume_init();
            (ret, jitter)
        }
    }

    fn wait_clock(
        &self,
        time: gst::ClockTime,
    ) -> (
        Result<gst::ClockSuccess, gst::ClockError>,
        gst::ClockTimeDiff,
    ) {
        unsafe {
            let mut jitter = mem::MaybeUninit::uninit();
            let ret = gst::ClockSuccess::try_from_glib(ffi::gst_base_sink_wait_clock(
                self.as_ref().to_glib_none().0,
                time.into_glib(),
                jitter.as_mut_ptr(),
            ));
            let jitter = jitter.assume_init();
            (ret, jitter)
        }
    }

    fn wait_preroll(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe {
            gst::FlowSuccess::try_from_glib(ffi::gst_base_sink_wait_preroll(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    fn set_async(&self, async_: bool) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"async\0".as_ptr() as *const _,
                async_.to_value().to_glib_none().0,
            );
        }
    }

    fn enables_last_sample(&self) -> bool {
        unsafe {
            let mut value = glib::Value::from_type(<bool as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::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")
        }
    }

    fn set_enable_last_sample(&self, enable_last_sample: bool) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"enable-last-sample\0".as_ptr() as *const _,
                enable_last_sample.to_value().to_glib_none().0,
            );
        }
    }

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

    fn set_qos(&self, qos: bool) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"qos\0".as_ptr() as *const _,
                qos.to_value().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "async")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_async_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "blocksize")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_blocksize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "enable-last-sample")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_enable_last_sample_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "last-sample")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_last_sample_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "max-bitrate")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_max_bitrate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "max-lateness")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_max_lateness_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))]
    #[doc(alias = "processing-deadline")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_processing_deadline_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "qos")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_qos_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "render-delay")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_render_delay_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "stats")]
    fn connect_stats_notify<F: Fn(&Self) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_stats_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::stats\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_stats_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "sync")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_sync_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "throttle-time")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_throttle_time_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "ts-offset")]
    fn connect_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 ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseSink>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_ts_offset_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}