// 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 crate::ffi;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`BaseSink`][crate::BaseSink] is the base class for sink elements in GStreamer, such as
    /// xvimagesink or filesink. It is a layer on top of [`gst::Element`][crate::gst::Element] that provides a
    /// simplified interface to plugin writers. [`BaseSink`][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 [`gst::Element`][crate::gst::Element] or to set functions on pads, because the
    /// [`BaseSink`][crate::BaseSink] infrastructure should be sufficient.
    ///
    /// [`BaseSink`][crate::BaseSink] provides support for exactly one sink pad, which should be
    /// named "sink". A sink implementation (subclass of [`BaseSink`][crate::BaseSink]) should
    /// install a pad template in its class_init function, like so:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```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`][crate::BaseSink] will handle the prerolling correctly. This means that it will
    /// return [`gst::StateChangeReturn::Async`][crate::gst::StateChangeReturn::Async] from a state change to PAUSED until the first
    /// buffer arrives in this element. The base class will call the
    /// `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, [`BaseSink`][crate::BaseSink] will synchronise on the
    /// clock using the times returned from `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
    /// [`sync`][struct@crate::BaseSink#sync] property to [`false`].
    ///
    /// After synchronisation the virtual method `GstBaseSinkClass::render` will be
    /// called. Subclasses should minimally implement this method.
    ///
    /// Subclasses that synchronise on the clock in the `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 [`BaseSinkExt::wait_preroll()`][crate::prelude::BaseSinkExt::wait_preroll()] to perform the
    /// blocking wait.
    ///
    /// Upon receiving the EOS event in the PLAYING state, [`BaseSink`][crate::BaseSink] will wait
    /// for the clock to reach the time indicated by the stop time of the last
    /// `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.
    ///
    /// [`BaseSink`][crate::BaseSink] will internally use the [`gst::EventType::Segment`][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.
    ///
    /// [`BaseSink`][crate::BaseSink] will by default report the current playback position in
    /// [`gst::Format::Time`][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 `GstBaseSinkClass::set_caps` function will be called when the subclass
    /// should configure itself to process a specific media type.
    ///
    /// The `GstBaseSinkClass::start` and `GstBaseSinkClass::stop` virtual methods
    /// will be called when resources should be allocated. Any
    /// `GstBaseSinkClass::preroll`, `GstBaseSinkClass::render` and
    /// `GstBaseSinkClass::set_caps` function will be called between the
    /// `GstBaseSinkClass::start` and `GstBaseSinkClass::stop` calls.
    ///
    /// The `GstBaseSinkClass::event` virtual method will be called when an event is
    /// received by [`BaseSink`][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 `GstBaseSinkClass::unlock` method is called when the elements should
    /// unblock any blocking operations they perform in the
    /// `GstBaseSinkClass::render` method. This is mostly useful when the
    /// `GstBaseSinkClass::render` method performs a blocking write on a file
    /// descriptor, for example.
    ///
    /// The [`max-lateness`][struct@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
    /// `GstBaseSinkClass::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()`][crate::prelude::BaseSinkExt::set_max_lateness()] to configure the
    /// max-lateness value.
    ///
    /// The [`qos`][struct@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 [`async`][struct@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.
    ///
    /// ## Properties
    ///
    ///
    /// #### `async`
    ///  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.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `blocksize`
    ///  The amount of bytes to pull when operating in pull mode.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-last-sample`
    ///  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.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `last-sample`
    ///  The last buffer that arrived in the sink and was used for preroll or for
    /// rendering. This property can be used to generate thumbnails. This property
    /// can be [`None`] when the sink has not yet received a buffer.
    ///
    /// Readable
    ///
    ///
    /// #### `max-bitrate`
    ///  Control the maximum amount of bits that will be rendered per second.
    /// Setting this property to a value bigger than 0 will make the sink delay
    /// rendering of the buffers when it would exceed to max-bitrate.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `max-lateness`
    ///  Readable | Writeable
    ///
    ///
    /// #### `processing-deadline`
    ///  Maximum amount of time (in nanoseconds) that the pipeline can take
    /// for processing the buffer. This is added to the latency of live
    /// pipelines.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `qos`
    ///  Readable | Writeable
    ///
    ///
    /// #### `render-delay`
    ///  The additional delay between synchronisation and actual rendering of the
    /// media. This property will add additional latency to the device in order to
    /// make other sinks compensate for the delay.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `stats`
    ///  Various [`BaseSink`][crate::BaseSink] statistics. This property returns a [`gst::Structure`][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
    ///
    /// Readable
    ///
    ///
    /// #### `sync`
    ///  Readable | Writeable
    ///
    ///
    /// #### `throttle-time`
    ///  The time to insert between buffers. This property can be used to control
    /// the maximum amount of buffers per second to render. Setting this property
    /// to a value bigger than 0 will make the sink create THROTTLE QoS events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `ts-offset`
    ///  Controls the final synchronisation, a negative value will render the buffer
    /// earlier while a positive value delays playback. This property can be
    /// used to fix synchronisation in bad files.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent of the object. Please note, that when changing the 'parent'
    /// property, we don't emit [`notify`][struct@crate::glib::Object#notify] and [`deep-notify`][struct@crate::gst::Object#deep-notify]
    /// signals due to locking issues. In some cases one can use
    /// `GstBin::element-added` or `GstBin::element-removed` signals on the parent to
    /// achieve a similar effect.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`BaseSinkExt`][trait@crate::prelude::BaseSinkExt], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::ObjectExt`], [`trait@glib::ObjectExt`], [`BaseSinkExtManual`][trait@crate::prelude::BaseSinkExtManual]
    #[doc(alias = "GstBaseSink")]
    pub struct BaseSink(Object<ffi::GstBaseSink, ffi::GstBaseSinkClass>) @extends gst::Element, gst::Object;

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

impl BaseSink {
    pub const NONE: Option<&'static BaseSink> = None;
}

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

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::BaseSink>> Sealed for T {}
}

/// Trait containing all [`struct@BaseSink`] methods.
///
/// # Implementors
///
/// [`BaseSink`][struct@crate::BaseSink]
pub trait BaseSinkExt: IsA<BaseSink> + sealed::Sealed + 'static {
    //#[doc(alias = "gst_base_sink_do_preroll")]
    //fn do_preroll(&self, obj: /*Ignored*/&gst::MiniObject) -> Result<gst::FlowSuccess, gst::FlowError> {
    //    unsafe { TODO: call ffi:gst_base_sink_do_preroll() }
    //}

    /// 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 {
        unsafe { ffi::gst_base_sink_get_blocksize(self.as_ref().to_glib_none().0) }
    }

    /// 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.
    #[doc(alias = "gst_base_sink_get_drop_out_of_segment")]
    #[doc(alias = "get_drop_out_of_segment")]
    fn drops_out_of_segment(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_sink_get_drop_out_of_segment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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`][crate::gst::Caps] on the sample can be used to determine the type of the buffer.
    ///
    /// Free-function: gst_sample_unref
    ///
    /// # Returns
    ///
    /// a [`gst::Sample`][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")]
    #[doc(alias = "last-sample")]
    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,
            ))
        }
    }

    /// 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 {
        unsafe {
            try_from_glib(ffi::gst_base_sink_get_latency(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// 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")]
    #[doc(alias = "max-bitrate")]
    fn max_bitrate(&self) -> u64 {
        unsafe { ffi::gst_base_sink_get_max_bitrate(self.as_ref().to_glib_none().0) }
    }

    /// Gets the max lateness value. See [`set_max_lateness()`][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")]
    #[doc(alias = "max-lateness")]
    fn max_lateness(&self) -> i64 {
        unsafe { ffi::gst_base_sink_get_max_lateness(self.as_ref().to_glib_none().0) }
    }

    /// Get the processing deadline of `self`. see
    /// [`set_processing_deadline()`][Self::set_processing_deadline()] for more information about
    /// the processing deadline.
    ///
    /// # Returns
    ///
    /// the processing deadline
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_base_sink_get_processing_deadline")]
    #[doc(alias = "get_processing_deadline")]
    #[doc(alias = "processing-deadline")]
    fn processing_deadline(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::gst_base_sink_get_processing_deadline(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Get the render delay of `self`. see [`set_render_delay()`][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")]
    #[doc(alias = "render-delay")]
    fn render_delay(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::gst_base_sink_get_render_delay(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Return various [`BaseSink`][crate::BaseSink] statistics. This function returns a [`gst::Structure`][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 [`gst::Structure`][crate::gst::Structure]
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_base_sink_get_stats")]
    #[doc(alias = "get_stats")]
    fn stats(&self) -> gst::Structure {
        unsafe { from_glib_full(ffi::gst_base_sink_get_stats(self.as_ref().to_glib_none().0)) }
    }

    /// 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")]
    #[doc(alias = "sync")]
    fn is_sync(&self) -> bool {
        unsafe { from_glib(ffi::gst_base_sink_get_sync(self.as_ref().to_glib_none().0)) }
    }

    /// 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")]
    #[doc(alias = "throttle-time")]
    fn throttle_time(&self) -> u64 {
        unsafe { ffi::gst_base_sink_get_throttle_time(self.as_ref().to_glib_none().0) }
    }

    /// Get the synchronisation offset of `self`.
    ///
    /// # Returns
    ///
    /// The synchronisation offset.
    #[doc(alias = "gst_base_sink_get_ts_offset")]
    #[doc(alias = "get_ts_offset")]
    #[doc(alias = "ts-offset")]
    fn ts_offset(&self) -> gst::ClockTimeDiff {
        unsafe { ffi::gst_base_sink_get_ts_offset(self.as_ref().to_glib_none().0) }
    }

    /// 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")]
    #[doc(alias = "blocksize")]
    fn set_blocksize(&self, blocksize: u32) {
        unsafe {
            ffi::gst_base_sink_set_blocksize(self.as_ref().to_glib_none().0, blocksize);
        }
    }

    /// Configure `self` to drop buffers which are outside the current segment
    /// ## `drop_out_of_segment`
    /// drop buffers outside the segment
    #[doc(alias = "gst_base_sink_set_drop_out_of_segment")]
    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(),
            );
        }
    }

    /// 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")]
    #[doc(alias = "max-bitrate")]
    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);
        }
    }

    /// 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")]
    #[doc(alias = "max-lateness")]
    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);
        }
    }

    /// 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(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_base_sink_set_processing_deadline")]
    #[doc(alias = "processing-deadline")]
    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(),
            );
        }
    }

    /// 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")]
    #[doc(alias = "render-delay")]
    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());
        }
    }

    /// 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")]
    #[doc(alias = "sync")]
    fn set_sync(&self, sync: bool) {
        unsafe {
            ffi::gst_base_sink_set_sync(self.as_ref().to_glib_none().0, sync.into_glib());
        }
    }

    /// 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")]
    #[doc(alias = "throttle-time")]
    fn set_throttle_time(&self, throttle: u64) {
        unsafe {
            ffi::gst_base_sink_set_throttle_time(self.as_ref().to_glib_none().0, throttle);
        }
    }

    /// 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")]
    #[doc(alias = "ts-offset")]
    fn set_ts_offset(&self, offset: gst::ClockTimeDiff) {
        unsafe {
            ffi::gst_base_sink_set_ts_offset(self.as_ref().to_glib_none().0, offset);
        }
    }

    /// 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
    ///
    /// # Returns
    ///
    /// [`gst::FlowReturn`][crate::gst::FlowReturn]
    ///
    /// ## `jitter`
    /// the jitter to be filled with time diff, or [`None`]
    #[doc(alias = "gst_base_sink_wait")]
    fn wait(
        &self,
        time: impl Into<Option<gst::ClockTime>>,
    ) -> (Result<gst::FlowSuccess, gst::FlowError>, gst::ClockTimeDiff) {
        unsafe {
            let mut jitter = std::mem::MaybeUninit::uninit();
            let ret = try_from_glib(ffi::gst_base_sink_wait(
                self.as_ref().to_glib_none().0,
                time.into().into_glib(),
                jitter.as_mut_ptr(),
            ));
            (ret, jitter.assume_init())
        }
    }

    /// 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`][crate::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`][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 `GstBaseSinkClass::event` vmethod or when
    /// receiving a buffer in
    /// the `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
    ///
    /// # Returns
    ///
    /// [`gst::ClockReturn`][crate::gst::ClockReturn]
    ///
    /// ## `jitter`
    /// the jitter to be filled with time diff, or [`None`]
    #[doc(alias = "gst_base_sink_wait_clock")]
    fn wait_clock(
        &self,
        time: gst::ClockTime,
    ) -> (
        Result<gst::ClockSuccess, gst::ClockError>,
        gst::ClockTimeDiff,
    ) {
        unsafe {
            let mut jitter = std::mem::MaybeUninit::uninit();
            let ret = try_from_glib(ffi::gst_base_sink_wait_clock(
                self.as_ref().to_glib_none().0,
                time.into_glib(),
                jitter.as_mut_ptr(),
            ));
            (ret, jitter.assume_init())
        }
    }

    /// If the `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 `GstBaseSinkClass::render` method can block on something else than
    /// the clock, it must also be ready to unblock immediately on
    /// the `GstBaseSinkClass::unlock` method and cause the
    /// `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 [`gst::FlowReturn::Ok`][crate::gst::FlowReturn::Ok].
    ///
    /// This function will block until a state change to PLAYING happens (in which
    /// case this function returns [`gst::FlowReturn::Ok`][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 [`gst::FlowReturn::Flushing`][crate::gst::FlowReturn::Flushing]).
    ///
    /// This function should only be called with the PREROLL_LOCK held, like in the
    /// render function.
    ///
    /// # Returns
    ///
    /// [`gst::FlowReturn::Ok`][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> {
        unsafe {
            try_from_glib(ffi::gst_base_sink_wait_preroll(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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.
    #[doc(alias = "async")]
    fn is_async(&self) -> bool {
        ObjectExt::property(self.as_ref(), "async")
    }

    /// 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.
    #[doc(alias = "async")]
    fn set_async(&self, async_: bool) {
        ObjectExt::set_property(self.as_ref(), "async", async_)
    }

    /// 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.
    #[doc(alias = "enable-last-sample")]
    fn enables_last_sample(&self) -> bool {
        ObjectExt::property(self.as_ref(), "enable-last-sample")
    }

    /// 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.
    #[doc(alias = "enable-last-sample")]
    fn set_enable_last_sample(&self, enable_last_sample: bool) {
        ObjectExt::set_property(self.as_ref(), "enable-last-sample", enable_last_sample)
    }

    fn is_qos(&self) -> bool {
        ObjectExt::property(self.as_ref(), "qos")
    }

    fn set_qos(&self, qos: bool) {
        ObjectExt::set_property(self.as_ref(), "qos", qos)
    }

    #[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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_max_lateness_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_render_delay_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), 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: IsA<BaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_ts_offset_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<BaseSink>> BaseSinkExt for O {}