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

glib::wrapper! {
    /// This base class is for filter elements that process data. Elements
    /// that are suitable for implementation using [`crate::BaseTransform`] are ones
    /// where the size and caps of the output is known entirely from the input
    /// caps and buffer sizes. These include elements that directly transform
    /// one buffer into another, modify the contents of a buffer in-place, as
    /// well as elements that collate multiple input buffers into one output buffer,
    /// or that expand one input buffer into multiple output buffers. See below
    /// for more concrete use cases.
    ///
    /// It provides for:
    ///
    /// * one sinkpad and one srcpad
    /// * Possible formats on sink and source pad implemented
    ///  with custom transform_caps function. By default uses
    ///  same format on sink and source.
    ///
    /// * Handles state changes
    /// * Does flushing
    /// * Push mode
    /// * Pull mode if the sub-class transform can operate on arbitrary data
    ///
    /// # Use Cases
    ///
    /// ## Passthrough mode
    ///
    ///  * Element has no interest in modifying the buffer. It may want to inspect it,
    ///  in which case the element should have a transform_ip function. If there
    ///  is no transform_ip function in passthrough mode, the buffer is pushed
    ///  intact.
    ///
    ///  * The [`crate::BaseTransformClass.passthrough_on_same_caps`] variable
    ///  will automatically set/unset passthrough based on whether the
    ///  element negotiates the same caps on both pads.
    ///
    ///  * [`crate::BaseTransformClass.passthrough_on_same_caps`] on an element that
    ///  doesn't implement a transform_caps function is useful for elements that
    ///  only inspect data (such as level)
    ///
    ///  * Example elements
    ///
    ///  * Level
    ///  * Videoscale, audioconvert, videoconvert, audioresample in certain modes.
    ///
    /// ## Modifications in-place - input buffer and output buffer are the same thing.
    ///
    /// * The element must implement a transform_ip function.
    /// * Output buffer size must <= input buffer size
    /// * If the always_in_place flag is set, non-writable buffers will be copied
    ///  and passed to the transform_ip function, otherwise a new buffer will be
    ///  created and the transform function called.
    ///
    /// * Incoming writable buffers will be passed to the transform_ip function
    ///  immediately.
    /// * only implementing transform_ip and not transform implies always_in_place = [`true`]
    ///
    ///  * Example elements:
    ///  * Volume
    ///  * Audioconvert in certain modes (signed/unsigned conversion)
    ///  * videoconvert in certain modes (endianness swapping)
    ///
    /// ## Modifications only to the caps/metadata of a buffer
    ///
    /// * The element does not require writable data, but non-writable buffers
    ///  should be subbuffered so that the meta-information can be replaced.
    ///
    /// * Elements wishing to operate in this mode should replace the
    ///  prepare_output_buffer method to create subbuffers of the input buffer
    ///  and set always_in_place to [`true`]
    ///
    /// * Example elements
    ///  * Capsfilter when setting caps on outgoing buffers that have
    ///  none.
    ///  * identity when it is going to re-timestamp buffers by
    ///  datarate.
    ///
    /// ## Normal mode
    ///  * always_in_place flag is not set, or there is no transform_ip function
    ///  * Element will receive an input buffer and output buffer to operate on.
    ///  * Output buffer is allocated by calling the prepare_output_buffer function.
    ///  * Example elements:
    ///  * Videoscale, videoconvert, audioconvert when doing
    ///  scaling/conversions
    ///
    /// ## Special output buffer allocations
    ///  * Elements which need to do special allocation of their output buffers
    ///  beyond allocating output buffers via the negotiated allocator or
    ///  buffer pool should implement the prepare_output_buffer method.
    ///
    ///  * Example elements:
    ///  * efence
    ///
    /// # Sub-class settable flags on GstBaseTransform
    ///
    /// * passthrough
    ///
    ///  * Implies that in the current configuration, the sub-class is not interested in modifying the buffers.
    ///  * Elements which are always in passthrough mode whenever the same caps has been negotiated on both pads can set the class variable passthrough_on_same_caps to have this behaviour automatically.
    ///
    /// * always_in_place
    ///  * Determines whether a non-writable buffer will be copied before passing
    ///  to the transform_ip function.
    ///
    ///  * Implied [`true`] if no transform function is implemented.
    ///  * Implied [`false`] if ONLY transform function is implemented.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`trait@crate::prelude::BaseTransformExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::ObjectExt`], [`trait@glib::object::ObjectExt`], [`trait@crate::prelude::BaseTransformExtManual`]
    pub struct BaseTransform(Object<ffi::GstBaseTransform, ffi::GstBaseTransformClass>) @extends gst::Element, gst::Object;

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

unsafe impl Send for BaseTransform {}
unsafe impl Sync for BaseTransform {}

pub const NONE_BASE_TRANSFORM: Option<&BaseTransform> = None;

/// Trait containing all `BaseTransform` methods.
///
/// # Implementors
///
/// [`struct@crate::BaseTransform`]
pub trait BaseTransformExt: 'static {
    //#[doc(alias = "gst_base_transform_get_allocator")]
    //#[doc(alias = "get_allocator")]
    //fn allocator(&self, allocator: /*Ignored*/Option<gst::Allocator>, params: /*Ignored*/gst::AllocationParams);

    ///
    /// # Returns
    ///
    /// the instance of the [`crate::gst::BufferPool`] used
    /// by `self`; free it after use
    #[doc(alias = "gst_base_transform_get_buffer_pool")]
    #[doc(alias = "get_buffer_pool")]
    fn buffer_pool(&self) -> Option<gst::BufferPool>;

    /// See if `self` is configured as a in_place transform.
    ///
    /// # Returns
    ///
    /// [`true`] if the transform is configured in in_place mode.
    ///
    /// MT safe.
    #[doc(alias = "gst_base_transform_is_in_place")]
    fn is_in_place(&self) -> bool;

    /// See if `self` is configured as a passthrough transform.
    ///
    /// # Returns
    ///
    /// [`true`] if the transform is configured in passthrough mode.
    ///
    /// MT safe.
    #[doc(alias = "gst_base_transform_is_passthrough")]
    fn is_passthrough(&self) -> bool;

    /// Queries if the transform will handle QoS.
    ///
    /// # Returns
    ///
    /// [`true`] if QoS is enabled.
    ///
    /// MT safe.
    #[doc(alias = "gst_base_transform_is_qos_enabled")]
    fn is_qos_enabled(&self) -> bool;

    /// Negotiates src pad caps with downstream elements if the source pad is
    /// marked as needing reconfiguring. Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in
    /// any case. But marks it again if negotiation fails.
    ///
    /// Do not call this in the [`crate::GstBaseTransformClass.transform()`] or
    /// [`crate::GstBaseTransformClass.transform_ip()`] vmethod. Call this in
    /// [`crate::GstBaseTransformClass.submit_input_buffer()`],
    /// [`crate::GstBaseTransformClass.prepare_output_buffer()`] or in
    /// [`crate::GstBaseTransformClass.generate_output()`] _before_ any output buffer is
    /// allocated.
    ///
    /// It will be default be called when handling an ALLOCATION query or at the
    /// very beginning of the default [`crate::GstBaseTransformClass.submit_input_buffer()`]
    /// implementation.
    ///
    /// # Returns
    ///
    /// [`true`] if the negotiation succeeded, else [`false`].
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_base_transform_reconfigure")]
    fn reconfigure(&self) -> bool;

    /// Instructs `self` to request renegotiation upstream. This function is
    /// typically called after properties on the transform were set that
    /// influence the input format.
    #[doc(alias = "gst_base_transform_reconfigure_sink")]
    fn reconfigure_sink(&self);

    /// Instructs `self` to renegotiate a new downstream transform on the next
    /// buffer. This function is typically called after properties on the transform
    /// were set that influence the output format.
    #[doc(alias = "gst_base_transform_reconfigure_src")]
    fn reconfigure_src(&self);

    /// If `gap_aware` is [`false`] (the default), output buffers will have the
    /// [`crate::gst::BufferFlags::Gap`] flag unset.
    ///
    /// If set to [`true`], the element must handle output buffers with this flag set
    /// correctly, i.e. it can assume that the buffer contains neutral data but must
    /// unset the flag if the output is no neutral data.
    ///
    /// MT safe.
    /// ## `gap_aware`
    /// New state
    #[doc(alias = "gst_base_transform_set_gap_aware")]
    fn set_gap_aware(&self, gap_aware: bool);

    /// Determines whether a non-writable buffer will be copied before passing
    /// to the transform_ip function.
    ///
    ///  * Always [`true`] if no transform function is implemented.
    ///  * Always [`false`] if ONLY transform function is implemented.
    ///
    /// MT safe.
    /// ## `in_place`
    /// Boolean value indicating that we would like to operate
    /// on in_place buffers.
    #[doc(alias = "gst_base_transform_set_in_place")]
    fn set_in_place(&self, in_place: bool);

    /// Set passthrough mode for this filter by default. This is mostly
    /// useful for filters that do not care about negotiation.
    ///
    /// Always [`true`] for filters which don't implement either a transform
    /// or transform_ip or generate_output method.
    ///
    /// MT safe.
    /// ## `passthrough`
    /// boolean indicating passthrough mode.
    #[doc(alias = "gst_base_transform_set_passthrough")]
    fn set_passthrough(&self, passthrough: bool);

    /// If `prefer_passthrough` is [`true`] (the default), `self` will check and
    /// prefer passthrough caps from the list of caps returned by the
    /// transform_caps vmethod.
    ///
    /// If set to [`false`], the element must order the caps returned from the
    /// transform_caps function in such a way that the preferred format is
    /// first in the list. This can be interesting for transforms that can do
    /// passthrough transforms but prefer to do something else, like a
    /// capsfilter.
    ///
    /// MT safe.
    /// ## `prefer_passthrough`
    /// New state
    #[doc(alias = "gst_base_transform_set_prefer_passthrough")]
    fn set_prefer_passthrough(&self, prefer_passthrough: bool);

    /// Enable or disable QoS handling in the transform.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    #[doc(alias = "gst_base_transform_set_qos_enabled")]
    fn set_qos_enabled(&self, enabled: bool);

    /// Set the QoS parameters in the transform. This function is called internally
    /// when a QOS event is received but subclasses can provide custom information
    /// when needed.
    ///
    /// MT safe.
    /// ## `proportion`
    /// the proportion
    /// ## `diff`
    /// the diff against the clock
    /// ## `timestamp`
    /// the timestamp of the buffer generating the QoS expressed in
    /// running_time.
    #[doc(alias = "gst_base_transform_update_qos")]
    fn update_qos(&self, proportion: f64, diff: gst::ClockTimeDiff, timestamp: gst::ClockTime);

    /// Updates the srcpad caps and sends the caps downstream. This function
    /// can be used by subclasses when they have already negotiated their caps
    /// but found a change in them (or computed new information). This way,
    /// they can notify downstream about that change without losing any
    /// buffer.
    /// ## `updated_caps`
    /// An updated version of the srcpad caps to be pushed
    /// downstream
    ///
    /// # Returns
    ///
    /// [`true`] if the caps could be sent downstream [`false`] otherwise
    #[doc(alias = "gst_base_transform_update_src_caps")]
    fn update_src_caps(&self, updated_caps: &gst::Caps) -> Result<(), glib::error::BoolError>;

    fn is_qos(&self) -> bool;

    fn set_qos(&self, qos: bool);

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

impl<O: IsA<BaseTransform>> BaseTransformExt for O {
    //fn allocator(&self, allocator: /*Ignored*/Option<gst::Allocator>, params: /*Ignored*/gst::AllocationParams) {
    //    unsafe { TODO: call ffi:gst_base_transform_get_allocator() }
    //}

    fn buffer_pool(&self) -> Option<gst::BufferPool> {
        unsafe {
            from_glib_full(ffi::gst_base_transform_get_buffer_pool(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

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

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

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

    fn reconfigure_sink(&self) {
        unsafe {
            ffi::gst_base_transform_reconfigure_sink(self.as_ref().to_glib_none().0);
        }
    }

    fn reconfigure_src(&self) {
        unsafe {
            ffi::gst_base_transform_reconfigure_src(self.as_ref().to_glib_none().0);
        }
    }

    fn set_gap_aware(&self, gap_aware: bool) {
        unsafe {
            ffi::gst_base_transform_set_gap_aware(
                self.as_ref().to_glib_none().0,
                gap_aware.into_glib(),
            );
        }
    }

    fn set_in_place(&self, in_place: bool) {
        unsafe {
            ffi::gst_base_transform_set_in_place(
                self.as_ref().to_glib_none().0,
                in_place.into_glib(),
            );
        }
    }

    fn set_passthrough(&self, passthrough: bool) {
        unsafe {
            ffi::gst_base_transform_set_passthrough(
                self.as_ref().to_glib_none().0,
                passthrough.into_glib(),
            );
        }
    }

    fn set_prefer_passthrough(&self, prefer_passthrough: bool) {
        unsafe {
            ffi::gst_base_transform_set_prefer_passthrough(
                self.as_ref().to_glib_none().0,
                prefer_passthrough.into_glib(),
            );
        }
    }

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

    fn update_qos(&self, proportion: f64, diff: gst::ClockTimeDiff, timestamp: gst::ClockTime) {
        unsafe {
            ffi::gst_base_transform_update_qos(
                self.as_ref().to_glib_none().0,
                proportion,
                diff,
                timestamp.into_glib(),
            );
        }
    }

    fn update_src_caps(&self, updated_caps: &gst::Caps) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_base_transform_update_src_caps(
                    self.as_ref().to_glib_none().0,
                    updated_caps.to_glib_none().0
                ),
                "Failed to update src caps"
            )
        }
    }

    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 = "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::GstBaseTransform,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<BaseTransform>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseTransform::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),
            )
        }
    }
}