gstreamer_audio/auto/

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

glib::wrapper! {
    /// This is the base class for audio sinks. Subclasses need to implement the
    /// ::create_ringbuffer vmethod. This base class will then take care of
    /// writing samples to the ringbuffer, synchronisation, clipping and flushing.
    ///
    /// ## Properties
    ///
    ///
    /// #### `alignment-threshold`
    ///  Readable | Writeable
    ///
    ///
    /// #### `buffer-time`
    ///  Readable | Writeable
    ///
    ///
    /// #### `can-activate-pull`
    ///  Readable | Writeable
    ///
    ///
    /// #### `discont-wait`
    ///  A window of time in nanoseconds to wait before creating a discontinuity as
    /// a result of breaching the drift-tolerance.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `drift-tolerance`
    ///  Controls the amount of time in microseconds that clocks are allowed
    /// to drift before resynchronisation happens.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `latency-time`
    ///  Readable | Writeable
    ///
    ///
    /// #### `provide-clock`
    ///  Readable | Writeable
    ///
    ///
    /// #### `slave-method`
    ///  Readable | Writeable
    /// <details><summary><h4>BaseSink</h4></summary>
    ///
    ///
    /// #### `async`
    ///  If set to [`true`], the basesink will perform asynchronous state changes.
    /// When set to [`false`], the sink will not signal the parent when it prerolls.
    /// Use this option when dealing with sparse streams or when synchronisation is
    /// not required.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `blocksize`
    ///  The amount of bytes to pull when operating in pull mode.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `enable-last-sample`
    ///  Enable the last-sample property. If [`false`], basesink doesn't keep a
    /// reference to the last buffer arrived and the last-sample property is always
    /// set to [`None`]. This can be useful if you need buffers to be released as soon
    /// as possible, eg. if you're using a buffer pool.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `last-sample`
    ///  The last buffer that arrived in the sink and was used for preroll or for
    /// rendering. This property can be used to generate thumbnails. This property
    /// can be [`None`] when the sink has not yet received a buffer.
    ///
    /// Readable
    ///
    ///
    /// #### `max-bitrate`
    ///  Control the maximum amount of bits that will be rendered per second.
    /// Setting this property to a value bigger than 0 will make the sink delay
    /// rendering of the buffers when it would exceed to max-bitrate.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `max-lateness`
    ///  Readable | Writeable
    ///
    ///
    /// #### `processing-deadline`
    ///  Maximum amount of time (in nanoseconds) that the pipeline can take
    /// for processing the buffer. This is added to the latency of live
    /// pipelines.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `qos`
    ///  Readable | Writeable
    ///
    ///
    /// #### `render-delay`
    ///  The additional delay between synchronisation and actual rendering of the
    /// media. This property will add additional latency to the device in order to
    /// make other sinks compensate for the delay.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `stats`
    ///  Various [`gst_base::BaseSink`][crate::gst_base::BaseSink] statistics. This property returns a `GstStructure`
    /// with name `application/x-gst-base-sink-stats` with the following fields:
    ///
    /// - "average-rate" G_TYPE_DOUBLE average frame rate
    /// - "dropped" G_TYPE_UINT64 Number of dropped frames
    /// - "rendered" G_TYPE_UINT64 Number of rendered frames
    ///
    /// Readable
    ///
    ///
    /// #### `sync`
    ///  Readable | Writeable
    ///
    ///
    /// #### `throttle-time`
    ///  The time to insert between buffers. This property can be used to control
    /// the maximum amount of buffers per second to render. Setting this property
    /// to a value bigger than 0 will make the sink create THROTTLE QoS events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `ts-offset`
    ///  Controls the final synchronisation, a negative value will render the buffer
    /// earlier while a positive value delays playback. This property can be
    /// used to fix synchronisation in bad files.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writeable | 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 | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`AudioBaseSinkExt`][trait@crate::prelude::AudioBaseSinkExt], [`trait@gst_base::prelude::BaseSinkExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::GstObjectExt`], [`trait@glib::ObjectExt`]
    #[doc(alias = "GstAudioBaseSink")]
    pub struct AudioBaseSink(Object<ffi::GstAudioBaseSink, ffi::GstAudioBaseSinkClass>) @extends gst_base::BaseSink, gst::Element, gst::Object;

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

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

unsafe impl Send for AudioBaseSink {}
unsafe impl Sync for AudioBaseSink {}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::AudioBaseSink>> Sealed for T {}
}

/// Trait containing all [`struct@AudioBaseSink`] methods.
///
/// # Implementors
///
/// [`AudioBaseSink`][struct@crate::AudioBaseSink], [`AudioSink`][struct@crate::AudioSink]
pub trait AudioBaseSinkExt: IsA<AudioBaseSink> + sealed::Sealed + 'static {
    //#[doc(alias = "gst_audio_base_sink_create_ringbuffer")]
    //fn create_ringbuffer(&self) -> /*Ignored*/Option<AudioRingBuffer> {
    //    unsafe { TODO: call ffi:gst_audio_base_sink_create_ringbuffer() }
    //}

    /// Get the current alignment threshold, in nanoseconds, used by `self`.
    ///
    /// # Returns
    ///
    /// The current alignment threshold used by `self`.
    #[doc(alias = "gst_audio_base_sink_get_alignment_threshold")]
    #[doc(alias = "get_alignment_threshold")]
    #[doc(alias = "alignment-threshold")]
    fn alignment_threshold(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::gst_audio_base_sink_get_alignment_threshold(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Get the current discont wait, in nanoseconds, used by `self`.
    ///
    /// # Returns
    ///
    /// The current discont wait used by `self`.
    #[doc(alias = "gst_audio_base_sink_get_discont_wait")]
    #[doc(alias = "get_discont_wait")]
    #[doc(alias = "discont-wait")]
    fn discont_wait(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::gst_audio_base_sink_get_discont_wait(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Get the current drift tolerance, in microseconds, used by `self`.
    ///
    /// # Returns
    ///
    /// The current drift tolerance used by `self`.
    #[doc(alias = "gst_audio_base_sink_get_drift_tolerance")]
    #[doc(alias = "get_drift_tolerance")]
    #[doc(alias = "drift-tolerance")]
    fn drift_tolerance(&self) -> i64 {
        unsafe { ffi::gst_audio_base_sink_get_drift_tolerance(self.as_ref().to_glib_none().0) }
    }

    /// Queries whether `self` will provide a clock or not. See also
    /// gst_audio_base_sink_set_provide_clock.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` will provide a clock.
    #[doc(alias = "gst_audio_base_sink_get_provide_clock")]
    #[doc(alias = "get_provide_clock")]
    #[doc(alias = "provide-clock")]
    fn is_provide_clock(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_audio_base_sink_get_provide_clock(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gst_audio_base_sink_get_slave_method")]
    //#[doc(alias = "get_slave_method")]
    //#[doc(alias = "slave-method")]
    //fn slave_method(&self) -> /*Ignored*/AudioBaseSinkSlaveMethod {
    //    unsafe { TODO: call ffi:gst_audio_base_sink_get_slave_method() }
    //}

    /// Informs this base class that the audio output device has failed for
    /// some reason, causing a discontinuity (for example, because the device
    /// recovered from the error, but lost all contents of its ring buffer).
    /// This function is typically called by derived classes, and is useful
    /// for the custom slave method.
    #[doc(alias = "gst_audio_base_sink_report_device_failure")]
    fn report_device_failure(&self) {
        unsafe {
            ffi::gst_audio_base_sink_report_device_failure(self.as_ref().to_glib_none().0);
        }
    }

    /// Controls the sink's alignment threshold.
    /// ## `alignment_threshold`
    /// the new alignment threshold in nanoseconds
    #[doc(alias = "gst_audio_base_sink_set_alignment_threshold")]
    #[doc(alias = "alignment-threshold")]
    fn set_alignment_threshold(&self, alignment_threshold: gst::ClockTime) {
        unsafe {
            ffi::gst_audio_base_sink_set_alignment_threshold(
                self.as_ref().to_glib_none().0,
                alignment_threshold.into_glib(),
            );
        }
    }

    //#[doc(alias = "gst_audio_base_sink_set_custom_slaving_callback")]
    //fn set_custom_slaving_callback(&self, callback: /*Unimplemented*/Fn(&AudioBaseSink, impl Into<Option<gst::ClockTime>>, impl Into<Option<gst::ClockTime>>, gst::ClockTimeDiff, /*Ignored*/AudioBaseSinkDiscontReason), user_data: /*Unimplemented*/Option<Basic: Pointer>) {
    //    unsafe { TODO: call ffi:gst_audio_base_sink_set_custom_slaving_callback() }
    //}

    /// Controls how long the sink will wait before creating a discontinuity.
    /// ## `discont_wait`
    /// the new discont wait in nanoseconds
    #[doc(alias = "gst_audio_base_sink_set_discont_wait")]
    #[doc(alias = "discont-wait")]
    fn set_discont_wait(&self, discont_wait: gst::ClockTime) {
        unsafe {
            ffi::gst_audio_base_sink_set_discont_wait(
                self.as_ref().to_glib_none().0,
                discont_wait.into_glib(),
            );
        }
    }

    /// Controls the sink's drift tolerance.
    /// ## `drift_tolerance`
    /// the new drift tolerance in microseconds
    #[doc(alias = "gst_audio_base_sink_set_drift_tolerance")]
    #[doc(alias = "drift-tolerance")]
    fn set_drift_tolerance(&self, drift_tolerance: i64) {
        unsafe {
            ffi::gst_audio_base_sink_set_drift_tolerance(
                self.as_ref().to_glib_none().0,
                drift_tolerance,
            );
        }
    }

    /// Controls whether `self` will provide a clock or not. If `provide` is [`true`],
    /// [`ElementExtManual::provide_clock()`][crate::gst::prelude::ElementExtManual::provide_clock()] will return a clock that reflects the datarate
    /// of `self`. If `provide` is [`false`], [`ElementExtManual::provide_clock()`][crate::gst::prelude::ElementExtManual::provide_clock()] will return
    /// NULL.
    /// ## `provide`
    /// new state
    #[doc(alias = "gst_audio_base_sink_set_provide_clock")]
    #[doc(alias = "provide-clock")]
    fn set_provide_clock(&self, provide: bool) {
        unsafe {
            ffi::gst_audio_base_sink_set_provide_clock(
                self.as_ref().to_glib_none().0,
                provide.into_glib(),
            );
        }
    }

    //#[doc(alias = "gst_audio_base_sink_set_slave_method")]
    //#[doc(alias = "slave-method")]
    //fn set_slave_method(&self, method: /*Ignored*/AudioBaseSinkSlaveMethod) {
    //    unsafe { TODO: call ffi:gst_audio_base_sink_set_slave_method() }
    //}

    #[doc(alias = "buffer-time")]
    fn buffer_time(&self) -> i64 {
        ObjectExt::property(self.as_ref(), "buffer-time")
    }

    #[doc(alias = "buffer-time")]
    fn set_buffer_time(&self, buffer_time: i64) {
        ObjectExt::set_property(self.as_ref(), "buffer-time", buffer_time)
    }

    #[doc(alias = "can-activate-pull")]
    fn can_activate_pull(&self) -> bool {
        ObjectExt::property(self.as_ref(), "can-activate-pull")
    }

    #[doc(alias = "can-activate-pull")]
    fn set_can_activate_pull(&self, can_activate_pull: bool) {
        ObjectExt::set_property(self.as_ref(), "can-activate-pull", can_activate_pull)
    }

    #[doc(alias = "latency-time")]
    fn latency_time(&self) -> i64 {
        ObjectExt::property(self.as_ref(), "latency-time")
    }

    #[doc(alias = "latency-time")]
    fn set_latency_time(&self, latency_time: i64) {
        ObjectExt::set_property(self.as_ref(), "latency-time", latency_time)
    }

    #[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<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::alignment-threshold\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_alignment_threshold_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

    #[doc(alias = "can-activate-pull")]
    fn connect_can_activate_pull_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_activate_pull_trampoline<
            P: IsA<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::can-activate-pull\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_activate_pull_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<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::discont-wait\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_discont_wait_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

    #[doc(alias = "latency-time")]
    fn connect_latency_time_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_latency_time_trampoline<
            P: IsA<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::latency-time\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_latency_time_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "provide-clock")]
    fn connect_provide_clock_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_provide_clock_trampoline<
            P: IsA<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::provide-clock\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_provide_clock_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "slave-method")]
    fn connect_slave_method_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_slave_method_trampoline<
            P: IsA<AudioBaseSink>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstAudioBaseSink,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(AudioBaseSink::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::slave-method\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_slave_method_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<AudioBaseSink>> AudioBaseSinkExt for O {}