gstreamer_audio/auto/

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

glib::wrapper! {
    /// Subclasses must use (a subclass of) [`AudioAggregatorPad`][crate::AudioAggregatorPad] for both
    /// their source and sink pads,
    /// `gst_element_class_add_static_pad_template_with_gtype()` is a convenient
    /// helper.
    ///
    /// [`AudioAggregator`][crate::AudioAggregator] can perform conversion on the data arriving
    /// on its sink pads, based on the format expected downstream: in order
    /// to enable that behaviour, the GType of the sink pads must either be
    /// a (subclass of) [`AudioAggregatorConvertPad`][crate::AudioAggregatorConvertPad] to use the default
    /// `GstAudioConverter` implementation, or a subclass of [`AudioAggregatorPad`][crate::AudioAggregatorPad]
    /// implementing `GstAudioAggregatorPadClass.convert_buffer`.
    ///
    /// To allow for the output caps to change, the mechanism is the same as
    /// above, with the GType of the source pad.
    ///
    /// See `GstAudioMixer` for an example.
    ///
    /// When conversion is enabled, [`AudioAggregator`][crate::AudioAggregator] will accept
    /// any type of raw audio caps and perform conversion
    /// on the data arriving on its sink pads, with whatever downstream
    /// expects as the target format.
    ///
    /// In case downstream caps are not fully fixated, it will use
    /// the first configured sink pad to finish fixating its source pad
    /// caps.
    ///
    /// A notable exception for now is the sample rate, sink pads must
    /// have the same sample rate as either the downstream requirement,
    /// or the first configured pad, or a combination of both (when
    /// downstream specifies a range or a set of acceptable rates).
    ///
    /// The [`samples-selected`][struct@crate::gst_base::Aggregator#samples-selected] signal is provided with some
    /// additional information about the output buffer:
    /// - "offset" G_TYPE_UINT64 Offset in samples since segment start
    ///  for the position that is next to be filled in the output buffer.
    /// - "frames" G_TYPE_UINT Number of frames per output buffer.
    ///
    /// In addition the [`AggregatorExtManual::peek_next_sample()`][crate::gst_base::prelude::AggregatorExtManual::peek_next_sample()] function returns
    /// additional information in the info `GstStructure` of the returned sample:
    /// - "output-offset" G_TYPE_UINT64 Sample offset in output segment relative to
    ///  the output segment's start where the current position of this input
    ///  buffer would be placed
    /// - "position" G_TYPE_UINT current position in the input buffer in samples
    /// - "size" G_TYPE_UINT size of the input buffer in samples
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `alignment-threshold`
    ///  Readable | Writable
    ///
    ///
    /// #### `discont-wait`
    ///  Readable | Writable
    ///
    ///
    /// #### `force-live`
    ///  Causes the element to aggregate on a timeout even when no live source is
    /// connected to its sinks. See [`min-upstream-latency`][struct@crate::gst_base::Aggregator#min-upstream-latency] for a
    /// companion property: in the vast majority of cases where you plan to plug in
    /// live sources with a non-zero latency, you should set it to a non-zero value.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `ignore-inactive-pads`
    ///  Don't wait for inactive pads when live. An inactive pad
    /// is a pad that hasn't yet received a buffer, but that has
    /// been waited on at least once.
    ///
    /// The purpose of this property is to avoid aggregating on
    /// timeout when new pads are requested in advance of receiving
    /// data flow, for example the user may decide to connect it later,
    /// but wants to configure it already.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `output-buffer-duration`
    ///  Readable | Writable
    ///
    ///
    /// #### `output-buffer-duration-fraction`
    ///  Output block size in nanoseconds, expressed as a fraction.
    ///
    /// Readable | Writable
    /// <details><summary><h4>Aggregator</h4></summary>
    ///
    ///
    /// #### `emit-signals`
    ///  Enables the emission of signals such as [`samples-selected`][struct@crate::gst_base::Aggregator#samples-selected]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `latency`
    ///  Readable | Writable
    ///
    ///
    /// #### `min-upstream-latency`
    ///  Force minimum upstream latency (in nanoseconds). When sources with a
    /// higher latency are expected to be plugged in dynamically after the
    /// aggregator has started playing, this allows overriding the minimum
    /// latency reported by the initial source(s). This is only taken into
    /// account when larger than the actually reported minimum latency.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `start-time`
    ///  Readable | Writable
    ///
    ///
    /// #### `start-time-selection`
    ///  Readable | Writable
    /// </details>
    /// <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
    ///
    /// [`AudioAggregatorExt`][trait@crate::prelude::AudioAggregatorExt], [`trait@gst_base::prelude::AggregatorExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::GstObjectExt`], [`trait@glib::ObjectExt`], [`AudioAggregatorExtManual`][trait@crate::prelude::AudioAggregatorExtManual]
    #[doc(alias = "GstAudioAggregator")]
    pub struct AudioAggregator(Object<ffi::GstAudioAggregator, ffi::GstAudioAggregatorClass>) @extends gst_base::Aggregator, gst::Element, gst::Object;

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

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

unsafe impl Send for AudioAggregator {}
unsafe impl Sync for AudioAggregator {}

/// Trait containing all [`struct@AudioAggregator`] methods.
///
/// # Implementors
///
/// [`AudioAggregator`][struct@crate::AudioAggregator]
pub trait AudioAggregatorExt: IsA<AudioAggregator> + 'static {
    /// This can be used by subclasses to delay renegotiation until the current
    /// output buffer is finished to avoid dropping/converting it.
    ///
    /// # Returns
    ///
    /// [`true`] if there's currently a pending output buffer.
    #[cfg(feature = "v1_30")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_30")))]
    #[doc(alias = "gst_audio_aggregator_has_current_output_buffer")]
    fn has_current_output_buffer(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_aggregator_has_current_output_buffer(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "alignment-threshold")]
    fn alignment_threshold(&self) -> u64 {
        ObjectExt::property(self.as_ref(), "alignment-threshold")
    }

    #[doc(alias = "alignment-threshold")]
    fn set_alignment_threshold(&self, alignment_threshold: u64) {
        ObjectExt::set_property(self.as_ref(), "alignment-threshold", alignment_threshold)
    }

    #[doc(alias = "discont-wait")]
    fn discont_wait(&self) -> u64 {
        ObjectExt::property(self.as_ref(), "discont-wait")
    }

    #[doc(alias = "discont-wait")]
    fn set_discont_wait(&self, discont_wait: u64) {
        ObjectExt::set_property(self.as_ref(), "discont-wait", discont_wait)
    }

    #[doc(alias = "output-buffer-duration")]
    fn output_buffer_duration(&self) -> u64 {
        ObjectExt::property(self.as_ref(), "output-buffer-duration")
    }

    #[doc(alias = "output-buffer-duration")]
    fn set_output_buffer_duration(&self, output_buffer_duration: u64) {
        ObjectExt::set_property(
            self.as_ref(),
            "output-buffer-duration",
            output_buffer_duration,
        )
    }

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

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

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

impl<O: IsA<AudioAggregator>> AudioAggregatorExt for O {}