feat: Get iced-video working

gst/src/plugins/app/appsink.rs

@@ -1,7 +1,9 @@
 use crate::priv_prelude::*;
 
+#[doc(inline)]
+pub use gstreamer_app::AppSinkCallbacks;
+
 wrap_gst!(AppSink, gstreamer::Element);
-parent_child!(Pipeline, AppSink, downcast); // since AppSink is an Element internaly 
 parent_child!(Element, AppSink);
 
 impl Sink for AppSink {}
@@ -12,6 +14,7 @@ impl AppSink {
             .downcast_ref::<gstreamer_app::AppSink>()
             .expect("Failed to downcast to AppSink")
     }
+
     pub fn new(name: impl AsRef<str>) -> Result<Self> {
         use gstreamer::prelude::*;
         let inner = gstreamer::ElementFactory::make("appsink")
@@ -22,14 +25,47 @@ impl AppSink {
         Ok(AppSink { inner })
     }
 
-    pub fn with_caps(mut self, caps: Caps) -> Self {
+    pub fn with_emit_signals(self, emit: bool) -> Self {
+        self.inner.set_property("emit-signals", emit);
+        self
+    }
+
+    pub fn with_async(self, async_: bool) -> Self {
+        self.inner.set_property("async", async_);
+        self
+    }
+
+    pub fn with_sync(self, sync: bool) -> Self {
+        self.inner.set_property("sync", sync);
+        self
+    }
+
+    pub fn with_caps(self, caps: Caps) -> Self {
         self.inner.set_property("caps", caps.inner);
         self
     }
 
-    pub fn set_callbacks(&self, callbacks: gstreamer_app::AppSinkCallbacks) -> Result<()> {
+    pub fn with_callbacks(self, callbacks: gstreamer_app::AppSinkCallbacks) -> Self {
         self.appsink().set_callbacks(callbacks);
-        Ok(())
+        self
+    }
+
+    pub fn on_new_frame<F>(self, mut f: F) -> Self
+    where
+        F: FnMut(&AppSink) -> Result<(), gstreamer::FlowError> + Send + 'static,
+    {
+        self.with_emit_signals(true).with_callbacks(
+            AppSinkCallbacks::builder()
+                .new_sample(move |appsink| {
+                    use glib::object::Cast;
+                    let element = appsink.upcast_ref::<gstreamer::Element>();
+                    let appsink = AppSink::from_gst_ref(element);
+                    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(appsink)))
+                        .unwrap_or(Err(gstreamer::FlowError::Error))
+                        .map(|_| gstreamer::FlowSuccess::Ok)
+                })
+                .build(),
+        )
     }
 
     pub fn pull_sample(&self) -> Result<Sample> {
@@ -151,3 +187,49 @@ fn test_appsink() {
     }
     // std::thread::sleep(std::time::Duration::from_secs(5));
 }
+
+#[test]
+fn test_appsink_metadata() {
+    use tracing_subscriber::prelude::*;
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::fmt::layer()
+                .with_thread_ids(true)
+                .with_file(true),
+        )
+        .init();
+
+    crate::Gst::new();
+
+    let url = "https://jellyfin.tsuba.darksailor.dev/Items/6010382cf25273e624d305907010d773/Download?api_key=036c140222464878862231ef66a2bc9c";
+
+    let videoconvert = crate::plugins::videoconvertscale::VideoConvert::new("iced-video-convert")
+        // .unwrap();
+        // .with_output_format(gst::plugins::videoconvertscale::VideoFormat::Rgba)
+        .unwrap();
+    let appsink = crate::plugins::app::AppSink::new("iced-video-sink")
+        .unwrap()
+        .with_async(true)
+        .with_sync(true);
+
+    let video_sink = videoconvert.link(&appsink).unwrap();
+    let playbin = crate::plugins::playback::Playbin3::new("iced-video")
+        .unwrap()
+        .with_uri(url)
+        .with_video_sink(&video_sink);
+
+    playbin.pause().unwrap();
+
+    smol::block_on(async {
+        playbin.wait_for(gstreamer::State::Paused).await.unwrap();
+    });
+    // std::thread::sleep(core::time::Duration::from_secs(1));
+    let pad = appsink.pad("sink").unwrap();
+    let caps = pad.current_caps().unwrap();
+    let format = caps.format();
+    let height = caps.height();
+    let width = caps.width();
+    let framerate = caps.framerate();
+    dbg!(&format, height, width, framerate);
+    dbg!(&caps);
+}