// 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! {
    /// This base class is for parser elements that process data and splits it
    /// into separate audio/video/whatever frames.
    ///
    /// It provides for:
    ///
    ///  * provides one sink pad and one source pad
    ///  * handles state changes
    ///  * can operate in pull mode or push mode
    ///  * handles seeking in both modes
    ///  * handles events (SEGMENT/EOS/FLUSH)
    ///  * handles queries (POSITION/DURATION/SEEKING/FORMAT/CONVERT)
    ///  * handles flushing
    ///
    /// The purpose of this base class is to provide the basic functionality of
    /// a parser and share a lot of rather complex code.
    ///
    /// # Description of the parsing mechanism:
    ///
    /// ## Set-up phase
    ///
    ///  * `BaseParse` calls `BaseParseClass.start`() to inform subclass
    ///  that data processing is about to start now.
    ///
    ///  * `BaseParse` class calls `BaseParseClass.set_sink_caps`() to
    ///  inform the subclass about incoming sinkpad caps. Subclass could
    ///  already set the srcpad caps accordingly, but this might be delayed
    ///  until calling `BaseParse::finish_frame` with a non-queued frame.
    ///
    ///  * At least at this point subclass needs to tell the `BaseParse` class
    ///  how big data chunks it wants to receive (minimum frame size ). It can
    ///  do this with `BaseParseExt::set_min_frame_size`.
    ///
    ///  * `BaseParse` class sets up appropriate data passing mode (pull/push)
    ///  and starts to process the data.
    ///
    /// ## Parsing phase
    ///
    ///  * `BaseParse` gathers at least min_frame_size bytes of data either
    ///  by pulling it from upstream or collecting buffers in an internal
    ///  `Adapter`.
    ///
    ///  * A buffer of (at least) min_frame_size bytes is passed to subclass
    ///  with `BaseParseClass.handle_frame`(). Subclass checks the contents
    ///  and can optionally return `gst::FlowReturn::Ok` along with an amount of data
    ///  to be skipped to find a valid frame (which will result in a
    ///  subsequent DISCONT). If, otherwise, the buffer does not hold a
    ///  complete frame, `BaseParseClass.handle_frame`() can merely return
    ///  and will be called again when additional data is available. In push
    ///  mode this amounts to an additional input buffer (thus minimal
    ///  additional latency), in pull mode this amounts to some arbitrary
    ///  reasonable buffer size increase.
    ///
    ///  Of course, `BaseParseExt::set_min_frame_size` could also be used if
    ///  a very specific known amount of additional data is required. If,
    ///  however, the buffer holds a complete valid frame, it can pass the
    ///  size of this frame to `BaseParse::finish_frame`.
    ///
    ///  If acting as a converter, it can also merely indicate consumed input
    ///  data while simultaneously providing custom output data. Note that
    ///  baseclass performs some processing (such as tracking overall consumed
    ///  data rate versus duration) for each finished frame, but other state
    ///  is only updated upon each call to `BaseParseClass.handle_frame`()
    ///  (such as tracking upstream input timestamp).
    ///
    ///  Subclass is also responsible for setting the buffer metadata
    ///  (e.g. buffer timestamp and duration, or keyframe if applicable).
    ///  (although the latter can also be done by `BaseParse` if it is
    ///  appropriately configured, see below). Frame is provided with
    ///  timestamp derived from upstream (as much as generally possible),
    ///  duration obtained from configuration (see below), and offset
    ///  if meaningful (in pull mode).
    ///
    ///  Note that `BaseParseClass.handle_frame`() might receive any small
    ///  amount of input data when leftover data is being drained (e.g. at
    ///  EOS).
    ///
    ///  * As part of finish frame processing, just prior to actually pushing
    ///  the buffer in question, it is passed to
    ///  `BaseParseClass.pre_push_frame`() which gives subclass yet one last
    ///  chance to examine buffer metadata, or to send some custom (tag)
    ///  events, or to perform custom (segment) filtering.
    ///
    ///  * During the parsing process `BaseParseClass` will handle both srcpad
    ///  and sinkpad events. They will be passed to subclass if
    ///  `BaseParseClass.sink_event`() or `BaseParseClass.src_event`()
    ///  implementations have been provided.
    ///
    /// ## Shutdown phase
    ///
    /// * `BaseParse` class calls `BaseParseClass.stop`() to inform the
    ///  subclass that data parsing will be stopped.
    ///
    /// Subclass is responsible for providing pad template caps for source and
    /// sink pads. The pads need to be named "sink" and "src". It also needs to
    /// set the fixed caps on srcpad, when the format is ensured (e.g. when
    /// base class calls subclass' `BaseParseClass.set_sink_caps`() function).
    ///
    /// This base class uses `gst::Format::Default` as a meaning of frames. So,
    /// subclass conversion routine needs to know that conversion from
    /// `gst::Format::Time` to `gst::Format::Default` must return the
    /// frame number that can be found from the given byte position.
    ///
    /// `BaseParse` uses subclasses conversion methods also for seeking (or
    /// otherwise uses its own default one, see also below).
    ///
    /// Subclass `start` and `stop` functions will be called to inform the beginning
    /// and end of data processing.
    ///
    /// Things that subclass need to take care of:
    ///
    /// * Provide pad templates
    /// * Fixate the source pad caps when appropriate
    /// * Inform base class how big data chunks should be retrieved. This is
    ///  done with `BaseParseExt::set_min_frame_size` function.
    /// * Examine data chunks passed to subclass with
    ///  `BaseParseClass.handle_frame`() and pass proper frame(s) to
    ///  `BaseParse::finish_frame`, and setting src pad caps and timestamps
    ///  on frame.
    /// * Provide conversion functions
    /// * Update the duration information with `BaseParse::set_duration`
    /// * Optionally passthrough using `BaseParseExt::set_passthrough`
    /// * Configure various baseparse parameters using
    ///  `BaseParseExt::set_average_bitrate`, `BaseParseExt::set_syncable`
    ///  and `BaseParse::set_frame_rate`.
    ///
    /// * In particular, if subclass is unable to determine a duration, but
    ///  parsing (or specs) yields a frames per seconds rate, then this can be
    ///  provided to `BaseParse` to enable it to cater for buffer time
    ///  metadata (which will be taken from upstream as much as
    ///  possible). Internally keeping track of frame durations and respective
    ///  sizes that have been pushed provides `BaseParse` with an estimated
    ///  bitrate. A default `BaseParseClass.convert`() (used if not
    ///  overridden) will then use these rates to perform obvious conversions.
    ///  These rates are also used to update (estimated) duration at regular
    ///  frame intervals.
    ///
    /// # Implements
    ///
    /// [`BaseParseExt`](trait.BaseParseExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`BaseParseExtManual`](prelude/trait.BaseParseExtManual.html)
    pub struct BaseParse(Object<gst_base_sys::GstBaseParse, gst_base_sys::GstBaseParseClass, BaseParseClass>) @extends gst::Element, gst::Object;

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

unsafe impl Send for BaseParse {}
unsafe impl Sync for BaseParse {}

pub const NONE_BASE_PARSE: Option<&BaseParse> = None;

/// Trait containing all `BaseParse` methods.
///
/// # Implementors
///
/// [`BaseParse`](struct.BaseParse.html)
pub trait BaseParseExt: 'static {
    /// Adds an entry to the index associating `offset` to `ts`. It is recommended
    /// to only add keyframe entries. `force` allows to bypass checks, such as
    /// whether the stream is (upstream) seekable, another entry is already "close"
    /// to the new entry, etc.
    /// ## `offset`
    /// offset of entry
    /// ## `ts`
    /// timestamp associated with offset
    /// ## `key`
    /// whether entry refers to keyframe
    /// ## `force`
    /// add entry disregarding sanity checks
    ///
    /// # Returns
    ///
    /// `gboolean` indicating whether entry was added
    fn add_index_entry(&self, offset: u64, ts: gst::ClockTime, key: bool, force: bool) -> bool;

    /// Drains the adapter until it is empty. It decreases the min_frame_size to
    /// match the current adapter size and calls chain method until the adapter
    /// is emptied or chain returns with error.
    ///
    /// Feature: `v1_12`
    ///
    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn drain(&self);

    /// Sets the parser subclass's tags and how they should be merged with any
    /// upstream stream tags. This will override any tags previously-set
    /// with `BaseParseExt::merge_tags`.
    ///
    /// Note that this is provided for convenience, and the subclass is
    /// not required to use this and can still do tag handling on its own.
    /// ## `tags`
    /// a `gst::TagList` to merge, or NULL to unset
    ///  previously-set tags
    /// ## `mode`
    /// the `gst::TagMergeMode` to use, usually `gst::TagMergeMode::Replace`
    fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode);

    /// Optionally sets the average bitrate detected in media (if non-zero),
    /// e.g. based on metadata, as it will be posted to the application.
    ///
    /// By default, announced average bitrate is estimated. The average bitrate
    /// is used to estimate the total duration of the stream and to estimate
    /// a seek position, if there's no index and the format is syncable
    /// (see `BaseParseExt::set_syncable`).
    /// ## `bitrate`
    /// average bitrate in bits/second
    fn set_average_bitrate(&self, bitrate: u32);

    /// Set if frames carry timing information which the subclass can (generally)
    /// parse and provide. In particular, intrinsic (rather than estimated) time
    /// can be obtained following a seek.
    /// ## `has_timing`
    /// whether frames carry timing information
    fn set_has_timing_info(&self, has_timing: bool);

    /// By default, the base class might try to infer PTS from DTS and vice
    /// versa. While this is generally correct for audio data, it may not
    /// be otherwise. Sub-classes implementing such formats should disable
    /// timestamp inferring.
    /// ## `infer_ts`
    /// `true` if parser should infer DTS/PTS from each other
    fn set_infer_ts(&self, infer_ts: bool);

    /// Sets the minimum and maximum (which may likely be equal) latency introduced
    /// by the parsing process. If there is such a latency, which depends on the
    /// particular parsing of the format, it typically corresponds to 1 frame duration.
    /// ## `min_latency`
    /// minimum parse latency
    /// ## `max_latency`
    /// maximum parse latency
    fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime);

    /// Subclass can use this function to tell the base class that it needs to
    /// be given buffers of at least `min_size` bytes.
    /// ## `min_size`
    /// Minimum size in bytes of the data that this base class should
    ///  give to subclass.
    fn set_min_frame_size(&self, min_size: u32);

    /// Set if the nature of the format or configuration does not allow (much)
    /// parsing, and the parser should operate in passthrough mode (which only
    /// applies when operating in push mode). That is, incoming buffers are
    /// pushed through unmodified, i.e. no `BaseParseClass.handle_frame`()
    /// will be invoked, but `BaseParseClass.pre_push_frame`() will still be
    /// invoked, so subclass can perform as much or as little is appropriate for
    /// passthrough semantics in `BaseParseClass.pre_push_frame`().
    /// ## `passthrough`
    /// `true` if parser should run in passthrough mode
    fn set_passthrough(&self, passthrough: bool);

    /// By default, the base class will guess PTS timestamps using a simple
    /// interpolation (previous timestamp + duration), which is incorrect for
    /// data streams with reordering, where PTS can go backward. Sub-classes
    /// implementing such formats should disable PTS interpolation.
    /// ## `pts_interpolate`
    /// `true` if parser should interpolate PTS timestamps
    fn set_pts_interpolation(&self, pts_interpolate: bool);

    /// Set if frame starts can be identified. This is set by default and
    /// determines whether seeking based on bitrate averages
    /// is possible for a format/stream.
    /// ## `syncable`
    /// set if frame starts can be identified
    fn set_syncable(&self, syncable: bool);

    /// This function should only be called from a `handle_frame` implementation.
    ///
    /// `BaseParse` creates initial timestamps for frames by using the last
    /// timestamp seen in the stream before the frame starts. In certain
    /// cases, the correct timestamps will occur in the stream after the
    /// start of the frame, but before the start of the actual picture data.
    /// This function can be used to set the timestamps based on the offset
    /// into the frame data that the picture starts.
    /// ## `offset`
    /// offset into current buffer
    fn set_ts_at_offset(&self, offset: usize);

    /// If set to `true`, baseparse will unconditionally force parsing of the
    /// incoming data. This can be required in the rare cases where the incoming
    /// side-data (caps, pts, dts, ...) is not trusted by the user and wants to
    /// force validation and parsing of the incoming data.
    /// If set to `false`, decision of whether to parse the data or not is up to
    /// the implementation (standard behaviour).
    fn get_property_disable_passthrough(&self) -> bool;

    /// If set to `true`, baseparse will unconditionally force parsing of the
    /// incoming data. This can be required in the rare cases where the incoming
    /// side-data (caps, pts, dts, ...) is not trusted by the user and wants to
    /// force validation and parsing of the incoming data.
    /// If set to `false`, decision of whether to parse the data or not is up to
    /// the implementation (standard behaviour).
    fn set_property_disable_passthrough(&self, disable_passthrough: bool);

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

impl<O: IsA<BaseParse>> BaseParseExt for O {
    fn add_index_entry(&self, offset: u64, ts: gst::ClockTime, key: bool, force: bool) -> bool {
        unsafe {
            from_glib(gst_base_sys::gst_base_parse_add_index_entry(
                self.as_ref().to_glib_none().0,
                offset,
                ts.to_glib(),
                key.to_glib(),
                force.to_glib(),
            ))
        }
    }

    #[cfg(any(feature = "v1_12", feature = "dox"))]
    fn drain(&self) {
        unsafe {
            gst_base_sys::gst_base_parse_drain(self.as_ref().to_glib_none().0);
        }
    }

    fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode) {
        unsafe {
            gst_base_sys::gst_base_parse_merge_tags(
                self.as_ref().to_glib_none().0,
                tags.to_glib_none().0,
                mode.to_glib(),
            );
        }
    }

    fn set_average_bitrate(&self, bitrate: u32) {
        unsafe {
            gst_base_sys::gst_base_parse_set_average_bitrate(
                self.as_ref().to_glib_none().0,
                bitrate,
            );
        }
    }

    fn set_has_timing_info(&self, has_timing: bool) {
        unsafe {
            gst_base_sys::gst_base_parse_set_has_timing_info(
                self.as_ref().to_glib_none().0,
                has_timing.to_glib(),
            );
        }
    }

    fn set_infer_ts(&self, infer_ts: bool) {
        unsafe {
            gst_base_sys::gst_base_parse_set_infer_ts(
                self.as_ref().to_glib_none().0,
                infer_ts.to_glib(),
            );
        }
    }

    fn set_latency(&self, min_latency: gst::ClockTime, max_latency: gst::ClockTime) {
        unsafe {
            gst_base_sys::gst_base_parse_set_latency(
                self.as_ref().to_glib_none().0,
                min_latency.to_glib(),
                max_latency.to_glib(),
            );
        }
    }

    fn set_min_frame_size(&self, min_size: u32) {
        unsafe {
            gst_base_sys::gst_base_parse_set_min_frame_size(
                self.as_ref().to_glib_none().0,
                min_size,
            );
        }
    }

    fn set_passthrough(&self, passthrough: bool) {
        unsafe {
            gst_base_sys::gst_base_parse_set_passthrough(
                self.as_ref().to_glib_none().0,
                passthrough.to_glib(),
            );
        }
    }

    fn set_pts_interpolation(&self, pts_interpolate: bool) {
        unsafe {
            gst_base_sys::gst_base_parse_set_pts_interpolation(
                self.as_ref().to_glib_none().0,
                pts_interpolate.to_glib(),
            );
        }
    }

    fn set_syncable(&self, syncable: bool) {
        unsafe {
            gst_base_sys::gst_base_parse_set_syncable(
                self.as_ref().to_glib_none().0,
                syncable.to_glib(),
            );
        }
    }

    fn set_ts_at_offset(&self, offset: usize) {
        unsafe {
            gst_base_sys::gst_base_parse_set_ts_at_offset(self.as_ref().to_glib_none().0, offset);
        }
    }

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

    fn set_property_disable_passthrough(&self, disable_passthrough: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"disable-passthrough\0".as_ptr() as *const _,
                Value::from(&disable_passthrough).to_glib_none().0,
            );
        }
    }

    fn connect_property_disable_passthrough_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_disable_passthrough_trampoline<
            P,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut gst_base_sys::GstBaseParse,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<BaseParse>,
        {
            let f: &F = &*(f as *const F);
            f(&BaseParse::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::disable-passthrough\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_disable_passthrough_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}