// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use gst;
use gst_base_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;

glib_wrapper! {
    /// Manages a set of pads with the purpose of aggregating their buffers.
    /// Control is given to the subclass when all pads have data.
    ///
    ///  * Base class for mixers and muxers. Subclasses should at least implement
    ///  the `AggregatorClass.aggregate`() virtual method.
    ///
    ///  * Installs a `GstPadChainFunction`, a `GstPadEventFullFunction` and a
    ///  `GstPadQueryFunction` to queue all serialized data packets per sink pad.
    ///  Subclasses should not overwrite those, but instead implement
    ///  `AggregatorClass.sink_event`() and `AggregatorClass.sink_query`() as
    ///  needed.
    ///
    ///  * When data is queued on all pads, the aggregate vmethod is called.
    ///
    ///  * One can peek at the data on any given GstAggregatorPad with the
    ///  gst_aggregator_pad_peek_buffer () method, and remove it from the pad
    ///  with the gst_aggregator_pad_pop_buffer () method. When a buffer
    ///  has been taken with pop_buffer (), a new buffer can be queued
    ///  on that pad.
    ///
    ///  * If the subclass wishes to push a buffer downstream in its aggregate
    ///  implementation, it should do so through the
    ///  gst_aggregator_finish_buffer () method. This method will take care
    ///  of sending and ordering mandatory events such as stream start, caps
    ///  and segment.
    ///
    ///  * Same goes for EOS events, which should not be pushed directly by the
    ///  subclass, it should instead return GST_FLOW_EOS in its aggregate
    ///  implementation.
    ///
    ///  * Note that the aggregator logic regarding gap event handling is to turn
    ///  these into gap buffers with matching PTS and duration. It will also
    ///  flag these buffers with GST_BUFFER_FLAG_GAP and GST_BUFFER_FLAG_DROPPABLE
    ///  to ease their identification and subsequent processing.
    ///
    ///  * Subclasses must use (a subclass of) `AggregatorPad` for both their
    ///  sink and source pads.
    ///  See `gst::ElementClass::add_static_pad_template_with_gtype`.
    ///
    /// This class used to live in gst-plugins-bad and was moved to core.
    ///
    /// Feature: `v1_14`
    ///
    /// # Implements
    ///
    /// [`AggregatorExt`](trait.AggregatorExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct Aggregator(Object<gst_base_sys::GstAggregator, gst_base_sys::GstAggregatorClass, AggregatorClass>) @extends gst::Element, gst::Object;

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

unsafe impl Send for Aggregator {}
unsafe impl Sync for Aggregator {}

pub const NONE_AGGREGATOR: Option<&Aggregator> = None;

/// Trait containing all `Aggregator` methods.
///
/// Feature: `v1_14`
///
/// # Implementors
///
/// [`Aggregator`](struct.Aggregator.html)
pub trait AggregatorExt: 'static {
    //#[cfg(any(feature = "v1_14", feature = "dox"))]
    //fn get_allocator(&self, allocator: /*Ignored*/gst::Allocator, params: /*Ignored*/gst::AllocationParams);

    ///
    /// Feature: `v1_14`
    ///
    ///
    /// # Returns
    ///
    /// the instance of the `gst::BufferPool` used
    /// by `trans`; free it after use it
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn get_buffer_pool(&self) -> Option<gst::BufferPool>;

    /// Retrieves the latency values reported by `self` in response to the latency
    /// query, or `GST_CLOCK_TIME_NONE` if there is not live source connected and the element
    /// will not wait for the clock.
    ///
    /// Typically only called by subclasses.
    ///
    /// Feature: `v1_14`
    ///
    ///
    /// # Returns
    ///
    /// The latency or `GST_CLOCK_TIME_NONE` if the element does not sync
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn get_latency(&self) -> gst::ClockTime;

    /// Lets `Aggregator` sub-classes tell the baseclass what their internal
    /// latency is. Will also post a LATENCY message on the bus so the pipeline
    /// can reconfigure its global latency.
    ///
    /// Feature: `v1_14`
    ///
    /// ## `min_latency`
    /// minimum latency
    /// ## `max_latency`
    /// maximum latency
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime);

    /// Sets the caps to be used on the src pad.
    ///
    /// Feature: `v1_14`
    ///
    /// ## `caps`
    /// The `gst::Caps` to set on the src pad.
    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn set_src_caps(&self, caps: &gst::Caps);

    /// This is a simple `Aggregator::get_next_time` implementation that
    /// just looks at the `gst::Segment` on the srcpad of the aggregator and bases
    /// the next time on the running time there.
    ///
    /// This is the desired behaviour in most cases where you have a live source
    /// and you have a dead line based aggregator subclass.
    ///
    /// Feature: `v1_16`
    ///
    ///
    /// # Returns
    ///
    /// The running time based on the position
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn simple_get_next_time(&self) -> gst::ClockTime;

    fn get_property_start_time(&self) -> u64;

    fn set_property_start_time(&self, start_time: u64);

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

    fn connect_property_start_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

impl<O: IsA<Aggregator>> AggregatorExt for O {
    //#[cfg(any(feature = "v1_14", feature = "dox"))]
    //fn get_allocator(&self, allocator: /*Ignored*/gst::Allocator, params: /*Ignored*/gst::AllocationParams) {
    //    unsafe { TODO: call gst_base_sys:gst_aggregator_get_allocator() }
    //}

    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn get_buffer_pool(&self) -> Option<gst::BufferPool> {
        unsafe {
            from_glib_full(gst_base_sys::gst_aggregator_get_buffer_pool(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
        unsafe {
            gst_base_sys::gst_aggregator_set_latency(
                self.as_ref().to_glib_none().0,
                min_latency.to_glib(),
                max_latency.to_glib(),
            );
        }
    }

    #[cfg(any(feature = "v1_14", feature = "dox"))]
    fn set_src_caps(&self, caps: &gst::Caps) {
        unsafe {
            gst_base_sys::gst_aggregator_set_src_caps(
                self.as_ref().to_glib_none().0,
                caps.to_glib_none().0,
            );
        }
    }

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

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

    fn set_property_start_time(&self, start_time: u64) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"start-time\0".as_ptr() as *const _,
                Value::from(&start_time).to_glib_none().0,
            );
        }
    }

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

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