fmp4mux: Add test for muxing of multiple streams

generic/fmp4/tests/tests.rs

@@ -189,3 +189,198 @@ fn test_buffer_flags_single_stream_iso() {
 
     test_buffer_flags_single_stream(false);
 }
+
+#[test]
+fn test_buffer_flags_multi_stream() {
+    init();
+
+    let mut h1 = gst_check::Harness::with_padnames("isofmp4mux", Some("sink_0"), Some("src"));
+    let mut h2 = gst_check::Harness::with_element(&h1.element().unwrap(), Some("sink_1"), None);
+
+    // 5s fragment duration
+    h1.element()
+        .unwrap()
+        .set_property("fragment-duration", gst::ClockTime::from_seconds(5));
+
+    h1.set_src_caps(
+        gst::Caps::builder("video/x-h264")
+            .field("width", 1920i32)
+            .field("height", 1080i32)
+            .field("framerate", gst::Fraction::new(30, 1))
+            .field("stream-format", "avc")
+            .field("alignment", "au")
+            .field("codec_data", gst::Buffer::with_size(1).unwrap())
+            .build(),
+    );
+    h1.play();
+
+    h2.set_src_caps(
+        gst::Caps::builder("audio/mpeg")
+            .field("mpegversion", 4i32)
+            .field("channels", 1i32)
+            .field("rate", 44100i32)
+            .field("stream-format", "raw")
+            .field("base-profile", "lc")
+            .field("profile", "lc")
+            .field("level", "2")
+            .field(
+                "codec_data",
+                gst::Buffer::from_slice([0x12, 0x08, 0x56, 0xe5, 0x00]),
+            )
+            .build(),
+    );
+    h2.play();
+
+    let output_offset = gst::ClockTime::from_seconds(60 * 60 * 1000);
+
+    // Push 7 buffers of 1s each, 1st and last buffer without DELTA_UNIT flag
+    for i in 0..7 {
+        let mut buffer = gst::Buffer::with_size(1).unwrap();
+        {
+            let buffer = buffer.get_mut().unwrap();
+            buffer.set_pts(gst::ClockTime::from_seconds(i));
+            buffer.set_dts(gst::ClockTime::from_seconds(i));
+            buffer.set_duration(gst::ClockTime::SECOND);
+            if i != 0 && i != 5 {
+                buffer.set_flags(gst::BufferFlags::DELTA_UNIT);
+            }
+        }
+        assert_eq!(h1.push(buffer), Ok(gst::FlowSuccess::Ok));
+
+        let mut buffer = gst::Buffer::with_size(1).unwrap();
+        {
+            let buffer = buffer.get_mut().unwrap();
+            buffer.set_pts(gst::ClockTime::from_seconds(i));
+            buffer.set_dts(gst::ClockTime::from_seconds(i));
+            buffer.set_duration(gst::ClockTime::SECOND);
+        }
+        assert_eq!(h2.push(buffer), Ok(gst::FlowSuccess::Ok));
+
+        if i == 2 {
+            let ev = loop {
+                let ev = h1.pull_upstream_event().unwrap();
+                if ev.type_() != gst::EventType::Reconfigure
+                    && ev.type_() != gst::EventType::Latency
+                {
+                    break ev;
+                }
+            };
+
+            assert_eq!(ev.type_(), gst::EventType::CustomUpstream);
+            assert_eq!(
+                gst_video::UpstreamForceKeyUnitEvent::parse(&ev).unwrap(),
+                gst_video::UpstreamForceKeyUnitEvent {
+                    running_time: Some(gst::ClockTime::from_seconds(5)),
+                    all_headers: true,
+                    count: 0
+                }
+            );
+        }
+    }
+
+    let header = h1.pull().unwrap();
+    assert_eq!(
+        header.flags(),
+        gst::BufferFlags::HEADER | gst::BufferFlags::DISCONT
+    );
+    assert_eq!(header.pts(), Some(gst::ClockTime::ZERO + output_offset));
+    assert_eq!(header.dts(), Some(gst::ClockTime::ZERO + output_offset));
+
+    let fragment_header = h1.pull().unwrap();
+    assert_eq!(fragment_header.flags(), gst::BufferFlags::HEADER);
+    assert_eq!(
+        fragment_header.pts(),
+        Some(gst::ClockTime::ZERO + output_offset)
+    );
+    assert_eq!(
+        fragment_header.dts(),
+        Some(gst::ClockTime::ZERO + output_offset)
+    );
+    assert_eq!(
+        fragment_header.duration(),
+        Some(gst::ClockTime::from_seconds(5))
+    );
+
+    for i in 0..5 {
+        for j in 0..2 {
+            let buffer = h1.pull().unwrap();
+            if i == 4 && j == 1 {
+                assert_eq!(
+                    buffer.flags(),
+                    gst::BufferFlags::DELTA_UNIT | gst::BufferFlags::MARKER
+                );
+            } else {
+                assert_eq!(buffer.flags(), gst::BufferFlags::DELTA_UNIT);
+            }
+
+            assert_eq!(
+                buffer.pts(),
+                Some(gst::ClockTime::from_seconds(i) + output_offset)
+            );
+
+            if j == 0 {
+                assert_eq!(
+                    buffer.dts(),
+                    Some(gst::ClockTime::from_seconds(i) + output_offset)
+                );
+            } else {
+                assert!(buffer.dts().is_none());
+            }
+            assert_eq!(buffer.duration(), Some(gst::ClockTime::SECOND));
+        }
+    }
+
+    h1.push_event(gst::event::Eos::new());
+    h2.push_event(gst::event::Eos::new());
+
+    let fragment_header = h1.pull().unwrap();
+    assert_eq!(fragment_header.flags(), gst::BufferFlags::HEADER);
+    assert_eq!(
+        fragment_header.pts(),
+        Some(gst::ClockTime::from_seconds(5) + output_offset)
+    );
+    assert_eq!(
+        fragment_header.dts(),
+        Some(gst::ClockTime::from_seconds(5) + output_offset)
+    );
+    assert_eq!(
+        fragment_header.duration(),
+        Some(gst::ClockTime::from_seconds(2))
+    );
+
+    for i in 5..7 {
+        for j in 0..2 {
+            let buffer = h1.pull().unwrap();
+            if i == 6 && j == 1 {
+                assert_eq!(
+                    buffer.flags(),
+                    gst::BufferFlags::DELTA_UNIT | gst::BufferFlags::MARKER
+                );
+            } else {
+                assert_eq!(buffer.flags(), gst::BufferFlags::DELTA_UNIT);
+            }
+            assert_eq!(
+                buffer.pts(),
+                Some(gst::ClockTime::from_seconds(i) + output_offset)
+            );
+            if j == 0 {
+                assert_eq!(
+                    buffer.dts(),
+                    Some(gst::ClockTime::from_seconds(i) + output_offset)
+                );
+            } else {
+                assert!(buffer.dts().is_none());
+            }
+            assert_eq!(buffer.duration(), Some(gst::ClockTime::SECOND));
+        }
+    }
+
+    let ev = h1.pull_event().unwrap();
+    assert_eq!(ev.type_(), gst::EventType::StreamStart);
+    let ev = h1.pull_event().unwrap();
+    assert_eq!(ev.type_(), gst::EventType::Caps);
+    let ev = h1.pull_event().unwrap();
+    assert_eq!(ev.type_(), gst::EventType::Segment);
+    let ev = h1.pull_event().unwrap();
+    assert_eq!(ev.type_(), gst::EventType::Eos);
+}