feat(gst): enhance GStreamer integration with new modules and improved API

This commit introduces significant enhancements to the GStreamer integration by:
- Adding new modules for bins, caps, elements, pads, and plugins
- Implementing a more ergonomic API with helper methods like play(), pause(), ready()
- Adding support for various GStreamer plugins including app, autodetect, playback, and videoconvertscale
- Improving error handling with better context attachment
- Updating dependencies to latest versions including gstreamer-video 0.24.4
- Refactoring existing code to use modern Rust patterns and features

gst/src/plugins/app/appsink.rs

@@ -0,0 +1,108 @@
+use crate::*;
+
+pub struct AppSink {
+    inner: gstreamer::Element,
+}
+
+impl IsElement for AppSink {
+    fn as_element(&self) -> &Element {
+        unsafe { core::mem::transmute(&self.inner) }
+    }
+
+    fn into_element(self) -> Element {
+        Element { inner: self.inner }
+    }
+}
+
+impl Sink for AppSink {}
+
+impl AppSink {
+    fn appsink(&self) -> &gstreamer_app::AppSink {
+        self.inner
+            .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")
+            .name(name.as_ref())
+            .build()
+            .change_context(Error)
+            .attach("Failed to create appsink element")?;
+        Ok(AppSink { inner })
+    }
+
+    pub fn with_caps(mut self, caps: &gstreamer::Caps) -> Self {
+        use gstreamer::prelude::*;
+        // self.inner.set_caps(Some(caps));
+        self
+    }
+
+    pub fn set_callbacks(&self, callbacks: gstreamer_app::AppSinkCallbacks) -> Result<()> {
+        self.appsink().set_callbacks(callbacks);
+        Ok(())
+    }
+
+    pub fn pull_sample(&self, timeout: impl Into<Option<core::time::Duration>>) -> Result<Sample> {
+        use gstreamer::prelude::*;
+        self.appsink()
+            .pull_sample()
+            .change_context(Error)
+            .attach("Failed to pull sample from AppSink")
+            .map(Sample::from)
+    }
+    pub fn try_pull_sample(
+        &self,
+        timeout: impl Into<Option<core::time::Duration>>,
+    ) -> Result<Option<Sample>> {
+        use gstreamer::prelude::*;
+        Ok(self
+            .appsink()
+            .try_pull_sample(duration_to_clocktime(timeout)?)
+            .map(From::from))
+    }
+
+    pub fn pull_preroll(&self, timeout: impl Into<Option<core::time::Duration>>) -> Result<Sample> {
+        use gstreamer::prelude::*;
+        self.appsink()
+            .pull_preroll()
+            .change_context(Error)
+            .attach("Failed to pull preroll sample from AppSink")
+            .map(Sample::from)
+    }
+
+    pub fn try_pull_preroll(
+        &self,
+        timeout: impl Into<Option<core::time::Duration>>,
+    ) -> Result<Option<Sample>> {
+        use gstreamer::prelude::*;
+        Ok(self
+            .appsink()
+            .try_pull_preroll(duration_to_clocktime(timeout)?)
+            .map(From::from))
+    }
+}
+
+fn duration_to_clocktime(
+    timeout: impl Into<Option<core::time::Duration>>,
+) -> Result<Option<gstreamer::ClockTime>> {
+    match timeout.into() {
+        Some(dur) => {
+            let clocktime = gstreamer::ClockTime::try_from(dur)
+                .change_context(Error)
+                .attach("Failed to convert duration to ClockTime")?;
+            Ok(Some(clocktime))
+        }
+        None => Ok(None),
+    }
+}
+
+pub struct Sample {
+    inner: gstreamer::Sample,
+}
+
+impl From<gstreamer::Sample> for Sample {
+    fn from(inner: gstreamer::Sample) -> Self {
+        Sample { inner }
+    }
+}