fix: playback of malformed MP4 files with invalid framerates

- [x] I have disclosed use of any AI generated code in my commit
messages.
- If you are using an LLM, and do not fully understand the changes it is
making to the code base, do not create a PR.
- In our experience, AI generated code often results in overly complex
code that lacks enough context for a proper fix or feature inclusion.
This results in considerably longer code reviews. Due to this, AI
authored or partially authored PRs may be closed without comment.
- [x] I understand these changes in full and will be able to respond to
review comments.
- [x] My change is accurately described in the commit message.
- [x] My contribution is tested and working as described.
- [x] I have read the [Developer Certificate of
Origin](https://developercertificate.org/) and certify my contribution
under its conditions.

Some malformed MP4 files previously wouldn't play at all because they
reported a 0/1 framerate.
Other files suffered from severe audio stuttering caused by repeated
long GAP events emitted from malformed edit lists.
This patch treats invalid framerates as unknown (allowing the existing
fallback to be used) and suppresses suspicious long audio GAP events
before they reach the audio sink.
As a result, both kinds of videos now play correctly.

src/video.rs

@@ -4,6 +4,40 @@ use iced_video_player::{Video, gst, gst_app, gst_pbutils};
 use cosmic::action;
 use cosmic::app::Task;
 
+const SUSPICIOUS_AUDIO_GAP_DURATION: gst::ClockTime = gst::ClockTime::SECOND;
+
+fn is_suspicious_audio_gap(duration: Option<gst::ClockTime>) -> bool {
+    duration.is_some_and(|duration| duration >= SUSPICIOUS_AUDIO_GAP_DURATION)
+}
+
+fn suppress_suspicious_audio_gaps(audio_filter: &gst::Element) {
+    let Some(src_pad) = audio_filter.static_pad("src") else {
+        log::warn!("audio filter has no source pad; malformed audio gaps will not be suppressed");
+        return;
+    };
+
+    let _ = src_pad.add_probe(gst::PadProbeType::EVENT_DOWNSTREAM, |_, info| {
+        let Some(event) = info.event() else {
+            return gst::PadProbeReturn::Ok;
+        };
+        let gst::EventView::Gap(gap) = event.view() else {
+            return gst::PadProbeReturn::Ok;
+        };
+        let (timestamp, duration) = gap.get();
+        if !is_suspicious_audio_gap(duration) {
+            return gst::PadProbeReturn::Ok;
+        }
+
+        // Some malformed MP4 edit lists cause streamsynchronizer to emit a
+        // long GAP before almost every audio buffer. The next buffer's PTS is
+        // still continuous, so forwarding those events makes audio sinks
+        // repeatedly wait or resynchronise and produces choppy playback.
+        log::debug!("suppressing audio GAP at {timestamp} with duration {duration:?}");
+        drop(info.take_event());
+        gst::PadProbeReturn::Handled
+    });
+}
+
 #[derive(Debug, Default)]
 pub struct VideoSettings {
     pub mute: bool,
@@ -27,11 +61,14 @@ pub fn new_video(
         .downcast::<gst::Pipeline>()
         .map_err(|_| iced_video_player::Error::Cast)
         .unwrap();
-    if let Ok(scaletempo) = gst::ElementFactory::make("scaletempo").build() {
-        pipeline.set_property("audio-filter", &scaletempo);
-    } else {
-        log::warn!("scaletempo element not available; speed changes will affect pitch");
-    }
+    let audio_filter = gst::ElementFactory::make("scaletempo")
+        .build()
+        .unwrap_or_else(|_| {
+            log::warn!("scaletempo element not available; speed changes will affect pitch");
+            gst::ElementFactory::make("identity").build().unwrap()
+        });
+    suppress_suspicious_audio_gaps(&audio_filter);
+    pipeline.set_property("audio-filter", &audio_filter);
     pipeline.connect("element-setup", false, |vals| {
         let Ok(elem) = vals[1].get::<gst::Element>() else {
             return None;
@@ -84,3 +121,25 @@ pub fn new_video(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::is_suspicious_audio_gap;
+    use iced_video_player::gst;
+
+    #[test]
+    fn long_audio_gap_is_suspicious() {
+        assert!(is_suspicious_audio_gap(Some(gst::ClockTime::SECOND)));
+        assert!(is_suspicious_audio_gap(Some(
+            gst::ClockTime::from_seconds(3)
+        )));
+    }
+
+    #[test]
+    fn short_or_unknown_audio_gap_is_preserved() {
+        assert!(!is_suspicious_audio_gap(Some(
+            gst::ClockTime::from_mseconds(999)
+        )));
+        assert!(!is_suspicious_audio_gap(None));
+    }
+}