gstreamer_audio/auto/

audio_encoder.rs

// 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 crate::{AudioInfo, ffi};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

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
    ///  [`AudioEncoderExt::finish_frame()`][crate::prelude::AudioEncoderExt::finish_frame()] to have encoded data pushed
    ///  downstream. Alternatively, it might also call
    ///  [`AudioEncoderExt::finish_frame()`][crate::prelude::AudioEncoderExt::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 [`AudioEncoderExt::finish_frame()`][crate::prelude::AudioEncoderExt::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 [`perfect-timestamp`][struct@crate::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 [`tolerance`][struct@crate::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 [`hard-resync`][struct@crate::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
    ///  [`AudioEncoderExt::finish_frame()`][crate::prelude::AudioEncoderExt::finish_frame()].
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `hard-resync`
    ///  Readable | Writable
    ///
    ///
    /// #### `mark-granule`
    ///  Readable
    ///
    ///
    /// #### `perfect-timestamp`
    ///  Readable | Writable
    ///
    ///
    /// #### `tolerance`
    ///  Readable | Writable
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent of the object. Please note, that when changing the 'parent'
    /// property, we don't emit [`notify`][struct@crate::glib::Object#notify] and [`deep-notify`][struct@crate::gst::Object#deep-notify]
    /// signals due to locking issues. In some cases one can use
    /// `GstBin::element-added` or `GstBin::element-removed` signals on the parent to
    /// achieve a similar effect.
    ///
    /// Readable | Writable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`AudioEncoderExt`][trait@crate::prelude::AudioEncoderExt], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::GstObjectExt`], [`trait@glib::ObjectExt`], [`AudioEncoderExtManual`][trait@crate::prelude::AudioEncoderExtManual]
    #[doc(alias = "GstAudioEncoder")]
    pub struct AudioEncoder(Object<ffi::GstAudioEncoder, ffi::GstAudioEncoderClass>) @extends gst::Element, gst::Object;

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

impl AudioEncoder {
    pub const NONE: Option<&'static AudioEncoder> = None;
}

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

/// Trait containing all [`struct@AudioEncoder`] methods.
///
/// # Implementors
///
/// [`AudioEncoder`][struct@crate::AudioEncoder]
pub trait AudioEncoderExt: IsA<AudioEncoder> + '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
    #[doc(alias = "gst_audio_encoder_allocate_output_buffer")]
    fn allocate_output_buffer(&self, size: usize) -> gst::Buffer {
        unsafe {
            from_glib_full(ffi::gst_audio_encoder_allocate_output_buffer(
                self.as_ref().to_glib_none().0,
                size,
            ))
        }
    }

    ///  0, then best estimate is all samples provided to encoder
    /// (subclass) so far. `buf` may be NULL, in which case next number of `samples`
    /// are considered discarded, e.g. as a result of discontinuous transmission,
    /// and a discontinuity is marked.
    ///
    /// Note that samples received in `GstAudioEncoderClass.handle_frame()`
    /// may be invalidated by a call to this function.
    /// ## `buffer`
    /// encoded data
    /// ## `samples`
    /// number of samples (per channel) represented by encoded data
    ///
    /// # Returns
    ///
    /// a [`gst::FlowReturn`][crate::gst::FlowReturn] that should be escalated to caller (of caller)
    #[doc(alias = "gst_audio_encoder_finish_frame")]
    fn finish_frame(
        &self,
        buffer: Option<gst::Buffer>,
        samples: i32,
    ) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe {
            try_from_glib(ffi::gst_audio_encoder_finish_frame(
                self.as_ref().to_glib_none().0,
                buffer.into_glib_ptr(),
                samples,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// a [`AudioInfo`][crate::AudioInfo] describing the input audio format
    #[doc(alias = "gst_audio_encoder_get_audio_info")]
    #[doc(alias = "get_audio_info")]
    fn audio_info(&self) -> AudioInfo {
        unsafe {
            from_glib_none(ffi::gst_audio_encoder_get_audio_info(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries encoder drain handling.
    ///
    /// # Returns
    ///
    /// TRUE if drainable handling is enabled.
    ///
    /// MT safe.
    #[doc(alias = "gst_audio_encoder_get_drainable")]
    #[doc(alias = "get_drainable")]
    fn is_drainable(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_encoder_get_drainable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// currently configured maximum handled frames
    #[doc(alias = "gst_audio_encoder_get_frame_max")]
    #[doc(alias = "get_frame_max")]
    fn frame_max(&self) -> i32 {
        unsafe { ffi::gst_audio_encoder_get_frame_max(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// currently maximum requested samples per frame
    #[doc(alias = "gst_audio_encoder_get_frame_samples_max")]
    #[doc(alias = "get_frame_samples_max")]
    fn frame_samples_max(&self) -> i32 {
        unsafe { ffi::gst_audio_encoder_get_frame_samples_max(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// currently minimum requested samples per frame
    #[doc(alias = "gst_audio_encoder_get_frame_samples_min")]
    #[doc(alias = "get_frame_samples_min")]
    fn frame_samples_min(&self) -> i32 {
        unsafe { ffi::gst_audio_encoder_get_frame_samples_min(self.as_ref().to_glib_none().0) }
    }

    /// Queries encoder hard minimum handling.
    ///
    /// # Returns
    ///
    /// TRUE if hard minimum handling is enabled.
    ///
    /// MT safe.
    #[doc(alias = "gst_audio_encoder_get_hard_min")]
    #[doc(alias = "get_hard_min")]
    fn is_hard_min(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_encoder_get_hard_min(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "gst_audio_encoder_get_hard_resync")]
    #[doc(alias = "get_hard_resync")]
    #[doc(alias = "hard-resync")]
    fn is_hard_resync(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_encoder_get_hard_resync(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the variables pointed to by `min` and `max` to the currently configured
    /// latency.
    ///
    /// # Returns
    ///
    ///
    /// ## `min`
    /// a pointer to storage to hold minimum latency
    ///
    /// ## `max`
    /// a pointer to storage to hold maximum latency
    #[doc(alias = "gst_audio_encoder_get_latency")]
    #[doc(alias = "get_latency")]
    fn latency(&self) -> (gst::ClockTime, Option<gst::ClockTime>) {
        unsafe {
            let mut min = std::mem::MaybeUninit::uninit();
            let mut max = std::mem::MaybeUninit::uninit();
            ffi::gst_audio_encoder_get_latency(
                self.as_ref().to_glib_none().0,
                min.as_mut_ptr(),
                max.as_mut_ptr(),
            );
            (
                try_from_glib(min.assume_init()).expect("mandatory glib value is None"),
                from_glib(max.assume_init()),
            )
        }
    }

    ///
    /// # Returns
    ///
    /// currently configured encoder lookahead
    #[doc(alias = "gst_audio_encoder_get_lookahead")]
    #[doc(alias = "get_lookahead")]
    fn lookahead(&self) -> i32 {
        unsafe { ffi::gst_audio_encoder_get_lookahead(self.as_ref().to_glib_none().0) }
    }

    /// Queries if the encoder will handle granule marking.
    ///
    /// # Returns
    ///
    /// TRUE if granule marking is enabled.
    ///
    /// MT safe.
    #[doc(alias = "gst_audio_encoder_get_mark_granule")]
    #[doc(alias = "get_mark_granule")]
    #[doc(alias = "mark-granule")]
    fn is_mark_granule(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_encoder_get_mark_granule(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries encoder perfect timestamp behaviour.
    ///
    /// # Returns
    ///
    /// TRUE if perfect timestamp setting enabled.
    ///
    /// MT safe.
    #[doc(alias = "gst_audio_encoder_get_perfect_timestamp")]
    #[doc(alias = "get_perfect_timestamp")]
    #[doc(alias = "perfect-timestamp")]
    fn is_perfect_timestamp(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_encoder_get_perfect_timestamp(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries current audio jitter tolerance threshold.
    ///
    /// # Returns
    ///
    /// encoder audio jitter tolerance threshold.
    ///
    /// MT safe.
    #[doc(alias = "gst_audio_encoder_get_tolerance")]
    #[doc(alias = "get_tolerance")]
    fn tolerance(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::gst_audio_encoder_get_tolerance(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Sets the audio encoder tags and how they should be merged with any
    /// upstream stream tags. This will override any tags previously-set
    /// with [`merge_tags()`][Self::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`][crate::gst::TagList] to merge, or NULL to unset
    ///  previously-set tags
    /// ## `mode`
    /// the [`gst::TagMergeMode`][crate::gst::TagMergeMode] to use, usually [`gst::TagMergeMode::Replace`][crate::gst::TagMergeMode::Replace]
    #[doc(alias = "gst_audio_encoder_merge_tags")]
    fn merge_tags(&self, tags: Option<&gst::TagList>, mode: gst::TagMergeMode) {
        unsafe {
            ffi::gst_audio_encoder_merge_tags(
                self.as_ref().to_glib_none().0,
                tags.to_glib_none().0,
                mode.into_glib(),
            );
        }
    }

    /// 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`][crate::gst::Caps] owned by caller
    #[doc(alias = "gst_audio_encoder_proxy_getcaps")]
    fn proxy_getcaps(&self, caps: Option<&gst::Caps>, filter: Option<&gst::Caps>) -> gst::Caps {
        unsafe {
            from_glib_full(ffi::gst_audio_encoder_proxy_getcaps(
                self.as_ref().to_glib_none().0,
                caps.to_glib_none().0,
                filter.to_glib_none().0,
            ))
        }
    }

    /// Sets a caps in allocation query which are different from the set
    /// pad's caps. Use this function before calling
    /// [`AudioEncoderExtManual::negotiate()`][crate::prelude::AudioEncoderExtManual::negotiate()]. Setting to [`None`] the allocation
    /// query will use the caps from the pad.
    /// ## `allocation_caps`
    /// a [`gst::Caps`][crate::gst::Caps] or [`None`]
    #[doc(alias = "gst_audio_encoder_set_allocation_caps")]
    fn set_allocation_caps(&self, allocation_caps: Option<&gst::Caps>) {
        unsafe {
            ffi::gst_audio_encoder_set_allocation_caps(
                self.as_ref().to_glib_none().0,
                allocation_caps.to_glib_none().0,
            );
        }
    }

    /// Allows [`AudioEncoder`][crate::AudioEncoder] sub-classes to set the memory `allocator` and
    /// its `params`.
    /// ## `allocator`
    /// the [`gst::Allocator`][crate::gst::Allocator]
    /// ## `params`
    /// the [`gst::AllocationParams`][crate::gst::AllocationParams] of `allocator`
    #[cfg(feature = "v1_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
    #[doc(alias = "gst_audio_encoder_set_allocator")]
    fn set_allocator(
        &self,
        allocator: Option<impl IsA<gst::Allocator>>,
        params: Option<&gst::AllocationParams>,
    ) {
        unsafe {
            ffi::gst_audio_encoder_set_allocator(
                self.as_ref().to_glib_none().0,
                allocator.map(|p| p.upcast()).into_glib_ptr(),
                params.to_glib_none().0,
            );
        }
    }

    /// 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
    #[doc(alias = "gst_audio_encoder_set_drainable")]
    fn set_drainable(&self, enabled: bool) {
        unsafe {
            ffi::gst_audio_encoder_set_drainable(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// 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
    /// `GstAudioEncoderClass.set_format()` is called.
    /// ## `num`
    /// number of frames
    #[doc(alias = "gst_audio_encoder_set_frame_max")]
    fn set_frame_max(&self, num: i32) {
        unsafe {
            ffi::gst_audio_encoder_set_frame_max(self.as_ref().to_glib_none().0, num);
        }
    }

    /// 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, [`set_frame_samples_min()`][Self::set_frame_samples_min()]
    /// must be called with the same number.
    ///
    /// Note: This value will be reset to 0 every time before
    /// `GstAudioEncoderClass.set_format()` is called.
    /// ## `num`
    /// number of samples per frame
    #[doc(alias = "gst_audio_encoder_set_frame_samples_max")]
    fn set_frame_samples_max(&self, num: i32) {
        unsafe {
            ffi::gst_audio_encoder_set_frame_samples_max(self.as_ref().to_glib_none().0, num);
        }
    }

    /// 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, [`set_frame_samples_max()`][Self::set_frame_samples_max()]
    /// must be called with the same number.
    ///
    /// Note: This value will be reset to 0 every time before
    /// `GstAudioEncoderClass.set_format()` is called.
    /// ## `num`
    /// number of samples per frame
    #[doc(alias = "gst_audio_encoder_set_frame_samples_min")]
    fn set_frame_samples_min(&self, num: i32) {
        unsafe {
            ffi::gst_audio_encoder_set_frame_samples_min(self.as_ref().to_glib_none().0, num);
        }
    }

    /// 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
    #[doc(alias = "gst_audio_encoder_set_hard_min")]
    fn set_hard_min(&self, enabled: bool) {
        unsafe {
            ffi::gst_audio_encoder_set_hard_min(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    #[doc(alias = "gst_audio_encoder_set_hard_resync")]
    #[doc(alias = "hard-resync")]
    fn set_hard_resync(&self, enabled: bool) {
        unsafe {
            ffi::gst_audio_encoder_set_hard_resync(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Sets encoder latency. If the provided values changed from
    /// previously provided ones, this will also post a LATENCY message on the bus
    /// so the pipeline can reconfigure its global latency.
    /// ## `min`
    /// minimum latency
    /// ## `max`
    /// maximum latency
    #[doc(alias = "gst_audio_encoder_set_latency")]
    fn set_latency(&self, min: gst::ClockTime, max: impl Into<Option<gst::ClockTime>>) {
        unsafe {
            ffi::gst_audio_encoder_set_latency(
                self.as_ref().to_glib_none().0,
                min.into_glib(),
                max.into().into_glib(),
            );
        }
    }

    /// Sets encoder lookahead (in units of input rate samples)
    ///
    /// Note: This value will be reset to 0 every time before
    /// `GstAudioEncoderClass.set_format()` is called.
    /// ## `num`
    /// lookahead
    #[doc(alias = "gst_audio_encoder_set_lookahead")]
    fn set_lookahead(&self, num: i32) {
        unsafe {
            ffi::gst_audio_encoder_set_lookahead(self.as_ref().to_glib_none().0, num);
        }
    }

    /// Enable or disable encoder granule handling.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    #[doc(alias = "gst_audio_encoder_set_mark_granule")]
    fn set_mark_granule(&self, enabled: bool) {
        unsafe {
            ffi::gst_audio_encoder_set_mark_granule(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Enable or disable encoder perfect output timestamp preference.
    ///
    /// MT safe.
    /// ## `enabled`
    /// new state
    #[doc(alias = "gst_audio_encoder_set_perfect_timestamp")]
    #[doc(alias = "perfect-timestamp")]
    fn set_perfect_timestamp(&self, enabled: bool) {
        unsafe {
            ffi::gst_audio_encoder_set_perfect_timestamp(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Configures encoder audio jitter tolerance threshold.
    ///
    /// MT safe.
    /// ## `tolerance`
    /// new tolerance
    #[doc(alias = "gst_audio_encoder_set_tolerance")]
    #[doc(alias = "tolerance")]
    fn set_tolerance(&self, tolerance: gst::ClockTime) {
        unsafe {
            ffi::gst_audio_encoder_set_tolerance(
                self.as_ref().to_glib_none().0,
                tolerance.into_glib(),
            );
        }
    }

    #[doc(alias = "hard-resync")]
    fn connect_hard_resync_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_hard_resync_trampoline<
            P: IsA<AudioEncoder>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioEncoder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(AudioEncoder::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::hard-resync".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_hard_resync_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "mark-granule")]
    fn connect_mark_granule_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_mark_granule_trampoline<
            P: IsA<AudioEncoder>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioEncoder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(AudioEncoder::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::mark-granule".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_mark_granule_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "perfect-timestamp")]
    fn connect_perfect_timestamp_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_perfect_timestamp_trampoline<
            P: IsA<AudioEncoder>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioEncoder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(AudioEncoder::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::perfect-timestamp".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_perfect_timestamp_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "tolerance")]
    fn connect_tolerance_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_tolerance_trampoline<
            P: IsA<AudioEncoder>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioEncoder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(AudioEncoder::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::tolerance".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_tolerance_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<AudioEncoder>> AudioEncoderExt for O {}