gstreamer: Add accessors for PadProbeDatas on PadProbeInfo

And make use of it in examples and other code.

This allows to simplify usage a bit in most cases.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1324>

examples/src/bin/custom_events.rs

@@ -75,12 +75,18 @@ fn example_main() {
     // Add a pad probe on the sink pad and catch the custom event we sent, then send
     // an EOS event on the pipeline.
     sinkpad.add_probe(gst::PadProbeType::EVENT_DOWNSTREAM, move |_, probe_info| {
-        match probe_info.data {
-            Some(gst::PadProbeData::Event(ref ev))
-                if ev.type_() == gst::EventType::CustomDownstream =>
-            {
-                if let Some(custom_event) = ExampleCustomEvent::parse(ev) {
-                    if let Some(pipeline) = pipeline_weak.upgrade() {
+        let Some(event) = probe_info.event() else {
+            return gst::PadProbeReturn::Ok;
+        };
+
+        let Some(custom_event) = ExampleCustomEvent::parse(event) else {
+            return gst::PadProbeReturn::Ok;
+        };
+
+        let Some(pipeline) = pipeline_weak.upgrade() else {
+            return gst::PadProbeReturn::Ok;
+        };
+
         if custom_event.send_eos {
             /* Send EOS event to shut down the pipeline, but from an async callback, as we're
              * in a pad probe blocking the stream thread here... */
@@ -95,11 +101,7 @@ fn example_main() {
         } else {
             println!("Got custom event, with send_eos=false. Ignoring");
         }
-                    }
-                }
-            }
-            _ => (),
-        }
+
         gst::PadProbeReturn::Ok
     });
 

examples/src/bin/d3d11videosink.rs

@@ -305,7 +305,6 @@ fn main() -> Result<()> {
     let sinkpad = videosink.static_pad("sink").unwrap();
     let overlay_context_weak = Arc::downgrade(&overlay_context);
     sinkpad.add_probe(gst::PadProbeType::BUFFER, move |_, probe_info| {
-        if let Some(gst::PadProbeData::Buffer(_)) = probe_info.data {
         let overlay_context = overlay_context_weak.upgrade().unwrap();
         let mut context = overlay_context.lock().unwrap();
         context.timestamp_queue.push_back(SystemTime::now());
@@ -317,7 +316,7 @@ fn main() -> Result<()> {
             context.avg_fps = 1000f32 * (context.timestamp_queue.len() - 1) as f32 / duration;
             context.timestamp_queue.clear();
         }
-        }
+
         gst::PadProbeReturn::Ok
     });
 

examples/src/bin/pad_probes.rs

@@ -38,7 +38,10 @@ fn example_main() {
     // This handler gets called for every buffer that passes the pad we probe.
     src_pad.add_probe(gst::PadProbeType::BUFFER, |_, probe_info| {
         // Interpret the data sent over the pad as one buffer
-        if let Some(gst::PadProbeData::Buffer(ref buffer)) = probe_info.data {
+        let Some(buffer) = probe_info.buffer() else {
+            return gst::PadProbeReturn::Ok;
+        };
+
         // At this point, buffer is only a reference to an existing memory region somewhere.
         // When we want to access its content, we have to map it while requesting the required
         // mode of access (read, read/write).
@@ -67,7 +70,6 @@ fn example_main() {
             .sum();
         let rms = (sum / (samples.len() as f64)).sqrt();
         println!("rms: {rms}");
-        }
 
         gst::PadProbeReturn::Ok
     });

examples/src/bin/zoom.rs

@@ -96,7 +96,7 @@ fn example_main() {
     mixer_src_pad.add_probe(gst::PadProbeType::EVENT_UPSTREAM, move |_, probe_info| {
         let mixer_sink_pad = mixer_sink_pad_weak.upgrade().unwrap();
 
-        let Some(gst::PadProbeData::Event(ref ev)) = probe_info.data else {
+        let Some(ev) = probe_info.event() else {
             return gst::PadProbeReturn::Ok;
         };
 

gstreamer-utils/src/streamproducer.rs

@@ -196,11 +196,13 @@ impl StreamProducer {
             .add_probe(
                 gst::PadProbeType::EVENT_UPSTREAM,
                 glib::clone!(@weak appsink, @weak consumer => @default-panic, move |_pad, info| {
-                    if let Some(gst::PadProbeData::Event(ref ev)) = info.data {
-                        if gst_video::UpstreamForceKeyUnitEvent::parse(ev).is_ok() {
+                    let Some(event) = info.event() else {
+                        return gst::PadProbeReturn::Ok;
+                    };
+
+                    if gst_video::UpstreamForceKeyUnitEvent::parse(event).is_ok() {
                         gst::debug!(CAT, obj: &appsink,  "Requesting keyframe");
-                            let _ = appsink.send_event(ev.clone());
-                        }
+                        let _ = appsink.send_event(event.clone());
                     }
 
                     gst::PadProbeReturn::Ok
@@ -486,14 +488,18 @@ impl<'a> From<&'a gst_app::AppSink> for StreamProducer {
         sinkpad.add_probe(
             gst::PadProbeType::EVENT_UPSTREAM,
             glib::clone!(@strong consumers => move |_pad, info| {
-                if let Some(gst::PadProbeData::Event(ref ev)) = info.data {
-                    if let gst::EventView::Latency(ev) = ev.view() {
-                        let latency = ev.latency();
+                let Some(event) = info.event() else {
+                    return gst::PadProbeReturn::Ok;
+                };
+
+                let gst::EventView::Latency(event) = event.view() else {
+                    return gst::PadProbeReturn::Ok;
+                };
+
+                let latency = event.latency();
                 let mut consumers = consumers.lock().unwrap();
                 consumers.current_latency = Some(latency);
-                        consumers.latency_updated = true;
-                    }
-                }
+
                 gst::PadProbeReturn::Ok
             }),
         );

gstreamer/src/pad.rs

@@ -56,6 +56,64 @@ pub struct PadProbeInfo<'a> {
     pub flow_res: Result<FlowSuccess, FlowError>,
 }
 
+impl<'a> PadProbeInfo<'a> {
+    pub fn buffer(&self) -> Option<&Buffer> {
+        match self.data {
+            Some(PadProbeData::Buffer(ref buffer)) => Some(buffer),
+            _ => None,
+        }
+    }
+
+    pub fn buffer_mut(&mut self) -> Option<&mut Buffer> {
+        match self.data {
+            Some(PadProbeData::Buffer(ref mut buffer)) => Some(buffer),
+            _ => None,
+        }
+    }
+
+    pub fn buffer_list(&self) -> Option<&BufferList> {
+        match self.data {
+            Some(PadProbeData::BufferList(ref buffer_list)) => Some(buffer_list),
+            _ => None,
+        }
+    }
+
+    pub fn buffer_list_mut(&mut self) -> Option<&mut BufferList> {
+        match self.data {
+            Some(PadProbeData::BufferList(ref mut buffer_list)) => Some(buffer_list),
+            _ => None,
+        }
+    }
+
+    pub fn query(&self) -> Option<&QueryRef> {
+        match self.data {
+            Some(PadProbeData::Query(ref query)) => Some(*query),
+            _ => None,
+        }
+    }
+
+    pub fn query_mut(&mut self) -> Option<&mut QueryRef> {
+        match self.data {
+            Some(PadProbeData::Query(ref mut query)) => Some(*query),
+            _ => None,
+        }
+    }
+
+    pub fn event(&self) -> Option<&Event> {
+        match self.data {
+            Some(PadProbeData::Event(ref event)) => Some(event),
+            _ => None,
+        }
+    }
+
+    pub fn event_mut(&mut self) -> Option<&mut Event> {
+        match self.data {
+            Some(PadProbeData::Event(ref mut event)) => Some(event),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum PadProbeData<'a> {
     Buffer(Buffer),