// 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, RTSPAddress, RTSPAddressPool, RTSPFilterResult, RTSPPublishClockMode, RTSPStreamTransport,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// The definition of a media stream.
    ///
    /// ## Properties
    ///
    ///
    /// #### `control`
    ///  Readable | Writeable
    ///
    ///
    /// #### `profiles`
    ///  Readable | Writeable
    ///
    ///
    /// #### `protocols`
    ///  Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `new-rtcp-encoder`
    ///
    ///
    ///
    /// #### `new-rtp-encoder`
    ///
    ///
    ///
    /// #### `new-rtp-rtcp-decoder`
    ///
    ///
    /// # Implements
    ///
    /// [`RTSPStreamExt`][trait@crate::prelude::RTSPStreamExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GstRTSPStream")]
    pub struct RTSPStream(Object<ffi::GstRTSPStream, ffi::GstRTSPStreamClass>);

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

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

    /// Create a new media stream with index `idx` that handles RTP data on
    /// `pad` and has a payloader element `payloader` if `pad` is a source pad
    /// or a depayloader element `payloader` if `pad` is a sink pad.
    /// ## `idx`
    /// an index
    /// ## `payloader`
    /// a [`gst::Element`][crate::gst::Element]
    /// ## `pad`
    /// a [`gst::Pad`][crate::gst::Pad]
    ///
    /// # Returns
    ///
    /// a new [`RTSPStream`][crate::RTSPStream]
    #[doc(alias = "gst_rtsp_stream_new")]
    pub fn new(
        idx: u32,
        payloader: &impl IsA<gst::Element>,
        pad: &impl IsA<gst::Pad>,
    ) -> RTSPStream {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_new(
                idx,
                payloader.as_ref().to_glib_none().0,
                pad.as_ref().to_glib_none().0,
            ))
        }
    }
}

unsafe impl Send for RTSPStream {}
unsafe impl Sync for RTSPStream {}

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

/// Trait containing all [`struct@RTSPStream`] methods.
///
/// # Implementors
///
/// [`RTSPStream`][struct@crate::RTSPStream]
pub trait RTSPStreamExt: IsA<RTSPStream> + sealed::Sealed + 'static {
    /// Add multicast client address to stream. At this point, the sockets that
    /// will stream RTP and RTCP data to `destination` are supposed to be
    /// allocated.
    /// ## `destination`
    /// a multicast address to add
    /// ## `rtp_port`
    /// RTP port
    /// ## `rtcp_port`
    /// RTCP port
    /// ## `family`
    /// socket family
    ///
    /// # Returns
    ///
    /// [`true`] if `destination` can be addedd and handled by `self`.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_add_multicast_client_address")]
    fn add_multicast_client_address(
        &self,
        destination: &str,
        rtp_port: u32,
        rtcp_port: u32,
        family: gio::SocketFamily,
    ) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_add_multicast_client_address(
                self.as_ref().to_glib_none().0,
                destination.to_glib_none().0,
                rtp_port,
                rtcp_port,
                family.into_glib(),
            ))
        }
    }

    /// Add the transport in `trans` to `self`. The media of `self` will
    /// then also be send to the values configured in `trans`. Adding the
    /// same transport twice will not add it a second time.
    ///
    /// `self` must be joined to a bin.
    ///
    /// `trans` must contain a valid `GstRTSPTransport`.
    /// ## `trans`
    /// a [`RTSPStreamTransport`][crate::RTSPStreamTransport]
    ///
    /// # Returns
    ///
    /// [`true`] if `trans` was added
    #[doc(alias = "gst_rtsp_stream_add_transport")]
    fn add_transport(
        &self,
        trans: &impl IsA<RTSPStreamTransport>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_add_transport(
                    self.as_ref().to_glib_none().0,
                    trans.as_ref().to_glib_none().0
                ),
                "Failed to add transport"
            )
        }
    }

    //#[doc(alias = "gst_rtsp_stream_allocate_udp_sockets")]
    //fn allocate_udp_sockets(&self, family: gio::SocketFamily, transport: /*Ignored*/&mut gst_rtsp::RTSPTransport, use_client_settings: bool) -> bool {
    //    unsafe { TODO: call ffi:gst_rtsp_stream_allocate_udp_sockets() }
    //}

    //#[doc(alias = "gst_rtsp_stream_complete_stream")]
    //fn complete_stream(&self, transport: /*Ignored*/&gst_rtsp::RTSPTransport) -> bool {
    //    unsafe { TODO: call ffi:gst_rtsp_stream_complete_stream() }
    //}

    /// Get the [`RTSPAddressPool`][crate::RTSPAddressPool] used as the address pool of `self`.
    ///
    /// # Returns
    ///
    /// the [`RTSPAddressPool`][crate::RTSPAddressPool] of `self`.
    /// `g_object_unref()` after usage.
    #[doc(alias = "gst_rtsp_stream_get_address_pool")]
    #[doc(alias = "get_address_pool")]
    fn address_pool(&self) -> Option<RTSPAddressPool> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_address_pool(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the size of the UDP transmission buffer (in bytes)
    ///
    /// # Returns
    ///
    /// the size of the UDP TX buffer
    #[doc(alias = "gst_rtsp_stream_get_buffer_size")]
    #[doc(alias = "get_buffer_size")]
    fn buffer_size(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_buffer_size(self.as_ref().to_glib_none().0) }
    }

    /// Retrieve the current caps of `self`.
    ///
    /// # Returns
    ///
    /// the [`gst::Caps`][crate::gst::Caps] of `self`.
    /// use `gst_caps_unref()` after usage.
    #[doc(alias = "gst_rtsp_stream_get_caps")]
    #[doc(alias = "get_caps")]
    fn caps(&self) -> Option<gst::Caps> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_caps(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the control string to identify this stream.
    ///
    /// # Returns
    ///
    /// the control string. `g_free()` after usage.
    #[doc(alias = "gst_rtsp_stream_get_control")]
    #[doc(alias = "get_control")]
    fn control(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_control(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "gst_rtsp_stream_get_current_seqnum")]
    #[doc(alias = "get_current_seqnum")]
    fn current_seqnum(&self) -> u16 {
        unsafe { ffi::gst_rtsp_stream_get_current_seqnum(self.as_ref().to_glib_none().0) }
    }

    /// Get the configured DSCP QoS in of the outgoing sockets.
    ///
    /// # Returns
    ///
    /// the DSCP QoS value of the outgoing sockets, or -1 if disbled.
    #[doc(alias = "gst_rtsp_stream_get_dscp_qos")]
    #[doc(alias = "get_dscp_qos")]
    fn dscp_qos(&self) -> i32 {
        unsafe { ffi::gst_rtsp_stream_get_dscp_qos(self.as_ref().to_glib_none().0) }
    }

    /// Get the stream index.
    ///
    /// # Returns
    ///
    /// the stream index.
    #[doc(alias = "gst_rtsp_stream_get_index")]
    #[doc(alias = "get_index")]
    fn index(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_index(self.as_ref().to_glib_none().0) }
    }

    /// Get the previous joined bin with [`join_bin()`][Self::join_bin()] or NULL.
    ///
    /// # Returns
    ///
    /// the joined bin or NULL.
    #[doc(alias = "gst_rtsp_stream_get_joined_bin")]
    #[doc(alias = "get_joined_bin")]
    fn joined_bin(&self) -> Option<gst::Bin> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_joined_bin(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the the maximum time-to-live value of outgoing multicast packets.
    ///
    /// # Returns
    ///
    /// the maximum time-to-live value of outgoing multicast packets.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_get_max_mcast_ttl")]
    #[doc(alias = "get_max_mcast_ttl")]
    fn max_mcast_ttl(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_max_mcast_ttl(self.as_ref().to_glib_none().0) }
    }

    /// Get the configured MTU in the payloader of `self`.
    ///
    /// # Returns
    ///
    /// the MTU of the payloader.
    #[doc(alias = "gst_rtsp_stream_get_mtu")]
    #[doc(alias = "get_mtu")]
    fn mtu(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_mtu(self.as_ref().to_glib_none().0) }
    }

    /// Get the multicast address of `self` for `family`. The original
    /// [`RTSPAddress`][crate::RTSPAddress] is cached and copy is returned, so freeing the return value
    /// won't release the address from the pool.
    /// ## `family`
    /// the [`gio::SocketFamily`][crate::gio::SocketFamily]
    ///
    /// # Returns
    ///
    /// the [`RTSPAddress`][crate::RTSPAddress] of `self`
    /// or [`None`] when no address could be allocated. `gst_rtsp_address_free()`
    /// after usage.
    #[doc(alias = "gst_rtsp_stream_get_multicast_address")]
    #[doc(alias = "get_multicast_address")]
    fn multicast_address(&self, family: gio::SocketFamily) -> Option<RTSPAddress> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_multicast_address(
                self.as_ref().to_glib_none().0,
                family.into_glib(),
            ))
        }
    }

    /// Get all multicast client addresses that RTP data will be sent to
    ///
    /// # Returns
    ///
    /// A comma separated list of host:port pairs with destinations
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_get_multicast_client_addresses")]
    #[doc(alias = "get_multicast_client_addresses")]
    fn multicast_client_addresses(&self) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_multicast_client_addresses(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the multicast interface used for `self`.
    ///
    /// # Returns
    ///
    /// the multicast interface for `self`.
    /// `g_free()` after usage.
    #[doc(alias = "gst_rtsp_stream_get_multicast_iface")]
    #[doc(alias = "get_multicast_iface")]
    fn multicast_iface(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_multicast_iface(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the allowed profiles of `self`.
    ///
    /// # Returns
    ///
    /// a [`gst_rtsp::RTSPProfile`][crate::gst_rtsp::RTSPProfile]
    #[doc(alias = "gst_rtsp_stream_get_profiles")]
    #[doc(alias = "get_profiles")]
    fn profiles(&self) -> gst_rtsp::RTSPProfile {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_profiles(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the allowed protocols of `self`.
    ///
    /// # Returns
    ///
    /// a [`gst_rtsp::RTSPLowerTrans`][crate::gst_rtsp::RTSPLowerTrans]
    #[doc(alias = "gst_rtsp_stream_get_protocols")]
    #[doc(alias = "get_protocols")]
    fn protocols(&self) -> gst_rtsp::RTSPLowerTrans {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_protocols(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the stream payload type.
    ///
    /// # Returns
    ///
    /// the stream payload type.
    #[doc(alias = "gst_rtsp_stream_get_pt")]
    #[doc(alias = "get_pt")]
    fn pt(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_pt(self.as_ref().to_glib_none().0) }
    }

    /// Gets if and how the stream clock should be published according to RFC7273.
    ///
    /// # Returns
    ///
    /// The GstRTSPPublishClockMode
    #[doc(alias = "gst_rtsp_stream_get_publish_clock_mode")]
    #[doc(alias = "get_publish_clock_mode")]
    fn publish_clock_mode(&self) -> RTSPPublishClockMode {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_publish_clock_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// whether `self` will follow the Rate-Control=no behaviour as specified
    /// in the ONVIF replay spec.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_rtsp_stream_get_rate_control")]
    #[doc(alias = "get_rate_control")]
    fn is_rate_control(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_rate_control(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieve the current rate and/or applied_rate.
    ///
    /// # Returns
    ///
    /// [`true`] if rate and/or applied_rate could be determined.
    ///
    /// ## `rate`
    /// the configured rate
    ///
    /// ## `applied_rate`
    /// the configured applied_rate
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_rtsp_stream_get_rates")]
    #[doc(alias = "get_rates")]
    fn rates(&self) -> Option<(f64, f64)> {
        unsafe {
            let mut rate = std::mem::MaybeUninit::uninit();
            let mut applied_rate = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gst_rtsp_stream_get_rates(
                self.as_ref().to_glib_none().0,
                rate.as_mut_ptr(),
                applied_rate.as_mut_ptr(),
            ));
            if ret {
                Some((rate.assume_init(), applied_rate.assume_init()))
            } else {
                None
            }
        }
    }

    /// Get the payload-type used for retransmission of this stream
    ///
    /// # Returns
    ///
    /// The retransmission PT.
    #[doc(alias = "gst_rtsp_stream_get_retransmission_pt")]
    #[doc(alias = "get_retransmission_pt")]
    fn retransmission_pt(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_retransmission_pt(self.as_ref().to_glib_none().0) }
    }

    /// Get the amount of time to store retransmission data.
    ///
    /// # Returns
    ///
    /// the amount of time to store retransmission data.
    #[doc(alias = "gst_rtsp_stream_get_retransmission_time")]
    #[doc(alias = "get_retransmission_time")]
    fn retransmission_time(&self) -> Option<gst::ClockTime> {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_retransmission_time(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the multicast RTCP socket from `self` for a `family`.
    /// ## `family`
    /// the socket family
    ///
    /// # Returns
    ///
    /// the multicast RTCP socket or [`None`] if no
    /// socket could be allocated for `family`. Unref after usage
    #[doc(alias = "gst_rtsp_stream_get_rtcp_multicast_socket")]
    #[doc(alias = "get_rtcp_multicast_socket")]
    fn rtcp_multicast_socket(&self, family: gio::SocketFamily) -> Option<gio::Socket> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_rtcp_multicast_socket(
                self.as_ref().to_glib_none().0,
                family.into_glib(),
            ))
        }
    }

    /// Get the RTCP socket from `self` for a `family`.
    ///
    /// `self` must be joined to a bin.
    /// ## `family`
    /// the socket family
    ///
    /// # Returns
    ///
    /// the RTCP socket or [`None`] if no
    /// socket could be allocated for `family`. Unref after usage
    #[doc(alias = "gst_rtsp_stream_get_rtcp_socket")]
    #[doc(alias = "get_rtcp_socket")]
    fn rtcp_socket(&self, family: gio::SocketFamily) -> Option<gio::Socket> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_rtcp_socket(
                self.as_ref().to_glib_none().0,
                family.into_glib(),
            ))
        }
    }

    /// Get the multicast RTP socket from `self` for a `family`.
    /// ## `family`
    /// the socket family
    ///
    /// # Returns
    ///
    /// the multicast RTP socket or [`None`] if no
    ///
    /// socket could be allocated for `family`. Unref after usage
    #[doc(alias = "gst_rtsp_stream_get_rtp_multicast_socket")]
    #[doc(alias = "get_rtp_multicast_socket")]
    fn rtp_multicast_socket(&self, family: gio::SocketFamily) -> Option<gio::Socket> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_rtp_multicast_socket(
                self.as_ref().to_glib_none().0,
                family.into_glib(),
            ))
        }
    }

    /// Get the RTP socket from `self` for a `family`.
    ///
    /// `self` must be joined to a bin.
    /// ## `family`
    /// the socket family
    ///
    /// # Returns
    ///
    /// the RTP socket or [`None`] if no
    /// socket could be allocated for `family`. Unref after usage
    #[doc(alias = "gst_rtsp_stream_get_rtp_socket")]
    #[doc(alias = "get_rtp_socket")]
    fn rtp_socket(&self, family: gio::SocketFamily) -> Option<gio::Socket> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_rtp_socket(
                self.as_ref().to_glib_none().0,
                family.into_glib(),
            ))
        }
    }

    /// Retrieve the current rtptime, seq and running-time. This is used to
    /// construct a RTPInfo reply header.
    ///
    /// # Returns
    ///
    /// [`true`] when rtptime, seq and running-time could be determined.
    ///
    /// ## `rtptime`
    /// result RTP timestamp
    ///
    /// ## `seq`
    /// result RTP seqnum
    ///
    /// ## `clock_rate`
    /// the clock rate
    ///
    /// ## `running_time`
    /// result running-time
    #[doc(alias = "gst_rtsp_stream_get_rtpinfo")]
    #[doc(alias = "get_rtpinfo")]
    fn rtpinfo(&self) -> Option<(u32, u32, u32, Option<gst::ClockTime>)> {
        unsafe {
            let mut rtptime = std::mem::MaybeUninit::uninit();
            let mut seq = std::mem::MaybeUninit::uninit();
            let mut clock_rate = std::mem::MaybeUninit::uninit();
            let mut running_time = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gst_rtsp_stream_get_rtpinfo(
                self.as_ref().to_glib_none().0,
                rtptime.as_mut_ptr(),
                seq.as_mut_ptr(),
                clock_rate.as_mut_ptr(),
                running_time.as_mut_ptr(),
            ));
            if ret {
                Some((
                    rtptime.assume_init(),
                    seq.assume_init(),
                    clock_rate.assume_init(),
                    from_glib(running_time.assume_init()),
                ))
            } else {
                None
            }
        }
    }

    /// Get the RTP session of this stream.
    ///
    /// # Returns
    ///
    /// The RTP session of this stream. Unref after usage.
    #[doc(alias = "gst_rtsp_stream_get_rtpsession")]
    #[doc(alias = "get_rtpsession")]
    fn rtpsession(&self) -> Option<glib::Object> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_rtpsession(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gst_rtsp_stream_get_server_port")]
    //#[doc(alias = "get_server_port")]
    //fn server_port(&self, server_port: /*Ignored*/gst_rtsp::RTSPRange, family: gio::SocketFamily) {
    //    unsafe { TODO: call ffi:gst_rtsp_stream_get_server_port() }
    //}

    /// Get the sinkpad associated with `self`.
    ///
    /// # Returns
    ///
    /// the sinkpad. Unref after usage.
    #[doc(alias = "gst_rtsp_stream_get_sinkpad")]
    #[doc(alias = "get_sinkpad")]
    fn sinkpad(&self) -> Option<gst::Pad> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_sinkpad(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the srcpad associated with `self`.
    ///
    /// # Returns
    ///
    /// the srcpad. Unref after usage.
    #[doc(alias = "gst_rtsp_stream_get_srcpad")]
    #[doc(alias = "get_srcpad")]
    fn srcpad(&self) -> Option<gst::Pad> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_srcpad(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the SRTP encoder for this stream.
    ///
    /// # Returns
    ///
    /// The SRTP encoder for this stream. Unref after usage.
    #[doc(alias = "gst_rtsp_stream_get_srtp_encoder")]
    #[doc(alias = "get_srtp_encoder")]
    fn srtp_encoder(&self) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_get_srtp_encoder(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the SSRC used by the RTP session of this stream. This function can only
    /// be called when `self` has been joined.
    ///
    /// # Returns
    ///
    ///
    /// ## `ssrc`
    /// result ssrc
    #[doc(alias = "gst_rtsp_stream_get_ssrc")]
    #[doc(alias = "get_ssrc")]
    fn ssrc(&self) -> u32 {
        unsafe {
            let mut ssrc = std::mem::MaybeUninit::uninit();
            ffi::gst_rtsp_stream_get_ssrc(self.as_ref().to_glib_none().0, ssrc.as_mut_ptr());
            ssrc.assume_init()
        }
    }

    #[doc(alias = "gst_rtsp_stream_get_ulpfec_enabled")]
    #[doc(alias = "get_ulpfec_enabled")]
    fn is_ulpfec_enabled(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_get_ulpfec_enabled(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the amount of redundancy applied when creating ULPFEC
    /// protection packets.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_get_ulpfec_percentage")]
    #[doc(alias = "get_ulpfec_percentage")]
    fn ulpfec_percentage(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_ulpfec_percentage(self.as_ref().to_glib_none().0) }
    }

    ///
    /// # Returns
    ///
    /// the payload type used for ULPFEC protection packets
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_get_ulpfec_pt")]
    #[doc(alias = "get_ulpfec_pt")]
    fn ulpfec_pt(&self) -> u32 {
        unsafe { ffi::gst_rtsp_stream_get_ulpfec_pt(self.as_ref().to_glib_none().0) }
    }

    /// Parse and handle a KeyMgmt header.
    /// ## `keymgmt`
    /// a keymgmt header
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_handle_keymgmt")]
    fn handle_keymgmt(&self, keymgmt: &str) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_handle_keymgmt(
                self.as_ref().to_glib_none().0,
                keymgmt.to_glib_none().0,
            ))
        }
    }

    /// Check if `self` has the control string `control`.
    /// ## `control`
    /// a control string
    ///
    /// # Returns
    ///
    /// [`true`] is `self` has `control` as the control string
    #[doc(alias = "gst_rtsp_stream_has_control")]
    fn has_control(&self, control: Option<&str>) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_has_control(
                self.as_ref().to_glib_none().0,
                control.to_glib_none().0,
            ))
        }
    }

    /// Check if multicast sockets are configured to be bound to multicast addresses.
    ///
    /// # Returns
    ///
    /// [`true`] if multicast sockets are configured to be bound to multicast addresses.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_is_bind_mcast_address")]
    fn is_bind_mcast_address(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_bind_mcast_address(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Check if `self` is blocking on a [`gst::Buffer`][crate::gst::Buffer].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is blocking
    #[doc(alias = "gst_rtsp_stream_is_blocking")]
    fn is_blocking(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_blocking(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// See [`set_client_side()`][Self::set_client_side()]
    ///
    /// # Returns
    ///
    /// TRUE if this [`RTSPStream`][crate::RTSPStream] is client-side.
    #[doc(alias = "gst_rtsp_stream_is_client_side")]
    fn is_client_side(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_client_side(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the stream is complete, contains the receiver and the sender
    /// parts. As the stream contains sink(s) element(s), it's possible to perform
    /// seek operations on it.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream contains at least one sink element.
    #[doc(alias = "gst_rtsp_stream_is_complete")]
    fn is_complete(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_complete(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the stream is a receiver.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream is a receiver and [`false`] otherwise.
    #[doc(alias = "gst_rtsp_stream_is_receiver")]
    fn is_receiver(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_receiver(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks whether the stream is a sender.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream is a sender and [`false`] otherwise.
    #[doc(alias = "gst_rtsp_stream_is_sender")]
    fn is_sender(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_is_sender(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gst_rtsp_stream_is_transport_supported")]
    //fn is_transport_supported(&self, transport: /*Ignored*/&mut gst_rtsp::RTSPTransport) -> bool {
    //    unsafe { TODO: call ffi:gst_rtsp_stream_is_transport_supported() }
    //}

    /// Join the [`gst::Bin`][crate::gst::Bin] `bin` that contains the element `rtpbin`.
    ///
    /// `self` will link to `rtpbin`, which must be inside `bin`. The elements
    /// added to `bin` will be set to the state given in `state`.
    /// ## `bin`
    /// a [`gst::Bin`][crate::gst::Bin] to join
    /// ## `rtpbin`
    /// a rtpbin element in `bin`
    /// ## `state`
    /// the target state of the new elements
    ///
    /// # Returns
    ///
    /// [`true`] on success.
    #[doc(alias = "gst_rtsp_stream_join_bin")]
    fn join_bin(
        &self,
        bin: &impl IsA<gst::Bin>,
        rtpbin: &impl IsA<gst::Element>,
        state: gst::State,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_join_bin(
                    self.as_ref().to_glib_none().0,
                    bin.as_ref().to_glib_none().0,
                    rtpbin.as_ref().to_glib_none().0,
                    state.into_glib()
                ),
                "Failed to join bin"
            )
        }
    }

    /// Remove the elements of `self` from `bin`.
    /// ## `bin`
    /// a [`gst::Bin`][crate::gst::Bin]
    /// ## `rtpbin`
    /// a rtpbin [`gst::Element`][crate::gst::Element]
    ///
    /// # Returns
    ///
    /// [`true`] on success.
    #[doc(alias = "gst_rtsp_stream_leave_bin")]
    fn leave_bin(
        &self,
        bin: &impl IsA<gst::Bin>,
        rtpbin: &impl IsA<gst::Element>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_leave_bin(
                    self.as_ref().to_glib_none().0,
                    bin.as_ref().to_glib_none().0,
                    rtpbin.as_ref().to_glib_none().0
                ),
                "Failed to leave bin"
            )
        }
    }

    /// Handle an RTCP buffer for the stream. This method is usually called when a
    /// message has been received from a client using the TCP transport.
    ///
    /// This function takes ownership of `buffer`.
    /// ## `buffer`
    /// a [`gst::Buffer`][crate::gst::Buffer]
    ///
    /// # Returns
    ///
    /// a GstFlowReturn.
    #[doc(alias = "gst_rtsp_stream_recv_rtcp")]
    fn recv_rtcp(&self, buffer: gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe {
            try_from_glib(ffi::gst_rtsp_stream_recv_rtcp(
                self.as_ref().to_glib_none().0,
                buffer.into_glib_ptr(),
            ))
        }
    }

    /// Handle an RTP buffer for the stream. This method is usually called when a
    /// message has been received from a client using the TCP transport.
    ///
    /// This function takes ownership of `buffer`.
    /// ## `buffer`
    /// a [`gst::Buffer`][crate::gst::Buffer]
    ///
    /// # Returns
    ///
    /// a GstFlowReturn.
    #[doc(alias = "gst_rtsp_stream_recv_rtp")]
    fn recv_rtp(&self, buffer: gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
        unsafe {
            try_from_glib(ffi::gst_rtsp_stream_recv_rtp(
                self.as_ref().to_glib_none().0,
                buffer.into_glib_ptr(),
            ))
        }
    }

    /// Remove the transport in `trans` from `self`. The media of `self` will
    /// not be sent to the values configured in `trans`.
    ///
    /// `self` must be joined to a bin.
    ///
    /// `trans` must contain a valid `GstRTSPTransport`.
    /// ## `trans`
    /// a [`RTSPStreamTransport`][crate::RTSPStreamTransport]
    ///
    /// # Returns
    ///
    /// [`true`] if `trans` was removed
    #[doc(alias = "gst_rtsp_stream_remove_transport")]
    fn remove_transport(
        &self,
        trans: &impl IsA<RTSPStreamTransport>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_remove_transport(
                    self.as_ref().to_glib_none().0,
                    trans.as_ref().to_glib_none().0
                ),
                "Failed to remove transport"
            )
        }
    }

    /// Creating a rtxreceive bin
    /// ## `sessid`
    /// the session id
    ///
    /// # Returns
    ///
    /// a [`gst::Element`][crate::gst::Element].
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_request_aux_receiver")]
    fn request_aux_receiver(&self, sessid: u32) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_request_aux_receiver(
                self.as_ref().to_glib_none().0,
                sessid,
            ))
        }
    }

    /// Creating a rtxsend bin
    /// ## `sessid`
    /// the session id
    ///
    /// # Returns
    ///
    /// a [`gst::Element`][crate::gst::Element].
    #[doc(alias = "gst_rtsp_stream_request_aux_sender")]
    fn request_aux_sender(&self, sessid: u32) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_request_aux_sender(
                self.as_ref().to_glib_none().0,
                sessid,
            ))
        }
    }

    /// Creating a rtpulpfecdec element
    ///
    /// # Returns
    ///
    /// a [`gst::Element`][crate::gst::Element].
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_request_ulpfec_decoder")]
    fn request_ulpfec_decoder(
        &self,
        rtpbin: &impl IsA<gst::Element>,
        sessid: u32,
    ) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_request_ulpfec_decoder(
                self.as_ref().to_glib_none().0,
                rtpbin.as_ref().to_glib_none().0,
                sessid,
            ))
        }
    }

    /// Creating a rtpulpfecenc element
    ///
    /// # Returns
    ///
    /// a [`gst::Element`][crate::gst::Element].
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_request_ulpfec_encoder")]
    fn request_ulpfec_encoder(&self, sessid: u32) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_request_ulpfec_encoder(
                self.as_ref().to_glib_none().0,
                sessid,
            ))
        }
    }

    /// Reserve `address` and `port` as the address and port of `self`. The original
    /// [`RTSPAddress`][crate::RTSPAddress] is cached and copy is returned, so freeing the return value
    /// won't release the address from the pool.
    /// ## `address`
    /// an address
    /// ## `port`
    /// a port
    /// ## `n_ports`
    /// n_ports
    /// ## `ttl`
    /// a TTL
    ///
    /// # Returns
    ///
    /// the [`RTSPAddress`][crate::RTSPAddress] of `self` or [`None`] when
    /// the address could not be reserved. `gst_rtsp_address_free()` after
    /// usage.
    #[doc(alias = "gst_rtsp_stream_reserve_address")]
    fn reserve_address(
        &self,
        address: &str,
        port: u32,
        n_ports: u32,
        ttl: u32,
    ) -> Option<RTSPAddress> {
        unsafe {
            from_glib_full(ffi::gst_rtsp_stream_reserve_address(
                self.as_ref().to_glib_none().0,
                address.to_glib_none().0,
                port,
                n_ports,
                ttl,
            ))
        }
    }

    /// Checks whether the individual `self` is seekable.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is seekable, else [`false`].
    #[doc(alias = "gst_rtsp_stream_seekable")]
    fn seekable(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_seekable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// configure `pool` to be used as the address pool of `self`.
    /// ## `pool`
    /// a [`RTSPAddressPool`][crate::RTSPAddressPool]
    #[doc(alias = "gst_rtsp_stream_set_address_pool")]
    fn set_address_pool(&self, pool: Option<&impl IsA<RTSPAddressPool>>) {
        unsafe {
            ffi::gst_rtsp_stream_set_address_pool(
                self.as_ref().to_glib_none().0,
                pool.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Decide whether the multicast socket should be bound to a multicast address or
    /// INADDR_ANY.
    /// ## `bind_mcast_addr`
    /// the new value
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_set_bind_mcast_address")]
    fn set_bind_mcast_address(&self, bind_mcast_addr: bool) {
        unsafe {
            ffi::gst_rtsp_stream_set_bind_mcast_address(
                self.as_ref().to_glib_none().0,
                bind_mcast_addr.into_glib(),
            );
        }
    }

    /// Blocks or unblocks the dataflow on `self`.
    /// ## `blocked`
    /// boolean indicating we should block or unblock
    ///
    /// # Returns
    ///
    /// [`true`] on success
    #[doc(alias = "gst_rtsp_stream_set_blocked")]
    fn set_blocked(&self, blocked: bool) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_set_blocked(
                    self.as_ref().to_glib_none().0,
                    blocked.into_glib()
                ),
                "Failed to block/unblock the dataflow"
            )
        }
    }

    /// Set the size of the UDP transmission buffer (in bytes)
    /// Needs to be set before the stream is joined to a bin.
    /// ## `size`
    /// the buffer size
    #[doc(alias = "gst_rtsp_stream_set_buffer_size")]
    fn set_buffer_size(&self, size: u32) {
        unsafe {
            ffi::gst_rtsp_stream_set_buffer_size(self.as_ref().to_glib_none().0, size);
        }
    }

    /// Sets the [`RTSPStream`][crate::RTSPStream] as a 'client side' stream - used for sending
    /// streams to an RTSP server via RECORD. This has the practical effect
    /// of changing which UDP port numbers are used when setting up the local
    /// side of the stream sending to be either the 'server' or 'client' pair
    /// of a configured UDP transport.
    /// ## `client_side`
    /// TRUE if this [`RTSPStream`][crate::RTSPStream] is running on the 'client' side of
    /// an RTSP connection.
    #[doc(alias = "gst_rtsp_stream_set_client_side")]
    fn set_client_side(&self, client_side: bool) {
        unsafe {
            ffi::gst_rtsp_stream_set_client_side(
                self.as_ref().to_glib_none().0,
                client_side.into_glib(),
            );
        }
    }

    /// Set the control string in `self`.
    /// ## `control`
    /// a control string
    #[doc(alias = "gst_rtsp_stream_set_control")]
    #[doc(alias = "control")]
    fn set_control(&self, control: Option<&str>) {
        unsafe {
            ffi::gst_rtsp_stream_set_control(
                self.as_ref().to_glib_none().0,
                control.to_glib_none().0,
            );
        }
    }

    /// Configure the dscp qos of the outgoing sockets to `dscp_qos`.
    /// ## `dscp_qos`
    /// a new dscp qos value (0-63, or -1 to disable)
    #[doc(alias = "gst_rtsp_stream_set_dscp_qos")]
    fn set_dscp_qos(&self, dscp_qos: i32) {
        unsafe {
            ffi::gst_rtsp_stream_set_dscp_qos(self.as_ref().to_glib_none().0, dscp_qos);
        }
    }

    /// Set the maximum time-to-live value of outgoing multicast packets.
    /// ## `ttl`
    /// the new multicast ttl value
    ///
    /// # Returns
    ///
    /// [`true`] if the requested ttl has been set successfully.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_set_max_mcast_ttl")]
    fn set_max_mcast_ttl(&self, ttl: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_set_max_mcast_ttl(
                self.as_ref().to_glib_none().0,
                ttl,
            ))
        }
    }

    /// Configure the mtu in the payloader of `self` to `mtu`.
    /// ## `mtu`
    /// a new MTU
    #[doc(alias = "gst_rtsp_stream_set_mtu")]
    fn set_mtu(&self, mtu: u32) {
        unsafe {
            ffi::gst_rtsp_stream_set_mtu(self.as_ref().to_glib_none().0, mtu);
        }
    }

    /// configure `multicast_iface` to be used for `self`.
    /// ## `multicast_iface`
    /// a multicast interface name
    #[doc(alias = "gst_rtsp_stream_set_multicast_iface")]
    fn set_multicast_iface(&self, multicast_iface: Option<&str>) {
        unsafe {
            ffi::gst_rtsp_stream_set_multicast_iface(
                self.as_ref().to_glib_none().0,
                multicast_iface.to_glib_none().0,
            );
        }
    }

    /// Configure the allowed profiles for `self`.
    /// ## `profiles`
    /// the new profiles
    #[doc(alias = "gst_rtsp_stream_set_profiles")]
    #[doc(alias = "profiles")]
    fn set_profiles(&self, profiles: gst_rtsp::RTSPProfile) {
        unsafe {
            ffi::gst_rtsp_stream_set_profiles(self.as_ref().to_glib_none().0, profiles.into_glib());
        }
    }

    /// Configure the allowed lower transport for `self`.
    /// ## `protocols`
    /// the new flags
    #[doc(alias = "gst_rtsp_stream_set_protocols")]
    #[doc(alias = "protocols")]
    fn set_protocols(&self, protocols: gst_rtsp::RTSPLowerTrans) {
        unsafe {
            ffi::gst_rtsp_stream_set_protocols(
                self.as_ref().to_glib_none().0,
                protocols.into_glib(),
            );
        }
    }

    /// Configure a pt map between `pt` and `caps`.
    /// ## `pt`
    /// the pt
    /// ## `caps`
    /// a [`gst::Caps`][crate::gst::Caps]
    #[doc(alias = "gst_rtsp_stream_set_pt_map")]
    fn set_pt_map(&self, pt: u32, caps: &gst::Caps) {
        unsafe {
            ffi::gst_rtsp_stream_set_pt_map(
                self.as_ref().to_glib_none().0,
                pt,
                caps.to_glib_none().0,
            );
        }
    }

    /// Sets if and how the stream clock should be published according to RFC7273.
    /// ## `mode`
    /// the clock publish mode
    #[doc(alias = "gst_rtsp_stream_set_publish_clock_mode")]
    fn set_publish_clock_mode(&self, mode: RTSPPublishClockMode) {
        unsafe {
            ffi::gst_rtsp_stream_set_publish_clock_mode(
                self.as_ref().to_glib_none().0,
                mode.into_glib(),
            );
        }
    }

    /// Define whether `self` will follow the Rate-Control=no behaviour as specified
    /// in the ONVIF replay spec.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "gst_rtsp_stream_set_rate_control")]
    fn set_rate_control(&self, enabled: bool) {
        unsafe {
            ffi::gst_rtsp_stream_set_rate_control(
                self.as_ref().to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Set the payload type (pt) for retransmission of this stream.
    /// ## `rtx_pt`
    /// a `guint`
    #[doc(alias = "gst_rtsp_stream_set_retransmission_pt")]
    fn set_retransmission_pt(&self, rtx_pt: u32) {
        unsafe {
            ffi::gst_rtsp_stream_set_retransmission_pt(self.as_ref().to_glib_none().0, rtx_pt);
        }
    }

    /// Set the amount of time to store retransmission packets.
    /// ## `time`
    /// a `GstClockTime`
    #[doc(alias = "gst_rtsp_stream_set_retransmission_time")]
    fn set_retransmission_time(&self, time: impl Into<Option<gst::ClockTime>>) {
        unsafe {
            ffi::gst_rtsp_stream_set_retransmission_time(
                self.as_ref().to_glib_none().0,
                time.into().into_glib(),
            );
        }
    }

    #[doc(alias = "gst_rtsp_stream_set_seqnum_offset")]
    fn set_seqnum_offset(&self, seqnum: u16) {
        unsafe {
            ffi::gst_rtsp_stream_set_seqnum_offset(self.as_ref().to_glib_none().0, seqnum);
        }
    }

    /// Sets the amount of redundancy to apply when creating ULPFEC
    /// protection packets.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_set_ulpfec_percentage")]
    fn set_ulpfec_percentage(&self, percentage: u32) {
        unsafe {
            ffi::gst_rtsp_stream_set_ulpfec_percentage(self.as_ref().to_glib_none().0, percentage);
        }
    }

    /// Set the payload type to be used for ULPFEC protection packets
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_set_ulpfec_pt")]
    fn set_ulpfec_pt(&self, pt: u32) {
        unsafe {
            ffi::gst_rtsp_stream_set_ulpfec_pt(self.as_ref().to_glib_none().0, pt);
        }
    }

    /// Call `func` for each transport managed by `self`. The result value of `func`
    /// determines what happens to the transport. `func` will be called with `self`
    /// locked so no further actions on `self` can be performed from `func`.
    ///
    /// If `func` returns [`RTSPFilterResult::Remove`][crate::RTSPFilterResult::Remove], the transport will be removed from
    /// `self`.
    ///
    /// If `func` returns [`RTSPFilterResult::Keep`][crate::RTSPFilterResult::Keep], the transport will remain in `self`.
    ///
    /// If `func` returns [`RTSPFilterResult::Ref`][crate::RTSPFilterResult::Ref], the transport will remain in `self` but
    /// will also be added with an additional ref to the result `GList` of this
    /// function..
    ///
    /// When `func` is [`None`], [`RTSPFilterResult::Ref`][crate::RTSPFilterResult::Ref] will be assumed for each transport.
    /// ## `func`
    /// a callback
    ///
    /// # Returns
    ///
    /// a `GList` with all
    /// transports for which `func` returned [`RTSPFilterResult::Ref`][crate::RTSPFilterResult::Ref]. After usage, each
    /// element in the `GList` should be unreffed before the list is freed.
    #[doc(alias = "gst_rtsp_stream_transport_filter")]
    fn transport_filter(
        &self,
        func: Option<&mut dyn (FnMut(&RTSPStream, &RTSPStreamTransport) -> RTSPFilterResult)>,
    ) -> Vec<RTSPStreamTransport> {
        let func_data: Option<
            &mut dyn (FnMut(&RTSPStream, &RTSPStreamTransport) -> RTSPFilterResult),
        > = func;
        unsafe extern "C" fn func_func(
            stream: *mut ffi::GstRTSPStream,
            trans: *mut ffi::GstRTSPStreamTransport,
            user_data: glib::ffi::gpointer,
        ) -> ffi::GstRTSPFilterResult {
            let stream = from_glib_borrow(stream);
            let trans = from_glib_borrow(trans);
            let callback = user_data
                as *mut Option<
                    &mut dyn (FnMut(&RTSPStream, &RTSPStreamTransport) -> RTSPFilterResult),
                >;
            if let Some(ref mut callback) = *callback {
                callback(&stream, &trans)
            } else {
                panic!("cannot get closure...")
            }
            .into_glib()
        }
        let func = if func_data.is_some() {
            Some(func_func as _)
        } else {
            None
        };
        let super_callback0: &Option<
            &mut dyn (FnMut(&RTSPStream, &RTSPStreamTransport) -> RTSPFilterResult),
        > = &func_data;
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gst_rtsp_stream_transport_filter(
                self.as_ref().to_glib_none().0,
                func,
                super_callback0 as *const _ as *mut _,
            ))
        }
    }

    #[doc(alias = "gst_rtsp_stream_unblock_linked")]
    fn unblock_linked(&self) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_unblock_linked(self.as_ref().to_glib_none().0),
                "Failed to unblock the dataflow"
            )
        }
    }

    /// Remove blocking probe from the RTCP source. When creating an UDP source for
    /// RTCP it is initially blocked until this function is called.
    /// This functions should be called once the pipeline is ready for handling RTCP
    /// packets.
    #[cfg(feature = "v1_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_20")))]
    #[doc(alias = "gst_rtsp_stream_unblock_rtcp")]
    fn unblock_rtcp(&self) {
        unsafe {
            ffi::gst_rtsp_stream_unblock_rtcp(self.as_ref().to_glib_none().0);
        }
    }

    /// Update the new crypto information for `ssrc` in `self`. If information
    /// for `ssrc` did not exist, it will be added. If information
    /// for `ssrc` existed, it will be replaced. If `crypto` is [`None`], it will
    /// be removed from `self`.
    /// ## `ssrc`
    /// the SSRC
    /// ## `crypto`
    /// a [`gst::Caps`][crate::gst::Caps] with crypto info
    ///
    /// # Returns
    ///
    /// [`true`] if `crypto` could be updated
    #[doc(alias = "gst_rtsp_stream_update_crypto")]
    fn update_crypto(
        &self,
        ssrc: u32,
        crypto: Option<&gst::Caps>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_rtsp_stream_update_crypto(
                    self.as_ref().to_glib_none().0,
                    ssrc,
                    crypto.to_glib_none().0
                ),
                "Failed to update crypto"
            )
        }
    }

    /// Check if the requested multicast ttl value is allowed.
    /// ## `ttl`
    /// a requested multicast ttl
    ///
    /// # Returns
    ///
    /// TRUE if the requested ttl value is allowed.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "gst_rtsp_stream_verify_mcast_ttl")]
    fn verify_mcast_ttl(&self, ttl: u32) -> bool {
        unsafe {
            from_glib(ffi::gst_rtsp_stream_verify_mcast_ttl(
                self.as_ref().to_glib_none().0,
                ttl,
            ))
        }
    }

    #[doc(alias = "new-rtcp-encoder")]
    fn connect_new_rtcp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn new_rtcp_encoder_trampoline<
            P: IsA<RTSPStream>,
            F: Fn(&P, &gst::Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstRTSPStream,
            object: *mut gst::ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                RTSPStream::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"new-rtcp-encoder\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    new_rtcp_encoder_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "new-rtp-encoder")]
    fn connect_new_rtp_encoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn new_rtp_encoder_trampoline<
            P: IsA<RTSPStream>,
            F: Fn(&P, &gst::Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstRTSPStream,
            object: *mut gst::ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                RTSPStream::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"new-rtp-encoder\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    new_rtp_encoder_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "new-rtp-rtcp-decoder")]
    fn connect_new_rtp_rtcp_decoder<F: Fn(&Self, &gst::Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn new_rtp_rtcp_decoder_trampoline<
            P: IsA<RTSPStream>,
            F: Fn(&P, &gst::Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstRTSPStream,
            object: *mut gst::ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                RTSPStream::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"new-rtp-rtcp-decoder\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    new_rtp_rtcp_decoder_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

impl<O: IsA<RTSPStream>> RTSPStreamExt for O {}