// 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::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib_sys;
use gst;
use gst_audio_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
use AudioInfo;

glib_wrapper! {
    /// This base class is for audio encoders turning raw audio samples into
    /// encoded audio data.
    ///
    /// GstAudioEncoder and subclass should cooperate as follows.
    ///
    /// ## Configuration
    ///
    ///  * Initially, GstAudioEncoder calls `start` when the encoder element
    ///  is activated, which allows subclass to perform any global setup.
    ///
    ///  * GstAudioEncoder calls `set_format` to inform subclass of the format
    ///  of input audio data that it is about to receive. Subclass should
    ///  setup for encoding and configure various base class parameters
    ///  appropriately, notably those directing desired input data handling.
    ///  While unlikely, it might be called more than once, if changing input
    ///  parameters require reconfiguration.
    ///
    ///  * GstAudioEncoder calls `stop` at end of all processing.
    ///
    /// As of configuration stage, and throughout processing, GstAudioEncoder
    /// maintains various parameters that provide required context,
    /// e.g. describing the format of input audio data.
    /// Conversely, subclass can and should configure these context parameters
    /// to inform base class of its expectation w.r.t. buffer handling.
    ///
    /// ## Data processing
    ///
    ///  * Base class gathers input sample data (as directed by the context's
    ///  frame_samples and frame_max) and provides this to subclass' `handle_frame`.
    ///  * If codec processing results in encoded data, subclass should call
    ///  `AudioEncoder::finish_frame` to have encoded data pushed
    ///  downstream. Alternatively, it might also call
    ///  `AudioEncoder::finish_frame` (with a NULL buffer and some number of
    ///  dropped samples) to indicate dropped (non-encoded) samples.
    ///  * Just prior to actually pushing a buffer downstream,
    ///  it is passed to `pre_push`.
    ///  * During the parsing process GstAudioEncoderClass will handle both
    ///  srcpad and sinkpad events. Sink events will be passed to subclass
    ///  if `event` callback has been provided.
    ///
    /// ## Shutdown phase
    ///
    ///  * GstAudioEncoder class calls `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. This
    /// is typically when base class calls subclass' `set_format` function, though
    /// it might be delayed until calling `AudioEncoder::finish_frame`.
    ///
    /// In summary, above process should have subclass concentrating on
    /// codec data processing while leaving other matters to base class,
    /// such as most notably timestamp handling. While it may exert more control
    /// in this area (see e.g. `pre_push`), it is very much not recommended.
    ///
    /// In particular, base class will either favor tracking upstream timestamps
    /// (at the possible expense of jitter) or aim to arrange for a perfect stream of
    /// output timestamps, depending on `AudioEncoder:perfect-timestamp`.
    /// However, in the latter case, the input may not be so perfect or ideal, which
    /// is handled as follows. An input timestamp is compared with the expected
    /// timestamp as dictated by input sample stream and if the deviation is less
    /// than `AudioEncoder:tolerance`, the deviation is discarded.
    /// Otherwise, it is considered a discontuinity and subsequent output timestamp
    /// is resynced to the new position after performing configured discontinuity
    /// processing. In the non-perfect-timestamp case, an upstream variation
    /// exceeding tolerance only leads to marking DISCONT on subsequent outgoing
    /// (while timestamps are adjusted to upstream regardless of variation).
    /// While DISCONT is also marked in the perfect-timestamp case, this one
    /// optionally (see `AudioEncoder:hard-resync`)
    /// performs some additional steps, such as clipping of (early) input samples
    /// or draining all currently remaining input data, depending on the direction
    /// of the discontuinity.
    ///
    /// If perfect timestamps are arranged, it is also possible to request baseclass
    /// (usually set by subclass) to provide additional buffer metadata (in OFFSET
    /// and OFFSET_END) fields according to granule defined semantics currently
    /// needed by oggmux. Specifically, OFFSET is set to granulepos (= sample count
    /// including buffer) and OFFSET_END to corresponding timestamp (as determined
    /// by same sample count and sample rate).
    ///
    /// Things that subclass need to take care of:
    ///
    ///  * Provide pad templates
    ///  * Set source pad caps when appropriate
    ///  * Inform base class of buffer processing needs using context's
    ///  frame_samples and frame_bytes.
    ///  * Set user-configurable properties to sane defaults for format and
    ///  implementing codec at hand, e.g. those controlling timestamp behaviour
    ///  and discontinuity processing.
    ///  * Accept data in `handle_frame` and provide encoded results to
    ///  `AudioEncoder::finish_frame`.
    ///
    /// # Implements
    ///
    /// [`AudioEncoderExt`](trait.AudioEncoderExt.html), [`gst::ElementExt`](../gst/trait.ElementExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct AudioEncoder(Object<gst_audio_sys::GstAudioEncoder, gst_audio_sys::GstAudioEncoderClass, AudioEncoderClass>) @extends gst::Element, gst::Object;

    match fn {
        get_type => || gst_audio_sys::gst_audio_encoder_get_type(),
    }
}

unsafe impl Send for AudioEncoder {}
unsafe impl Sync for AudioEncoder {}

pub const NONE_AUDIO_ENCODER: Option<&AudioEncoder> = None;

/// Trait containing all `AudioEncoder` methods.
///
/// # Implementors
///
/// [`AudioEncoder`](struct.AudioEncoder.html)
pub trait AudioEncoderExt: 'static {
    /// Helper function that allocates a buffer to hold an encoded audio frame
    /// for `self`'s current output format.
    /// ## `size`
    /// size of the buffer
    ///
    /// # Returns
    ///
    /// allocated buffer
    fn allocate_output_buffer(&self, size: usize) -> Result<gst::Buffer, glib::BoolError>;

    ///
    /// # Returns
    ///
    /// a `AudioInfo` describing the input audio format
    fn get_audio_info(&self) -> Option<AudioInfo>;

    /// Queries encoder drain handling.
    ///
    /// # Returns
    ///
    /// TRUE if drainable handling is enabled.
    ///
    /// MT safe.
    fn get_drainable(&self) -> bool;

    ///
    /// # Returns
    ///
    /// currently configured maximum handled frames
    fn get_frame_max(&self) -> i32;

    ///
    /// # Returns
    ///
    /// currently maximum requested samples per frame
    fn get_frame_samples_max(&self) -> i32;

    ///
    /// # Returns
    ///
    /// currently minimum requested samples per frame
    fn get_frame_samples_min(&self) -> i32;

    /// Queries encoder hard minimum handling.
    ///
    /// # Returns
    ///
    /// TRUE if hard minimum handling is enabled.
    ///
    /// MT safe.
    fn get_hard_min(&self) -> bool;

    fn get_hard_resync(&self) -> bool;

    ///
    /// # Returns
    ///
    /// currently configured encoder lookahead
    fn get_lookahead(&self) -> i32;

    /// Queries if the encoder will handle granule marking.
    ///
    /// # Returns
    ///
    /// TRUE if granule marking is enabled.
    ///
    /// MT safe.
    fn get_mark_granule(&self) -> bool;

    /// Queries encoder perfect timestamp behaviour.
    ///
    /// # Returns
    ///
    /// TRUE if perfect timestamp setting enabled.
    ///
    /// MT safe.
    fn get_perfect_timestamp(&self) -> bool;

    /// Queries current audio jitter tolerance threshold.
    ///
    /// # Returns
    ///
    /// encoder audio jitter tolerance threshold.
    ///
    /// MT safe.
    fn get_tolerance(&self) -> gst::ClockTime;

    /// Sets the audio encoder tags and how they should be merged with any
    /// upstream stream tags. This will override any tags previously-set
    /// with `AudioEncoderExt::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 channel/rate combinations supported by downstream elements
    /// (e.g. muxers).
    /// ## `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;

    /// Sets a caps in allocation query which are different from the set
    /// pad's caps. Use this function before calling
    /// `AudioEncoder::negotiate`. Setting to `None` the allocation
    /// query will use the caps from the pad.
    ///
    /// Feature: `v1_10`
    ///
    /// ## `allocation_caps`
    /// a `gst::Caps` or `None`
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn set_allocation_caps(&self, allocation_caps: Option<&gst::Caps>);

    /// Configures encoder drain handling. If drainable, subclass might
    /// be handed a NULL buffer to have it return any leftover encoded data.
    /// Otherwise, it is not considered so capable and will only ever be passed
    /// real data.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    fn set_drainable(&self, enabled: bool);

    /// Sets max number of frames accepted at once (assumed minimally 1).
    /// Requires `frame_samples_min` and `frame_samples_max` to be the equal.
    ///
    /// Note: This value will be reset to 0 every time before
    /// `AudioEncoderClass.set_format`() is called.
    /// ## `num`
    /// number of frames
    fn set_frame_max(&self, num: i32);

    /// Sets number of samples (per channel) subclass needs to be handed,
    /// at most or will be handed all available if 0.
    ///
    /// If an exact number of samples is required, `AudioEncoderExt::set_frame_samples_min`
    /// must be called with the same number.
    ///
    /// Note: This value will be reset to 0 every time before
    /// `AudioEncoderClass.set_format`() is called.
    /// ## `num`
    /// number of samples per frame
    fn set_frame_samples_max(&self, num: i32);

    /// Sets number of samples (per channel) subclass needs to be handed,
    /// at least or will be handed all available if 0.
    ///
    /// If an exact number of samples is required, `AudioEncoderExt::set_frame_samples_max`
    /// must be called with the same number.
    ///
    /// Note: This value will be reset to 0 every time before
    /// `AudioEncoderClass.set_format`() is called.
    /// ## `num`
    /// number of samples per frame
    fn set_frame_samples_min(&self, num: i32);

    /// Configures encoder hard minimum handling. If enabled, subclass
    /// will never be handed less samples than it configured, which otherwise
    /// might occur near end-of-data handling. Instead, the leftover samples
    /// will simply be discarded.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    fn set_hard_min(&self, enabled: bool);

    fn set_hard_resync(&self, enabled: bool);

    /// Set the codec headers to be sent downstream whenever requested.
    /// ## `headers`
    /// a list of
    ///  `gst::Buffer` containing the codec header
    fn set_headers(&self, headers: &[&gst::Buffer]);

    /// Sets encoder latency.
    /// ## `min`
    /// minimum latency
    /// ## `max`
    /// maximum latency
    fn set_latency(&self, min: gst::ClockTime, max: gst::ClockTime);

    /// Sets encoder lookahead (in units of input rate samples)
    ///
    /// Note: This value will be reset to 0 every time before
    /// `AudioEncoderClass.set_format`() is called.
    /// ## `num`
    /// lookahead
    fn set_lookahead(&self, num: i32);

    /// Enable or disable encoder granule handling.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    fn set_mark_granule(&self, enabled: bool);

    /// Enable or disable encoder perfect output timestamp preference.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    fn set_perfect_timestamp(&self, enabled: bool);

    /// Configures encoder audio jitter tolerance threshold.
    ///
    /// MT safe.
    /// ## `tolerance`
    /// new tolerance
    fn set_tolerance(&self, tolerance: gst::ClockTime);

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

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

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

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

impl<O: IsA<AudioEncoder>> AudioEncoderExt for O {
    fn allocate_output_buffer(&self, size: usize) -> Result<gst::Buffer, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_full(gst_audio_sys::gst_audio_encoder_allocate_output_buffer(
                self.as_ref().to_glib_none().0,
                size,
            ))
            .ok_or_else(|| glib_bool_error!("Failed to allocate output buffer"))
        }
    }

    fn get_audio_info(&self) -> Option<AudioInfo> {
        unsafe {
            from_glib_full(gst_audio_sys::gst_audio_encoder_get_audio_info(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_drainable(&self) -> bool {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_drainable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_frame_max(&self) -> i32 {
        unsafe { gst_audio_sys::gst_audio_encoder_get_frame_max(self.as_ref().to_glib_none().0) }
    }

    fn get_frame_samples_max(&self) -> i32 {
        unsafe {
            gst_audio_sys::gst_audio_encoder_get_frame_samples_max(self.as_ref().to_glib_none().0)
        }
    }

    fn get_frame_samples_min(&self) -> i32 {
        unsafe {
            gst_audio_sys::gst_audio_encoder_get_frame_samples_min(self.as_ref().to_glib_none().0)
        }
    }

    fn get_hard_min(&self) -> bool {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_hard_min(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_hard_resync(&self) -> bool {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_hard_resync(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_lookahead(&self) -> i32 {
        unsafe { gst_audio_sys::gst_audio_encoder_get_lookahead(self.as_ref().to_glib_none().0) }
    }

    fn get_mark_granule(&self) -> bool {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_mark_granule(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_perfect_timestamp(&self) -> bool {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_perfect_timestamp(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_tolerance(&self) -> gst::ClockTime {
        unsafe {
            from_glib(gst_audio_sys::gst_audio_encoder_get_tolerance(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_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_audio_sys::gst_audio_encoder_proxy_getcaps(
                self.as_ref().to_glib_none().0,
                caps.to_glib_none().0,
                filter.to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn set_allocation_caps(&self, allocation_caps: Option<&gst::Caps>) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_allocation_caps(
                self.as_ref().to_glib_none().0,
                allocation_caps.to_glib_none().0,
            );
        }
    }

    fn set_drainable(&self, enabled: bool) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_drainable(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_frame_max(&self, num: i32) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_frame_max(self.as_ref().to_glib_none().0, num);
        }
    }

    fn set_frame_samples_max(&self, num: i32) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_frame_samples_max(
                self.as_ref().to_glib_none().0,
                num,
            );
        }
    }

    fn set_frame_samples_min(&self, num: i32) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_frame_samples_min(
                self.as_ref().to_glib_none().0,
                num,
            );
        }
    }

    fn set_hard_min(&self, enabled: bool) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_hard_min(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_hard_resync(&self, enabled: bool) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_hard_resync(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_headers(&self, headers: &[&gst::Buffer]) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_headers(
                self.as_ref().to_glib_none().0,
                headers.to_glib_full(),
            );
        }
    }

    fn set_latency(&self, min: gst::ClockTime, max: gst::ClockTime) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_latency(
                self.as_ref().to_glib_none().0,
                min.to_glib(),
                max.to_glib(),
            );
        }
    }

    fn set_lookahead(&self, num: i32) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_lookahead(self.as_ref().to_glib_none().0, num);
        }
    }

    fn set_mark_granule(&self, enabled: bool) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_mark_granule(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_perfect_timestamp(&self, enabled: bool) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_perfect_timestamp(
                self.as_ref().to_glib_none().0,
                enabled.to_glib(),
            );
        }
    }

    fn set_tolerance(&self, tolerance: gst::ClockTime) {
        unsafe {
            gst_audio_sys::gst_audio_encoder_set_tolerance(
                self.as_ref().to_glib_none().0,
                tolerance.to_glib(),
            );
        }
    }

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

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

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

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