// 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;
use glib::object::IsA;
use glib::translate::*;
use gst;
use gst_video_sys;
use VideoCodecFrame;

glib_wrapper! {
    /// This base class is for video decoders turning encoded data into raw video
    /// frames.
    ///
    /// The GstVideoDecoder base class and derived subclasses should cooperate as
    /// follows:
    ///
    /// ## Configuration
    ///
    ///  * Initially, GstVideoDecoder calls `start` when the decoder element
    ///  is activated, which allows the subclass to perform any global setup.
    ///
    ///  * GstVideoDecoder calls `set_format` to inform the subclass of caps
    ///  describing input video data that it is about to receive, including
    ///  possibly configuration data.
    ///  While unlikely, it might be called more than once, if changing input
    ///  parameters require reconfiguration.
    ///
    ///  * Incoming data buffers are processed as needed, described in Data
    ///  Processing below.
    ///
    ///  * GstVideoDecoder calls `stop` at end of all processing.
    ///
    /// ## Data processing
    ///
    ///  * The base class gathers input data, and optionally allows subclass
    ///  to parse this into subsequently manageable chunks, typically
    ///  corresponding to and referred to as 'frames'.
    ///
    ///  * Each input frame is provided in turn to the subclass' `handle_frame`
    ///  callback.
    ///  The ownership of the frame is given to the `handle_frame` callback.
    ///
    ///  * If codec processing results in decoded data, the subclass should call
    ///  `VideoDecoder::finish_frame` to have decoded data pushed.
    ///  downstream. Otherwise, the subclass must call
    ///  `VideoDecoder::drop_frame`, to allow the base class to do timestamp
    ///  and offset tracking, and possibly to requeue the frame for a later
    ///  attempt in the case of reverse playback.
    ///
    /// ## Shutdown phase
    ///
    ///  * The GstVideoDecoder class calls `stop` to inform the subclass that data
    ///  parsing will be stopped.
    ///
    /// ## Additional Notes
    ///
    ///  * Seeking/Flushing
    ///
    ///  * When the pipeline is seeked or otherwise flushed, the subclass is
    ///  informed via a call to its `reset` callback, with the hard parameter
    ///  set to true. This indicates the subclass should drop any internal data
    ///  queues and timestamps and prepare for a fresh set of buffers to arrive
    ///  for parsing and decoding.
    ///
    ///  * End Of Stream
    ///
    ///  * At end-of-stream, the subclass `parse` function may be called some final
    ///  times with the at_eos parameter set to true, indicating that the element
    ///  should not expect any more data to be arriving, and it should parse and
    ///  remaining frames and call `VideoDecoder::have_frame` if possible.
    ///
    /// The 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 provide information about the ouptput caps, when they are known.
    /// This may be when the base class calls the subclass' `set_format` function,
    /// though it might be during decoding, before calling
    /// `VideoDecoder::finish_frame`. This is done via
    /// `VideoDecoder::set_output_state`
    ///
    /// The subclass is also responsible for providing (presentation) timestamps
    /// (likely based on corresponding input ones). If that is not applicable
    /// or possible, the base class provides limited framerate based interpolation.
    ///
    /// Similarly, the base class provides some limited (legacy) seeking support
    /// if specifically requested by the subclass, as full-fledged support
    /// should rather be left to upstream demuxer, parser or alike. This simple
    /// approach caters for seeking and duration reporting using estimated input
    /// bitrates. To enable it, a subclass should call
    /// `VideoDecoderExt::set_estimate_rate` to enable handling of incoming
    /// byte-streams.
    ///
    /// The base class provides some support for reverse playback, in particular
    /// in case incoming data is not packetized or upstream does not provide
    /// fragments on keyframe boundaries. However, the subclass should then be
    /// prepared for the parsing and frame processing stage to occur separately
    /// (in normal forward processing, the latter immediately follows the former),
    /// The subclass also needs to ensure the parsing stage properly marks
    /// keyframes, unless it knows the upstream elements will do so properly for
    /// incoming data.
    ///
    /// The bare minimum that a functional subclass needs to implement is:
    ///
    ///  * Provide pad templates
    ///  * Inform the base class of output caps via
    ///  `VideoDecoder::set_output_state`
    ///
    ///  * Parse input data, if it is not considered packetized from upstream
    ///  Data will be provided to `parse` which should invoke
    ///  `VideoDecoderExt::add_to_frame` and `VideoDecoder::have_frame` to
    ///  separate the data belonging to each video frame.
    ///
    ///  * Accept data in `handle_frame` and provide decoded results to
    ///  `VideoDecoder::finish_frame`, or call `VideoDecoder::drop_frame`.
    ///
    /// # Implements
    ///
    /// [`VideoDecoderExt`](trait.VideoDecoderExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct VideoDecoder(Object<gst_video_sys::GstVideoDecoder, gst_video_sys::GstVideoDecoderClass, VideoDecoderClass>) @extends gst::Element, gst::Object;

    match fn {
        get_type => || gst_video_sys::gst_video_decoder_get_type(),
    }
}

unsafe impl Send for VideoDecoder {}
unsafe impl Sync for VideoDecoder {}

pub const NONE_VIDEO_DECODER: Option<&VideoDecoder> = None;

/// Trait containing all `VideoDecoder` methods.
///
/// # Implementors
///
/// [`VideoDecoder`](struct.VideoDecoder.html)
pub trait VideoDecoderExt: 'static {
    /// Removes next `n_bytes` of input data and adds it to currently parsed frame.
    /// ## `n_bytes`
    /// the number of bytes to add
    fn add_to_frame(&self, n_bytes: i32);

    /// Helper function that allocates a buffer to hold a video frame for `self`'s
    /// current `VideoCodecState`.
    ///
    /// You should use `VideoDecoder::allocate_output_frame` instead of this
    /// function, if possible at all.
    ///
    /// # Returns
    ///
    /// allocated buffer, or NULL if no buffer could be
    ///  allocated (e.g. when downstream is flushing or shutting down)
    fn allocate_output_buffer(&self) -> Result<gst::Buffer, glib::BoolError>;

    ///
    /// # Returns
    ///
    /// the instance of the `gst::BufferPool` used
    /// by the decoder; free it after use it
    fn get_buffer_pool(&self) -> Option<gst::BufferPool>;

    ///
    /// # Returns
    ///
    /// currently configured byte to time conversion setting
    fn get_estimate_rate(&self) -> i32;

    /// Determines maximum possible decoding time for `frame` that will
    /// allow it to decode and arrive in time (as determined by QoS events).
    /// In particular, a negative result means decoding in time is no longer possible
    /// and should therefore occur as soon/skippy as possible.
    /// ## `frame`
    /// a `VideoCodecFrame`
    ///
    /// # Returns
    ///
    /// max decoding time.
    fn get_max_decode_time(&self, frame: &VideoCodecFrame) -> gst::ClockTimeDiff;

    ///
    /// # Returns
    ///
    /// currently configured decoder tolerated error count.
    fn get_max_errors(&self) -> i32;

    /// Queries decoder required format handling.
    ///
    /// # Returns
    ///
    /// `true` if required format handling is enabled.
    fn get_needs_format(&self) -> bool;

    /// Queries whether input data is considered packetized or not by the
    /// base class.
    ///
    /// # Returns
    ///
    /// TRUE if input data is considered packetized.
    fn get_packetized(&self) -> bool;

    /// Returns the number of bytes previously added to the current frame
    /// by calling `VideoDecoderExt::add_to_frame`.
    ///
    /// # Returns
    ///
    /// The number of bytes pending for the current frame
    fn get_pending_frame_size(&self) -> usize;

    ///
    /// # Returns
    ///
    /// The current QoS proportion.
    fn get_qos_proportion(&self) -> f64;

    /// Sets the audio decoder tags and how they should be merged with any
    /// upstream stream tags. This will override any tags previously-set
    /// with `gst_audio_decoder_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.
    ///
    /// MT safe.
    /// ## `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);

    /// Returns caps that express `caps` (or sink template caps if `caps` == NULL)
    /// restricted to resolution/format/... combinations supported by downstream
    /// elements.
    /// ## `caps`
    /// initial caps
    /// ## `filter`
    /// filter caps
    ///
    /// # Returns
    ///
    /// a `gst::Caps` owned by caller
    fn proxy_getcaps(&self, caps: Option<&gst::Caps>, filter: Option<&gst::Caps>) -> gst::Caps;

    /// Allows baseclass to perform byte to time estimated conversion.
    /// ## `enabled`
    /// whether to enable byte to time conversion
    fn set_estimate_rate(&self, enabled: bool);

    /// Sets numbers of tolerated decoder errors, where a tolerated one is then only
    /// warned about, but more than tolerated will lead to fatal error. You can set
    /// -1 for never returning fatal errors. Default is set to
    /// GST_VIDEO_DECODER_MAX_ERRORS.
    ///
    /// The '-1' option was added in 1.4
    /// ## `num`
    /// max tolerated errors
    fn set_max_errors(&self, num: i32);

    /// Configures decoder format needs. If enabled, subclass needs to be
    /// negotiated with format caps before it can process any data. It will then
    /// never be handed any data before it has been configured.
    /// Otherwise, it might be handed data without having been configured and
    /// is then expected being able to do so either by default
    /// or based on the input data.
    /// ## `enabled`
    /// new state
    fn set_needs_format(&self, enabled: bool);

    /// Allows baseclass to consider input data as packetized or not. If the
    /// input is packetized, then the `parse` method will not be called.
    /// ## `packetized`
    /// whether the input data should be considered as packetized.
    fn set_packetized(&self, packetized: bool);

    /// Lets `VideoDecoder` sub-classes decide if they want the sink pad
    /// to use the default pad query handler to reply to accept-caps queries.
    ///
    /// By setting this to true it is possible to further customize the default
    /// handler with `GST_PAD_SET_ACCEPT_INTERSECT` and
    /// `GST_PAD_SET_ACCEPT_TEMPLATE`
    /// ## `use_`
    /// if the default pad accept-caps query handling should be used
    fn set_use_default_pad_acceptcaps(&self, use_: bool);
}

impl<O: IsA<VideoDecoder>> VideoDecoderExt for O {
    fn add_to_frame(&self, n_bytes: i32) {
        unsafe {
            gst_video_sys::gst_video_decoder_add_to_frame(self.as_ref().to_glib_none().0, n_bytes);
        }
    }

    fn allocate_output_buffer(&self) -> Result<gst::Buffer, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_full(gst_video_sys::gst_video_decoder_allocate_output_buffer(
                self.as_ref().to_glib_none().0,
            ))
            .ok_or_else(|| glib_bool_error!("Failed to allocate output buffer"))
        }
    }

    fn get_buffer_pool(&self) -> Option<gst::BufferPool> {
        unsafe {
            from_glib_full(gst_video_sys::gst_video_decoder_get_buffer_pool(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_estimate_rate(&self) -> i32 {
        unsafe {
            gst_video_sys::gst_video_decoder_get_estimate_rate(self.as_ref().to_glib_none().0)
        }
    }

    fn get_max_decode_time(&self, frame: &VideoCodecFrame) -> gst::ClockTimeDiff {
        unsafe {
            gst_video_sys::gst_video_decoder_get_max_decode_time(
                self.as_ref().to_glib_none().0,
                frame.to_glib_none().0,
            )
        }
    }

    fn get_max_errors(&self) -> i32 {
        unsafe { gst_video_sys::gst_video_decoder_get_max_errors(self.as_ref().to_glib_none().0) }
    }

    fn get_needs_format(&self) -> bool {
        unsafe {
            from_glib(gst_video_sys::gst_video_decoder_get_needs_format(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_packetized(&self) -> bool {
        unsafe {
            from_glib(gst_video_sys::gst_video_decoder_get_packetized(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_pending_frame_size(&self) -> usize {
        unsafe {
            gst_video_sys::gst_video_decoder_get_pending_frame_size(self.as_ref().to_glib_none().0)
        }
    }

    fn get_qos_proportion(&self) -> f64 {
        unsafe {
            gst_video_sys::gst_video_decoder_get_qos_proportion(self.as_ref().to_glib_none().0)
        }
    }

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

    fn proxy_getcaps(&self, caps: Option<&gst::Caps>, filter: Option<&gst::Caps>) -> gst::Caps {
        unsafe {
            from_glib_full(gst_video_sys::gst_video_decoder_proxy_getcaps(
                self.as_ref().to_glib_none().0,
                caps.to_glib_none().0,
                filter.to_glib_none().0,
            ))
        }
    }

    fn set_estimate_rate(&self, enabled: bool) {
        unsafe {
            gst_video_sys::gst_video_decoder_set_estimate_rate(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_max_errors(&self, num: i32) {
        unsafe {
            gst_video_sys::gst_video_decoder_set_max_errors(self.as_ref().to_glib_none().0, num);
        }
    }

    fn set_needs_format(&self, enabled: bool) {
        unsafe {
            gst_video_sys::gst_video_decoder_set_needs_format(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_packetized(&self, packetized: bool) {
        unsafe {
            gst_video_sys::gst_video_decoder_set_packetized(
                self.as_ref().to_glib_none().0,
                packetized.to_glib(),
            );
        }
    }

    fn set_use_default_pad_acceptcaps(&self, use_: bool) {
        unsafe {
            gst_video_sys::gst_video_decoder_set_use_default_pad_acceptcaps(
                self.as_ref().to_glib_none().0,
                use_.to_glib(),
            );
        }
    }
}