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

glib::wrapper! {
    /// A [`Pipeline`][crate::Pipeline] can take an audio-video [`Timeline`][crate::Timeline] and conveniently
    /// link its [`Track`][crate::Track]-s to an internal `playsink` element, for
    /// preview/playback, and an internal `encodebin` element, for rendering.
    /// You can switch between these modes using [`GESPipelineExt::set_mode()`][crate::prelude::GESPipelineExt::set_mode()].
    ///
    /// You can choose the specific audio and video sinks used for previewing
    /// the timeline by setting the [`audio-sink`][struct@crate::Pipeline#audio-sink] and
    /// [`video-sink`][struct@crate::Pipeline#video-sink] properties.
    ///
    /// You can set the encoding and save location used in rendering by calling
    /// [`GESPipelineExt::set_render_settings()`][crate::prelude::GESPipelineExt::set_render_settings()].
    ///
    /// ## Properties
    ///
    ///
    /// #### `audio-filter`
    ///  The audio filter(s) to apply during playback in preview mode,
    /// immediately before the [`audio-sink`][struct@crate::Pipeline#audio-sink]. This exposes the
    /// `playsink:audio-filter` property of the internal `playsink`.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `audio-sink`
    ///  The audio sink used for preview. This exposes the
    /// `playsink:audio-sink` property of the internal `playsink`.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `mode`
    ///  The pipeline's mode. In preview mode (for audio or video, or both)
    /// the pipeline can display the timeline's content to an end user. In
    /// rendering mode the pipeline can encode the timeline's content and
    /// save it to a file.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `timeline`
    ///  The timeline used by this pipeline, whose content it will play and
    /// render, or [`None`] if the pipeline does not yet have a timeline.
    ///
    /// Note that after you set the timeline for the first time, subsequent
    /// calls to change the timeline will fail.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `video-filter`
    ///  The video filter(s) to apply during playback in preview mode,
    /// immediately before the [`video-sink`][struct@crate::Pipeline#video-sink]. This exposes the
    /// `playsink:video-filter` property of the internal `playsink`.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `video-sink`
    ///  The video sink used for preview. This exposes the
    /// `playsink:video-sink` property of the internal `playsink`.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Pipeline</h4></summary>
    ///
    ///
    /// #### `auto-flush-bus`
    ///  Whether or not to automatically flush all messages on the
    /// pipeline's bus when going from READY to NULL state. Please see
    /// [`PipelineExtManual::set_auto_flush_bus()`][crate::gst::prelude::PipelineExtManual::set_auto_flush_bus()] for more information on this option.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `delay`
    ///  The expected delay needed for elements to spin up to the
    /// PLAYING state expressed in nanoseconds.
    /// see [`PipelineExtManual::set_delay()`][crate::gst::prelude::PipelineExtManual::set_delay()] for more information on this option.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `latency`
    ///  Latency to configure on the pipeline. See [`PipelineExtManual::set_latency()`][crate::gst::prelude::PipelineExtManual::set_latency()].
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Bin</h4></summary>
    ///
    ///
    /// #### `async-handling`
    ///  If set to [`true`], the bin will handle asynchronous state changes.
    /// This should be used only if the bin subclass is modifying the state
    /// of its children on its own.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `message-forward`
    ///  Forward all children messages, even those that would normally be filtered by
    /// the bin. This can be interesting when one wants to be notified of the EOS
    /// state of individual elements, for example.
    ///
    /// The messages are converted to an ELEMENT message with the bin as the
    /// source. The structure of the message is named `GstBinForwarded` and contains
    /// a field named `message` that contains the original forwarded `GstMessage`.
    ///
    /// 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
    /// [`element-added`][struct@crate::gst::Bin#element-added] or [`element-removed`][struct@crate::gst::Bin#element-removed] signals on the parent to
    /// achieve a similar effect.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`GESPipelineExt`][trait@crate::prelude::GESPipelineExt], [`trait@gst::prelude::PipelineExt`], [`trait@gst::prelude::BinExt`], [`trait@gst::prelude::ElementExt`], [`trait@gst::prelude::GstObjectExt`], [`trait@glib::ObjectExt`], [`trait@gst::prelude::ChildProxyExt`]
    #[doc(alias = "GESPipeline")]
    pub struct Pipeline(Object<ffi::GESPipeline, ffi::GESPipelineClass>) @extends gst::Pipeline, gst::Bin, gst::Element, gst::Object, @implements gst::ChildProxy;

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

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

    /// Creates a new pipeline.
    ///
    /// # Returns
    ///
    /// The newly created pipeline.
    #[doc(alias = "ges_pipeline_new")]
    pub fn new() -> Pipeline {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::ges_pipeline_new()) }
    }
}

impl Default for Pipeline {
    fn default() -> Self {
        Self::new()
    }
}

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

/// Trait containing all [`struct@Pipeline`] methods.
///
/// # Implementors
///
/// [`Pipeline`][struct@crate::Pipeline]
pub trait GESPipelineExt: IsA<Pipeline> + sealed::Sealed + 'static {
    /// Gets the [`mode`][struct@crate::Pipeline#mode] of the pipeline.
    ///
    /// # Returns
    ///
    /// The current mode of `self`.
    #[doc(alias = "ges_pipeline_get_mode")]
    #[doc(alias = "get_mode")]
    fn mode(&self) -> PipelineFlags {
        unsafe { from_glib(ffi::ges_pipeline_get_mode(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a sample from the pipeline of the currently displayed image in
    /// preview, in the specified format.
    ///
    /// Note that if you use "ANY" caps for `caps`, then the current format of
    /// the image is used. You can retrieve these caps from the returned sample
    /// with `gst_sample_get_caps()`.
    /// ## `caps`
    /// Some caps to specifying the desired format, or
    /// `GST_CAPS_ANY` to use the native format
    ///
    /// # Returns
    ///
    /// A sample of `self`'s current image preview in
    /// the format given by `caps`, or [`None`] if an error prevented fetching the
    /// sample.
    #[doc(alias = "ges_pipeline_get_thumbnail")]
    #[doc(alias = "get_thumbnail")]
    fn thumbnail(&self, caps: &gst::Caps) -> Option<gst::Sample> {
        unsafe {
            from_glib_full(ffi::ges_pipeline_get_thumbnail(
                self.as_ref().to_glib_none().0,
                caps.to_glib_none().0,
            ))
        }
    }

    /// Gets a sample from the pipeline of the currently displayed image in
    /// preview, in the 24-bit "RGB" format and of the desired width and
    /// height.
    ///
    /// See [`thumbnail()`][Self::thumbnail()].
    /// ## `width`
    /// The requested pixel width of the image, or -1 to use the native
    /// size
    /// ## `height`
    /// The requested pixel height of the image, or -1 to use the
    /// native size
    ///
    /// # Returns
    ///
    /// A sample of `self`'s current image preview in
    /// the "RGB" format, scaled to `width` and `height`, or [`None`] if an error
    /// prevented fetching the sample.
    #[doc(alias = "ges_pipeline_get_thumbnail_rgb24")]
    #[doc(alias = "get_thumbnail_rgb24")]
    fn thumbnail_rgb24(&self, width: i32, height: i32) -> Option<gst::Sample> {
        unsafe {
            from_glib_full(ffi::ges_pipeline_get_thumbnail_rgb24(
                self.as_ref().to_glib_none().0,
                width,
                height,
            ))
        }
    }

    /// Gets the [`audio-sink`][struct@crate::Pipeline#audio-sink] of the pipeline.
    ///
    /// # Returns
    ///
    /// The audio sink used by `self` for preview.
    #[doc(alias = "ges_pipeline_preview_get_audio_sink")]
    fn preview_get_audio_sink(&self) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::ges_pipeline_preview_get_audio_sink(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`video-sink`][struct@crate::Pipeline#video-sink] of the pipeline.
    ///
    /// # Returns
    ///
    /// The video sink used by `self` for preview.
    #[doc(alias = "ges_pipeline_preview_get_video_sink")]
    fn preview_get_video_sink(&self) -> Option<gst::Element> {
        unsafe {
            from_glib_full(ffi::ges_pipeline_preview_get_video_sink(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the [`audio-sink`][struct@crate::Pipeline#audio-sink] of the pipeline.
    /// ## `sink`
    /// A audio sink for `self` to use for preview
    #[doc(alias = "ges_pipeline_preview_set_audio_sink")]
    fn preview_set_audio_sink(&self, sink: Option<&impl IsA<gst::Element>>) {
        unsafe {
            ffi::ges_pipeline_preview_set_audio_sink(
                self.as_ref().to_glib_none().0,
                sink.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the [`video-sink`][struct@crate::Pipeline#video-sink] of the pipeline.
    /// ## `sink`
    /// A video sink for `self` to use for preview
    #[doc(alias = "ges_pipeline_preview_set_video_sink")]
    fn preview_set_video_sink(&self, sink: Option<&impl IsA<gst::Element>>) {
        unsafe {
            ffi::ges_pipeline_preview_set_video_sink(
                self.as_ref().to_glib_none().0,
                sink.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Saves the currently displayed image of the pipeline in preview to the
    /// given location, in the specified dimensions and format.
    /// ## `width`
    /// The requested pixel width of the image, or -1 to use the native
    /// size
    /// ## `height`
    /// The requested pixel height of the image, or -1 to use the
    /// native size
    /// ## `format`
    /// The desired mime type (for example, "image/jpeg")
    /// ## `location`
    /// The path to save the thumbnail to
    ///
    /// # Returns
    ///
    /// [`true`] if `self`'s current image preview was successfully saved
    /// to `location` using the given `format`, `height` and `width`.
    #[doc(alias = "ges_pipeline_save_thumbnail")]
    fn save_thumbnail(
        &self,
        width: i32,
        height: i32,
        format: &str,
        location: &str,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::ges_pipeline_save_thumbnail(
                self.as_ref().to_glib_none().0,
                width,
                height,
                format.to_glib_none().0,
                location.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the [`mode`][struct@crate::Pipeline#mode] of the pipeline.
    ///
    /// Note that the pipeline will be set to [`gst::State::Null`][crate::gst::State::Null] during this call to
    /// perform the necessary changes. You will need to set the state again yourself
    /// after calling this.
    ///
    /// > **NOTE**: [Rendering settings](ges_pipeline_set_render_settings) need to be
    /// > set before setting `mode` to [`PipelineFlags::RENDER`][crate::PipelineFlags::RENDER] or
    /// > [`PipelineFlags::SMART_RENDER`][crate::PipelineFlags::SMART_RENDER], the call to this method will fail
    /// > otherwise.
    /// ## `mode`
    /// The mode to set for `self`
    ///
    /// # Returns
    ///
    /// [`true`] if the mode of `self` was successfully set to `mode`.
    #[doc(alias = "ges_pipeline_set_mode")]
    #[doc(alias = "mode")]
    fn set_mode(&self, mode: PipelineFlags) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_pipeline_set_mode(self.as_ref().to_glib_none().0, mode.into_glib()),
                "Failed to set mode"
            )
        }
    }

    /// Specifies encoding setting to be used by the pipeline to render its
    /// [`timeline`][struct@crate::Pipeline#timeline], and where the result should be written to.
    ///
    /// This method **must** be called before setting the pipeline mode to
    /// [`PipelineFlags::RENDER`][crate::PipelineFlags::RENDER].
    /// ## `output_uri`
    /// The URI to save the [`timeline`][struct@crate::Pipeline#timeline] rendering
    /// result to
    /// ## `profile`
    /// The encoding to use for rendering the [`timeline`][struct@crate::Pipeline#timeline]
    ///
    /// # Returns
    ///
    /// [`true`] if the settings were successfully set on `self`.
    #[doc(alias = "ges_pipeline_set_render_settings")]
    fn set_render_settings(
        &self,
        output_uri: &str,
        profile: &impl IsA<gst_pbutils::EncodingProfile>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_pipeline_set_render_settings(
                    self.as_ref().to_glib_none().0,
                    output_uri.to_glib_none().0,
                    profile.as_ref().to_glib_none().0
                ),
                "Failed to set render settings"
            )
        }
    }

    /// Takes the given timeline and sets it as the [`timeline`][struct@crate::Pipeline#timeline] for
    /// the pipeline.
    ///
    /// Note that you should only call this method once on a given pipeline
    /// because a pipeline can not have its [`timeline`][struct@crate::Pipeline#timeline] changed after
    /// it has been set.
    /// ## `timeline`
    /// The timeline to set for `self`
    ///
    /// # Returns
    ///
    /// [`true`] if `timeline` was successfully given to `self`.
    #[doc(alias = "ges_pipeline_set_timeline")]
    #[doc(alias = "timeline")]
    fn set_timeline(&self, timeline: &impl IsA<Timeline>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_pipeline_set_timeline(
                    self.as_ref().to_glib_none().0,
                    timeline.as_ref().to_glib_none().0
                ),
                "Failed to set timeline"
            )
        }
    }

    /// The audio filter(s) to apply during playback in preview mode,
    /// immediately before the [`audio-sink`][struct@crate::Pipeline#audio-sink]. This exposes the
    /// `playsink:audio-filter` property of the internal `playsink`.
    #[doc(alias = "audio-filter")]
    fn audio_filter(&self) -> Option<gst::Element> {
        ObjectExt::property(self.as_ref(), "audio-filter")
    }

    /// The audio filter(s) to apply during playback in preview mode,
    /// immediately before the [`audio-sink`][struct@crate::Pipeline#audio-sink]. This exposes the
    /// `playsink:audio-filter` property of the internal `playsink`.
    #[doc(alias = "audio-filter")]
    fn set_audio_filter<P: IsA<gst::Element>>(&self, audio_filter: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "audio-filter", audio_filter)
    }

    /// The audio sink used for preview. This exposes the
    /// `playsink:audio-sink` property of the internal `playsink`.
    #[doc(alias = "audio-sink")]
    fn audio_sink(&self) -> Option<gst::Element> {
        ObjectExt::property(self.as_ref(), "audio-sink")
    }

    /// The audio sink used for preview. This exposes the
    /// `playsink:audio-sink` property of the internal `playsink`.
    #[doc(alias = "audio-sink")]
    fn set_audio_sink<P: IsA<gst::Element>>(&self, audio_sink: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "audio-sink", audio_sink)
    }

    /// The timeline used by this pipeline, whose content it will play and
    /// render, or [`None`] if the pipeline does not yet have a timeline.
    ///
    /// Note that after you set the timeline for the first time, subsequent
    /// calls to change the timeline will fail.
    fn timeline(&self) -> Option<Timeline> {
        ObjectExt::property(self.as_ref(), "timeline")
    }

    /// The video filter(s) to apply during playback in preview mode,
    /// immediately before the [`video-sink`][struct@crate::Pipeline#video-sink]. This exposes the
    /// `playsink:video-filter` property of the internal `playsink`.
    #[doc(alias = "video-filter")]
    fn video_filter(&self) -> Option<gst::Element> {
        ObjectExt::property(self.as_ref(), "video-filter")
    }

    /// The video filter(s) to apply during playback in preview mode,
    /// immediately before the [`video-sink`][struct@crate::Pipeline#video-sink]. This exposes the
    /// `playsink:video-filter` property of the internal `playsink`.
    #[doc(alias = "video-filter")]
    fn set_video_filter<P: IsA<gst::Element>>(&self, video_filter: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "video-filter", video_filter)
    }

    /// The video sink used for preview. This exposes the
    /// `playsink:video-sink` property of the internal `playsink`.
    #[doc(alias = "video-sink")]
    fn video_sink(&self) -> Option<gst::Element> {
        ObjectExt::property(self.as_ref(), "video-sink")
    }

    /// The video sink used for preview. This exposes the
    /// `playsink:video-sink` property of the internal `playsink`.
    #[doc(alias = "video-sink")]
    fn set_video_sink<P: IsA<gst::Element>>(&self, video_sink: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "video-sink", video_sink)
    }

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

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

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

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

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

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

impl<O: IsA<Pipeline>> GESPipelineExt for O {}