gstreamer_base/auto/

base_src.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
#![allow(deprecated)]

use crate::ffi;
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// ");
    /// }
    /// ]|
    ///
    /// ## Controlled shutdown of live sources in applications
    ///
    /// Applications that record from a live source may want to stop recording
    /// in a controlled way, so that the recording is stopped, but the data
    /// already in the pipeline is processed to the end (remember that many live
    /// sources would go on recording forever otherwise). For that to happen the
    /// application needs to make the source stop recording and send an EOS
    /// event down the pipeline. The application would then wait for an
    /// EOS message posted on the pipeline's bus to know when all data has
    /// been processed and the pipeline can safely be stopped.
    ///
    /// An application may send an EOS event to a source element to make it
    /// perform the EOS logic (send EOS event downstream or post a
    /// `GST_MESSAGE_SEGMENT_DONE` on the bus). This can typically be done
    /// with the [`ElementExtManual::send_event()`][crate::gst::prelude::ElementExtManual::send_event()] function on the element or its parent bin.
    ///
    /// After the EOS has been sent to the element, the application should wait for
    /// an EOS message to be posted on the pipeline's bus. Once this EOS message is
    /// received, it may safely shut down the entire pipeline.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `automatic-eos`
    ///  See [`BaseSrcExt::set_automatic_eos()`][crate::prelude::BaseSrcExt::set_automatic_eos()]
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `blocksize`
    ///  Readable | Writable
    ///
    ///
    /// #### `do-timestamp`
    ///  Readable | Writable
    ///
    ///
    /// #### `num-buffers`
    ///  Readable | Writable
    ///
    ///
    /// #### `typefind`
    ///  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
    ///
    /// [`BaseSrcExt`][trait@crate::prelude::BaseSrcExt], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::ObjectExt`], [`trait@glib::ObjectExt`], [`BaseSrcExtManual`][trait@crate::prelude::BaseSrcExtManual]
    #[doc(alias = "GstBaseSrc")]
    pub struct BaseSrc(Object<ffi::GstBaseSrc, ffi::GstBaseSrcClass>) @extends gst::Element, gst::Object;

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

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

unsafe impl Send for BaseSrc {}
unsafe impl Sync for BaseSrc {}

/// Trait containing all [`struct@BaseSrc`] methods.
///
/// # Implementors
///
/// [`BaseSrc`][struct@crate::BaseSrc], [`PushSrc`][struct@crate::PushSrc]
pub trait BaseSrcExt: IsA<BaseSrc> + 'static {
    /// Get the number of bytes that `self` will push out with each buffer.
    ///
    /// # Returns
    ///
    /// the number of bytes pushed with each buffer.
    #[doc(alias = "gst_base_src_get_blocksize")]
    #[doc(alias = "get_blocksize")]
    fn blocksize(&self) -> u32 {
        unsafe { ffi::gst_base_src_get_blocksize(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the instance of the [`gst::BufferPool`][crate::gst::BufferPool] used
    /// by the src; unref it after usage.
    #[doc(alias = "gst_base_src_get_buffer_pool")]
    #[doc(alias = "get_buffer_pool")]
    fn buffer_pool(&self) -> Option<gst::BufferPool> {
        unsafe {
            from_glib_full(ffi::gst_base_src_get_buffer_pool(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Query if `self` timestamps outgoing buffers based on the current running_time.
    ///
    /// # Returns
    ///
    /// [`true`] if the base class will automatically timestamp outgoing buffers.
    #[doc(alias = "gst_base_src_get_do_timestamp")]
    #[doc(alias = "get_do_timestamp")]
    #[doc(alias = "do-timestamp")]
    fn does_timestamp(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_base_src_get_do_timestamp(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the current async behaviour of `self`. See also [`set_async()`][Self::set_async()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is operating in async mode.
    #[doc(alias = "gst_base_src_is_async")]
    fn is_async(&self) -> bool {
        unsafe { from_glib(ffi::gst_base_src_is_async(self.as_ref().to_glib_none().0)) }
    }

    /// Check if an element is in live mode.
    ///
    /// # Returns
    ///
    /// [`true`] if element is in live mode.
    #[doc(alias = "gst_base_src_is_live")]
    fn is_live(&self) -> bool {
        unsafe { from_glib(ffi::gst_base_src_is_live(self.as_ref().to_glib_none().0)) }
    }

    /// Negotiates src pad caps with downstream elements.
    /// Unmarks GST_PAD_FLAG_NEED_RECONFIGURE in any case. But marks it again
    /// if `GstBaseSrcClass::negotiate` fails.
    ///
    /// Do not call this in the `GstBaseSrcClass::fill` vmethod. Call this in
    /// `GstBaseSrcClass::create` or in `GstBaseSrcClass::alloc`, _before_ any
    /// buffer is allocated.
    ///
    /// # Returns
    ///
    /// [`true`] if the negotiation succeeded, else [`false`].
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_base_src_negotiate")]
    fn negotiate(&self) -> bool {
        unsafe { from_glib(ffi::gst_base_src_negotiate(self.as_ref().to_glib_none().0)) }
    }

    /// Prepare a new seamless segment for emission downstream. This function must
    /// only be called by derived sub-classes, and only from the `GstBaseSrcClass::create` function,
    /// as the stream-lock needs to be held.
    ///
    /// The format for the new segment will be the current format of the source, as
    /// configured with [`set_format()`][Self::set_format()]
    ///
    /// # Deprecated since 1.18
    ///
    /// Use [`new_segment()`][Self::new_segment()]
    /// ## `start`
    /// The new start value for the segment
    /// ## `stop`
    /// Stop value for the new segment
    /// ## `time`
    /// The new time value for the start of the new segment
    ///
    /// # Returns
    ///
    /// [`true`] if preparation of the seamless segment succeeded.
    #[cfg_attr(feature = "v1_18", deprecated = "Since 1.18")]
    #[allow(deprecated)]
    #[doc(alias = "gst_base_src_new_seamless_segment")]
    fn new_seamless_segment(&self, start: i64, stop: i64, time: i64) -> bool {
        unsafe {
            from_glib(ffi::gst_base_src_new_seamless_segment(
                self.as_ref().to_glib_none().0,
                start,
                stop,
                time,
            ))
        }
    }

    /// Prepare a new segment for emission downstream. This function must
    /// only be called by derived sub-classes, and only from the `GstBaseSrcClass::create` function,
    /// as the stream-lock needs to be held.
    ///
    /// The format for the `segment` must be identical with the current format
    /// of the source, as configured with [`set_format()`][Self::set_format()].
    ///
    /// The format of `self` must not be [`gst::Format::Undefined`][crate::gst::Format::Undefined] and the format
    /// should be configured via [`set_format()`][Self::set_format()] before calling this method.
    /// ## `segment`
    /// a pointer to a [`gst::Segment`][crate::gst::Segment]
    ///
    /// # Returns
    ///
    /// [`true`] if preparation of new segment succeeded.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_base_src_new_segment")]
    fn new_segment(&self, segment: &gst::Segment) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_base_src_new_segment(
                    self.as_ref().to_glib_none().0,
                    segment.to_glib_none().0
                ),
                "Failed to update segment"
            )
        }
    }

    /// Send a new segment downstream. This function must
    /// only be called by derived sub-classes, and only from the `GstBaseSrcClass::create` function,
    /// as the stream-lock needs to be held.
    /// This method also requires that an out caps has been configured, so
    /// [`set_caps()`][Self::set_caps()] needs to have been called before.
    ///
    /// The format for the `segment` must be identical with the current format
    /// of the source, as configured with [`set_format()`][Self::set_format()].
    ///
    /// The format of `self` must not be [`gst::Format::Undefined`][crate::gst::Format::Undefined] and the format
    /// should be configured via [`set_format()`][Self::set_format()] before calling this method.
    ///
    /// This is a variant of [`new_segment()`][Self::new_segment()] sending the segment right away,
    /// which can be useful to ensure events ordering.
    /// ## `segment`
    /// a pointer to a [`gst::Segment`][crate::gst::Segment]
    ///
    /// # Returns
    ///
    /// [`true`] if sending of new segment succeeded.
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "gst_base_src_push_segment")]
    fn push_segment(&self, segment: &gst::Segment) -> bool {
        unsafe {
            from_glib(ffi::gst_base_src_push_segment(
                self.as_ref().to_glib_none().0,
                segment.to_glib_none().0,
            ))
        }
    }

    /// Configure async behaviour in `self`, no state change will block. The open,
    /// close, start, stop, play and pause virtual methods will be executed in a
    /// different thread and are thus allowed to perform blocking operations. Any
    /// blocking operation should be unblocked with the unlock vmethod.
    /// ## `async_`
    /// new async mode
    #[doc(alias = "gst_base_src_set_async")]
    fn set_async(&self, async_: bool) {
        unsafe {
            ffi::gst_base_src_set_async(self.as_ref().to_glib_none().0, async_.into_glib());
        }
    }

    /// If `automatic_eos` is [`true`], `self` will automatically go EOS if a buffer
    /// after the total size is returned. By default this is [`true`] but sources
    /// that can't return an authoritative size and only know that they're EOS
    /// when trying to read more should set this to [`false`].
    ///
    /// When `self` operates in [`gst::Format::Time`][crate::gst::Format::Time], [`BaseSrc`][crate::BaseSrc] will send an EOS
    /// when a buffer outside of the currently configured segment is pushed if
    /// `automatic_eos` is [`true`]. Since 1.16, if `automatic_eos` is [`false`] an
    /// EOS will be pushed only when the `GstBaseSrcClass::create` implementation
    /// returns [`gst::FlowReturn::Eos`][crate::gst::FlowReturn::Eos].
    /// ## `automatic_eos`
    /// automatic eos
    #[doc(alias = "gst_base_src_set_automatic_eos")]
    #[doc(alias = "automatic-eos")]
    fn set_automatic_eos(&self, automatic_eos: bool) {
        unsafe {
            ffi::gst_base_src_set_automatic_eos(
                self.as_ref().to_glib_none().0,
                automatic_eos.into_glib(),
            );
        }
    }

    /// Set the number of bytes that `self` will push out with each buffer. When
    /// `blocksize` is set to -1, a default length will be used.
    /// ## `blocksize`
    /// the new blocksize in bytes
    #[doc(alias = "gst_base_src_set_blocksize")]
    #[doc(alias = "blocksize")]
    fn set_blocksize(&self, blocksize: u32) {
        unsafe {
            ffi::gst_base_src_set_blocksize(self.as_ref().to_glib_none().0, blocksize);
        }
    }

    /// Set new caps on the basesrc source pad.
    /// ## `caps`
    /// a [`gst::Caps`][crate::gst::Caps]
    ///
    /// # Returns
    ///
    /// [`true`] if the caps could be set
    #[doc(alias = "gst_base_src_set_caps")]
    fn set_caps(&self, caps: &gst::Caps) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_base_src_set_caps(self.as_ref().to_glib_none().0, caps.to_glib_none().0),
                "Failed to set caps"
            )
        }
    }

    /// Configure `self` to automatically timestamp outgoing buffers based on the
    /// current running_time of the pipeline. This property is mostly useful for live
    /// sources.
    /// ## `timestamp`
    /// enable or disable timestamping
    #[doc(alias = "gst_base_src_set_do_timestamp")]
    #[doc(alias = "do-timestamp")]
    fn set_do_timestamp(&self, timestamp: bool) {
        unsafe {
            ffi::gst_base_src_set_do_timestamp(
                self.as_ref().to_glib_none().0,
                timestamp.into_glib(),
            );
        }
    }

    /// If not `dynamic`, size is only updated when needed, such as when trying to
    /// read past current tracked size. Otherwise, size is checked for upon each
    /// read.
    /// ## `dynamic`
    /// new dynamic size mode
    #[doc(alias = "gst_base_src_set_dynamic_size")]
    fn set_dynamic_size(&self, dynamic: bool) {
        unsafe {
            ffi::gst_base_src_set_dynamic_size(self.as_ref().to_glib_none().0, dynamic.into_glib());
        }
    }

    ///  [`gst::State::Paused`][crate::gst::State::Paused].
    /// ## `format`
    /// the format to use
    #[doc(alias = "gst_base_src_set_format")]
    fn set_format(&self, format: gst::Format) {
        unsafe {
            ffi::gst_base_src_set_format(self.as_ref().to_glib_none().0, format.into_glib());
        }
    }

    /// If the element listens to a live source, `live` should
    /// be set to [`true`].
    ///
    /// A live source will not produce data in the PAUSED state and
    /// will therefore not be able to participate in the PREROLL phase
    /// of a pipeline. To signal this fact to the application and the
    /// pipeline, the state change return value of the live source will
    /// be GST_STATE_CHANGE_NO_PREROLL.
    /// ## `live`
    /// new live-mode
    #[doc(alias = "gst_base_src_set_live")]
    fn set_live(&self, live: bool) {
        unsafe {
            ffi::gst_base_src_set_live(self.as_ref().to_glib_none().0, live.into_glib());
        }
    }

    /// Complete an asynchronous start operation. When the subclass overrides the
    /// start method, it should call [`start_complete()`][Self::start_complete()] when the start
    /// operation completes either from the same thread or from an asynchronous
    /// helper thread.
    /// ## `ret`
    /// a [`gst::FlowReturn`][crate::gst::FlowReturn]
    #[doc(alias = "gst_base_src_start_complete")]
    fn start_complete(&self, ret: impl Into<gst::FlowReturn>) {
        unsafe {
            ffi::gst_base_src_start_complete(
                self.as_ref().to_glib_none().0,
                ret.into().into_glib(),
            );
        }
    }

    /// Wait until the start operation completes.
    ///
    /// # Returns
    ///
    /// a [`gst::FlowReturn`][crate::gst::FlowReturn].
    #[doc(alias = "gst_base_src_start_wait")]
    fn start_wait(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe { try_from_glib(ffi::gst_base_src_start_wait(self.as_ref().to_glib_none().0)) }
    }

    /// If the `GstBaseSrcClass::create` method performs its own synchronisation
    /// against the clock it must unblock when going from PLAYING to the PAUSED state
    /// and call this method before continuing to produce the remaining data.
    ///
    /// This function will block until a state change to PLAYING happens (in which
    /// case this function returns [`gst::FlowReturn::Ok`][crate::gst::FlowReturn::Ok]) or the processing must be stopped due
    /// to a state change to READY or a FLUSH event (in which case this function
    /// returns [`gst::FlowReturn::Flushing`][crate::gst::FlowReturn::Flushing]).
    ///
    /// # Returns
    ///
    /// [`gst::FlowReturn::Ok`][crate::gst::FlowReturn::Ok] if `self` is PLAYING and processing can
    /// continue. Any other return value should be returned from the create vmethod.
    #[doc(alias = "gst_base_src_wait_playing")]
    fn wait_playing(&self) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe {
            try_from_glib(ffi::gst_base_src_wait_playing(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// See [`set_automatic_eos()`][Self::set_automatic_eos()]
    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "automatic-eos")]
    fn is_automatic_eos(&self) -> bool {
        ObjectExt::property(self.as_ref(), "automatic-eos")
    }

    #[doc(alias = "num-buffers")]
    fn num_buffers(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "num-buffers")
    }

    #[doc(alias = "num-buffers")]
    fn set_num_buffers(&self, num_buffers: i32) {
        ObjectExt::set_property(self.as_ref(), "num-buffers", num_buffers)
    }

    fn is_typefind(&self) -> bool {
        ObjectExt::property(self.as_ref(), "typefind")
    }

    fn set_typefind(&self, typefind: bool) {
        ObjectExt::set_property(self.as_ref(), "typefind", typefind)
    }

    #[cfg(feature = "v1_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_24")))]
    #[doc(alias = "automatic-eos")]
    fn connect_automatic_eos_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_automatic_eos_trampoline<
            P: IsA<BaseSrc>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBaseSrc,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(BaseSrc::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::automatic-eos".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_automatic_eos_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

impl<O: IsA<BaseSrc>> BaseSrcExt for O {}