// 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
#![allow(deprecated)]

use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Provides useful functions and a base class for video sinks.
    ///
    /// GstVideoSink will configure the default base sink to drop frames that
    /// arrive later than 20ms as this is considered the default threshold for
    /// observing out-of-sync frames.
    ///
    /// ## Properties
    ///
    ///
    /// #### `show-preroll-frame`
    ///  Whether to show video frames during preroll. If set to [`false`], video
    /// frames will only be rendered in PLAYING state.
    ///
    /// Readable | Writeable | Construct
    /// <details><summary><h4>BaseSink</h4></summary>
    ///
    ///
    /// #### `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 [`gst_base::BaseSink`][crate::gst_base::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>
    /// <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
    ///
    /// [`VideoSinkExt`][trait@crate::prelude::VideoSinkExt], [`trait@gst_base::prelude::BaseSinkExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::ObjectExt`], [`trait@glib::ObjectExt`]
    #[doc(alias = "GstVideoSink")]
    pub struct VideoSink(Object<ffi::GstVideoSink, ffi::GstVideoSinkClass>) @extends gst_base::BaseSink, gst::Element, gst::Object;

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

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

unsafe impl Send for VideoSink {}
unsafe impl Sync for VideoSink {}

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

/// Trait containing all [`struct@VideoSink`] methods.
///
/// # Implementors
///
/// [`VideoSink`][struct@crate::VideoSink]
pub trait VideoSinkExt: IsA<VideoSink> + sealed::Sealed + 'static {
    /// Whether to show video frames during preroll. If set to [`false`], video
    /// frames will only be rendered in PLAYING state.
    #[doc(alias = "show-preroll-frame")]
    fn shows_preroll_frame(&self) -> bool {
        ObjectExt::property(self.as_ref(), "show-preroll-frame")
    }

    /// Whether to show video frames during preroll. If set to [`false`], video
    /// frames will only be rendered in PLAYING state.
    #[doc(alias = "show-preroll-frame")]
    fn set_show_preroll_frame(&self, show_preroll_frame: bool) {
        ObjectExt::set_property(self.as_ref(), "show-preroll-frame", show_preroll_frame)
    }

    #[doc(alias = "show-preroll-frame")]
    fn connect_show_preroll_frame_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_preroll_frame_trampoline<
            P: IsA<VideoSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstVideoSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(VideoSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::show-preroll-frame\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_show_preroll_frame_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<VideoSink>> VideoSinkExt for O {}