From eb494599378cbb6d133b11748527402f59a97982 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tim-Philipp=20M=C3=BCller?= <tim@centricular.com>
Date: Sun, 10 Mar 2024 13:01:52 +0000
Subject: [PATCH] rtp: m2pt: add some unit tests

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/1493>
---
 net/rtp/src/mp2t/mod.rs                       |   4 +
 net/rtp/src/mp2t/tests/mod.rs                 |   3 +
 net/rtp/src/mp2t/tests/tests.rs               | 640 ++++++++++++++++++
 .../mp2t/tests/videotestsrc-80x60-h264.m2ts   | Bin 0 -> 3648 bytes
 .../src/mp2t/tests/videotestsrc-80x60-h264.ts | Bin 0 -> 4324 bytes
 5 files changed, 647 insertions(+)
 create mode 100644 net/rtp/src/mp2t/tests/mod.rs
 create mode 100644 net/rtp/src/mp2t/tests/tests.rs
 create mode 100644 net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.m2ts
 create mode 100644 net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.ts

diff --git a/net/rtp/src/mp2t/mod.rs b/net/rtp/src/mp2t/mod.rs
index 7ec136ac..493e2b1e 100644
--- a/net/rtp/src/mp2t/mod.rs
+++ b/net/rtp/src/mp2t/mod.rs
@@ -2,3 +2,7 @@
 
 pub mod depay;
 pub mod pay;
+
+#[allow(clippy::module_inception)]
+#[cfg(test)]
+mod tests;
diff --git a/net/rtp/src/mp2t/tests/mod.rs b/net/rtp/src/mp2t/tests/mod.rs
new file mode 100644
index 00000000..a79d7e29
--- /dev/null
+++ b/net/rtp/src/mp2t/tests/mod.rs
@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MPL-2.0
+
+mod tests;
diff --git a/net/rtp/src/mp2t/tests/tests.rs b/net/rtp/src/mp2t/tests/tests.rs
new file mode 100644
index 00000000..b6282dd5
--- /dev/null
+++ b/net/rtp/src/mp2t/tests/tests.rs
@@ -0,0 +1,640 @@
+// GStreamer RTP MPEG-TS Payloader / Depayloader - unit tests
+//
+// Copyright (C) 2023-2024 Tim-Philipp Müller <tim centricular com>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at
+// <https://mozilla.org/MPL/2.0/>.
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use crate::tests::{run_test_pipeline, ExpectedBuffer, ExpectedPacket, Source};
+
+fn init() {
+    use std::sync::Once;
+    static INIT: Once = Once::new();
+
+    INIT.call_once(|| {
+        gst::init().unwrap();
+        crate::plugin_register_static().expect("rtpmp2t test");
+    });
+}
+
+// gst-launch-1.0 videotestsrc num-buffers=3 \
+//  ! video/x-raw,format=I420,width=80,height=60,framerate=25/1 \
+//  ! x264enc tune=zerolatency \
+//  ! mpegtsmux \
+//  ! filesink location=videotestsrc-80x60-h264.ts
+//
+// - 15 packets with timestamp  0ms
+// -  4 packets with timestamp 40ms
+// -  4 packets with timestamp 80ms
+//
+const MPEGTS_DATA: &[u8] = include_bytes!("videotestsrc-80x60-h264.ts").as_slice();
+
+// PACKET_SIZE = 188
+fn make_mp2t_buffer(
+    packet_number: usize,
+    n_packets: usize,
+    pts: gst::ClockTime,
+    flags: gst::BufferFlags,
+) -> gst::Buffer {
+    const PACKET_SIZE: usize = 188;
+
+    let mut ts_packet = MPEGTS_DATA[(packet_number * PACKET_SIZE)..].to_vec();
+
+    assert!(ts_packet.starts_with(&[0x47]));
+
+    ts_packet.truncate(n_packets * PACKET_SIZE);
+
+    // Add filler packets if needed
+    while ts_packet.len() < (n_packets * PACKET_SIZE) {
+        ts_packet.extend_from_slice(&[0x47, 0x1f, 0xff, 0x10]);
+
+        while ts_packet.len() % PACKET_SIZE != 0 {
+            ts_packet.extend_from_slice(&[0, 0, 0, 0]);
+        }
+    }
+
+    let mut buf = gst::Buffer::from_mut_slice(ts_packet);
+
+    if let Some(buf_ref) = buf.get_mut() {
+        buf_ref.set_pts(pts);
+        buf_ref.set_flags(flags);
+    }
+
+    buf
+}
+
+#[test]
+fn test_mp2t_pay_depay_single_ts_packets() {
+    init();
+
+    // mpegtsmux would first push these caps and then update with a streamheader
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 188i32)
+        .build();
+
+    let mut input_buffers = Vec::with_capacity(24);
+
+    // No DISCONT flag on first buffer for some reason..
+    // - 15 packets with timestamp  0ms
+    // -  4 packets with timestamp 40ms
+    // -  4 packets with timestamp 80ms
+    for i in 0..23 {
+        input_buffers.push(make_mp2t_buffer(
+            0,
+            1,
+            match i {
+                0..=14 => gst::ClockTime::ZERO,
+                15..=18 => gst::ClockTime::from_mseconds(40),
+                19..=23 => gst::ClockTime::from_mseconds(80),
+                _ => unreachable!(),
+            },
+            if i == 0 {
+                gst::BufferFlags::empty()
+            } else {
+                gst::BufferFlags::DELTA_UNIT
+            },
+        ));
+    }
+
+    let expected_pay = vec![
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(true)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(7200) // 80ms, 0.080 * 90000
+            .marker_bit(false)
+            .build()],
+    ];
+
+    let expected_depay = vec![
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .size(376)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+    ];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2",
+        "rtpmp2tdepay2",
+        expected_pay,
+        expected_depay,
+    );
+}
+
+#[test]
+fn test_mp2t_pay_depay_7ts_packets() {
+    init();
+
+    // mpegtsmux would first push these caps and then update with a streamheader
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 188i32)
+        .build();
+
+    let input_buffers = vec![
+        // This time we're not feeding single ts packets, but 7 per buffer (like alignment=7)
+        make_mp2t_buffer(0, 7, gst::ClockTime::ZERO, gst::BufferFlags::empty()),
+        make_mp2t_buffer(7, 7, gst::ClockTime::ZERO, gst::BufferFlags::DELTA_UNIT),
+        make_mp2t_buffer(14, 7, gst::ClockTime::ZERO, gst::BufferFlags::DELTA_UNIT),
+        make_mp2t_buffer(
+            21,
+            7,
+            gst::ClockTime::from_mseconds(80),
+            gst::BufferFlags::DELTA_UNIT,
+        ),
+    ];
+
+    let expected_pay = vec![
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(true)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(7200) // 80ms, 0.080 * 90000
+            .marker_bit(false)
+            .build()],
+    ];
+
+    let expected_depay = vec![
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .size(1316) // includes padding packets
+            .flags(gst::BufferFlags::empty())
+            .build()],
+    ];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2",
+        "rtpmp2tdepay2",
+        expected_pay,
+        expected_depay,
+    );
+}
+
+#[test]
+fn test_mp2t_pay_depay_7ts_packets_mtu_split() {
+    init();
+
+    // mpegtsmux would first push these caps and then update with a streamheader
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 188i32)
+        .build();
+
+    let input_buffers = vec![
+        // This time we're not feeding single ts packets, but 7 per buffer (like alignment=7)
+        make_mp2t_buffer(0, 7, gst::ClockTime::ZERO, gst::BufferFlags::empty()),
+    ];
+
+    let expected_pay = vec![vec![
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(true)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+        ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build(),
+    ]];
+
+    let expected_depay = vec![
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(188)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+    ];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2 mtu=300",
+        "rtpmp2tdepay2",
+        expected_pay,
+        expected_depay,
+    );
+}
+
+#[test]
+fn test_mp2t_pay_depay_au_ts_packets() {
+    init();
+
+    // mpegtsmux would first push these caps and then update with a streamheader
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 188i32)
+        .build();
+
+    let input_buffers = vec![
+        // This time we're not feeding single ts packets, but chunk per timestamp/AU
+        make_mp2t_buffer(0, 15, gst::ClockTime::ZERO, gst::BufferFlags::empty()),
+        make_mp2t_buffer(
+            15,
+            4,
+            gst::ClockTime::from_mseconds(40),
+            gst::BufferFlags::DELTA_UNIT,
+        ),
+        make_mp2t_buffer(
+            19,
+            4,
+            gst::ClockTime::from_mseconds(80),
+            gst::BufferFlags::DELTA_UNIT,
+        ),
+    ];
+
+    let expected_pay = vec![
+        // Since the first input buffer contains 15 ts packets, the payloader can push out
+        // two rtp packets of 7 ts packets immediately, with 1 ts packet queued for later.
+        vec![
+            ExpectedPacket::builder()
+                .pts(gst::ClockTime::ZERO)
+                .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+                .pt(33)
+                .rtp_time(0)
+                .marker_bit(true)
+                .build(),
+            ExpectedPacket::builder()
+                .pts(gst::ClockTime::ZERO)
+                .flags(gst::BufferFlags::empty())
+                .pt(33)
+                .rtp_time(0)
+                .marker_bit(false)
+                .build(),
+        ],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(false)
+            .build()],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .rtp_time(7200) // 80ms, 0.080 * 90000
+            .marker_bit(false)
+            .build()],
+    ];
+
+    let expected_depay = vec![
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(1316)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .size(376)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+    ];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2",
+        "rtpmp2tdepay2",
+        expected_pay,
+        expected_depay,
+    );
+}
+
+// gst-launch-1.0 videotestsrc num-buffers=3 is-live=true \
+//  ! video/x-raw,format=I420,width=80,height=60,framerate=25/1 \
+//  ! x264enc tune=zerolatency \
+//  ! mpegtsmux m2ts-mode=true \
+//  ! filesink location=videotestsrc-80x60-h264.m2ts \
+//  && truncate -s 3648 videotestsrc-80x60-h264.m2ts
+//
+// Same as above, just with 192-byte packets, and it seems like we only get 19 ts packets
+const M2TS_DATA: &[u8] = include_bytes!("videotestsrc-80x60-h264.m2ts").as_slice();
+
+#[test]
+fn test_mp2t_pay_depay_m2ts_variant() {
+    init();
+
+    // mpegtsmux would first push these caps and then update with a streamheader
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 192i32)
+        .build();
+
+    // Send as single input buffer, we just want to make sure the
+    // depayloader can automatically detect the packet size.
+    let mut input_buf = gst::Buffer::from_slice(M2TS_DATA);
+
+    if let Some(buf_ref) = input_buf.get_mut() {
+        buf_ref.set_pts(gst::ClockTime::ZERO);
+        buf_ref.set_flags(gst::BufferFlags::empty());
+    }
+
+    let input_buffers = vec![input_buf];
+
+    let expected_pay = vec![
+        // Since the first input buffer contains 21 ts packets, the payloader can push out
+        // 3 rtp packets immediately, with 2 ts packets queued for later.
+        vec![
+            ExpectedPacket::builder()
+                .pts(gst::ClockTime::ZERO)
+                .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+                .pt(33)
+                .rtp_time(0)
+                .marker_bit(true)
+                .build(),
+            ExpectedPacket::builder()
+                .pts(gst::ClockTime::ZERO)
+                .flags(gst::BufferFlags::empty())
+                .pt(33)
+                .rtp_time(0)
+                .marker_bit(false)
+                .build(),
+        ],
+        vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::from_mseconds(80))
+            .flags(gst::BufferFlags::empty())
+            .pt(33)
+            .pts(gst::ClockTime::ZERO)
+            .marker_bit(false)
+            .build()],
+    ];
+
+    let expected_depay = vec![
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(7 * 192)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(7 * 192)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+        vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(5 * 192)
+            .flags(gst::BufferFlags::empty())
+            .build()],
+    ];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2",
+        "rtpmp2tdepay2",
+        expected_pay,
+        expected_depay,
+    );
+}
+
+#[test]
+fn test_mp2t_pay_depay_single_packet() {
+    let inputs = [(188u8, MPEGTS_DATA), (192u8, M2TS_DATA)];
+
+    init();
+
+    for (packet_size, data) in inputs {
+        // mpegtsmux would first push these caps and then update with a streamheader
+        let input_caps = gst::Caps::builder("video/mpegts")
+            .field("systemstream", true)
+            .field("packetsize", packet_size as i32)
+            .build();
+
+        let packet_size = packet_size as usize;
+
+        // Send a single TS packet as input buffer, to make sure the
+        // depayloader can still automatically detect the packet size.
+        let mut input_buf = gst::Buffer::from_slice(&data[0..][..packet_size]);
+
+        if let Some(buf_ref) = input_buf.get_mut() {
+            buf_ref.set_pts(gst::ClockTime::ZERO);
+            buf_ref.set_flags(gst::BufferFlags::empty());
+        }
+
+        let input_buffers = vec![input_buf];
+
+        let expected_pay = vec![vec![ExpectedPacket::builder()
+            .pts(gst::ClockTime::ZERO)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+            .pt(33)
+            .rtp_time(0)
+            .marker_bit(true)
+            .build()]];
+
+        let expected_depay = vec![vec![ExpectedBuffer::builder()
+            .pts(gst::ClockTime::ZERO)
+            .size(packet_size)
+            .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+            .build()]];
+
+        run_test_pipeline(
+            Source::Buffers(input_caps, input_buffers),
+            "rtpmp2tpay2",
+            "rtpmp2tdepay2",
+            expected_pay,
+            expected_depay,
+        );
+    }
+}
+
+#[test]
+fn test_mp2t_depay_skip_bytes() {
+    init();
+
+    let input_caps = gst::Caps::builder("video/mpegts")
+        .field("systemstream", true)
+        .field("packetsize", 192i32)
+        .build();
+
+    // Send a single 192-byte TS packet as input buffer, and strip off the first 4 bytes
+    // (extra timestamp), which should yield a normal 188-byte TS packet. Need to send
+    // a single one since skip-first-bytes only applies to the whole payload buffer,
+    // not each individual TS packet, so it wouldn't work right if there were multiple
+    // TS packets (because it's made for stripping off other things, not TS packet prefixes).
+    let mut input_buf = gst::Buffer::from_slice(&M2TS_DATA[0..][..192]);
+
+    if let Some(buf_ref) = input_buf.get_mut() {
+        buf_ref.set_pts(gst::ClockTime::ZERO);
+        buf_ref.set_flags(gst::BufferFlags::empty());
+    }
+
+    let input_buffers = vec![input_buf];
+
+    let expected_pay = vec![vec![ExpectedPacket::builder()
+        .pts(gst::ClockTime::ZERO)
+        .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::MARKER)
+        .pt(33)
+        .rtp_time(0)
+        .marker_bit(true)
+        .build()]];
+
+    let expected_depay = vec![vec![ExpectedBuffer::builder()
+        .pts(gst::ClockTime::ZERO)
+        .size(192 - 4)
+        .flags(gst::BufferFlags::DISCONT | gst::BufferFlags::RESYNC)
+        .build()]];
+
+    run_test_pipeline(
+        Source::Buffers(input_caps, input_buffers),
+        "rtpmp2tpay2",
+        "rtpmp2tdepay2 skip-first-bytes=4",
+        expected_pay,
+        expected_depay,
+    );
+}
diff --git a/net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.m2ts b/net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.m2ts
new file mode 100644
index 0000000000000000000000000000000000000000..bb890badb7c5cc1c4716b36810d4f1a69b499381
GIT binary patch
literal 3648
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

literal 0
HcmV?d00001

diff --git a/net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.ts b/net/rtp/src/mp2t/tests/videotestsrc-80x60-h264.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fcb0e0d406b95d8d2a3933820d39e7c440a1c061
GIT binary patch
literal 4324
zcmdUyc|6qbx4_4UMz#qfLI!R2Ss3eBqOZMdAwn}_Fc~w`%w$W*5@j1(itMs{r3G0E
zWlgfTSR%6fDw4<&exIq=y}x_!ANTKj=Z`bzoaa2}yg%nTug^SVVgN!Gf%g7Cd_bVb
z{2-1d5D3IE0ncxdH#9MTBh&wnvV*{nC4a+C7=8mu0O9}_#MIczVNb$X|Mb`yArk{b
z<bG?O;t$gyzaNN4`Fa?ajFo=n6}HI(WlOIgAb!@che%F3$0a^KzAzAo69foxlUuN(
z>~-(OF5^f8K;h=v+p8Qsz0fc_Y+7?$X$U?nx3nC9!l=QO;RGt32uA`c9gRe2!qG?~
zQp-~dSTI!q0#vQ6Pn#&K!3`aZfJhG_0a!4i(gMjuPbM6NK%kXT2oxG{dNY|cZB<o&
ze}5G}6Of@0$%9BG<0vXrx|b@ul8QIemkh*FX-pE8!qA2jaCjU6i-gmOo>(;8gNP?n
z2|ie)HbNT#$5C+PKn4+u2taEi0+2{F+?R;;CI-M6SMY$Q0jDtnfvtdar+Z+LDhOZ`
zAmF~F0HTLGJ0lX<;ZDa<yogvN22Sv%Q+;vnz*Z!jNhgxYBnF^q255Q^n1DjK?2APJ
z2sn=*D!?vGA!1QTB_tB=iDNL`X$&6{jUDwT$z_^5)zgzfWMb9eOm8}{iJgl~rTXB!
z0mJ>@J_eaY0C4`pfq+x!zsnFvzBncug+yTz>0}%b1o-jfD|B3-JAvv;!!ZGy0Cb5-
z$B`&N3Lub<W5;;XalS+bp!pL?UfxU^76tbq1_H}ilsW<qu#5aL-F-<Ezy)Uzh!i5>
z3c!kBSEJ+D&7l(+-araE!Tmp}f16kWo(}iL0}TQ?566>$Z~zm9P}797H71qJZZ-Te
z8xf08!2l|aUFY{VE&!{E1RM+|kp^_e5AWyhiwpR72DSr##gjn_0-hX&(u4y??CuSm
z9)(IF!aYd<JB&;wvO7eg0VfAc2~Z8d#$5)6f_=p7(dHn=M1rNi{OAy%uln2~FW)9_
zd`j}OI=Ilkx@+b*zU7&4&HU&9LVcf3sa{zPU|&1mrg#7R>AQxZt7p^3Y7~sl^?vL1
zir+gfMp=M7$@|`fib~5eHfJ@s&MumxmA{CNyh#wd$7xn;6o;I79%y;0`sPE@L<IU1
z#(3RZI8{xzRKqQ{!LA9Sg9T5fF=Au8-177RcF{+9*`%(^Cm%x`wB?c|646D47w!s}
zn+baLp=T`&>wDX4NYwVC$n=lyFZRsF_dcKfHS;TbV585${%1o)Z6WWE91HL_vw#Ek
zTWcv|JJVZV{ic&RcHbUNSGv^<pS<`<1thNuHM_a#>oC7I$Mdc3rQiL(FgPf;F;YG1
z!i|P>Etz*)CKD6xh1;_cvh$Opb0d4Bvj+O|qgsQBwn|Q>bQR}FW>IqGQbwJsVevER
z&fs3WfSkQ7z<vnAdnty8|AmcEWKaCtIm`I)ZJlN0JZUqWp>71rfy!E*S$WhhH0yHM
zsk}5p6}Bv8<fILf(O>nsi)#>_tKiBno1Zu@Yiy7`Shnuv*{VI)DNj04%NnWvXZHa2
zaN}auYck~3iF0_J`8lhuR|WJ|fh|ZyZ%7=mJjW#P!*JhT&rYMteV9(TjJm-aaL(ti
zHV5XX|30`9=AHO~_epb>g^5#kSfG2m#Lzf>fCruC=y+0=qUOsDu#4^NSP`0yjb>(Q
zuO3tcPcjc`orR#sveizEyWMxH*wITkBb3)wV8c{!kiO%XE}PUA-fqC>QSK~gX1sGo
zTeQdcFoLi3QvXBUPi@~!AAR+Gd#BwFOW8F$8di$GpK2q+b8mF>i2g;^NO<unWo_2%
z1~q||zqtPs?P*KXdS0hZ@S#XOAL+7NnhwG#KS-_cTGUZc=-GYGFoEsj`#OuOkADjS
zKalzWcK`KEspG;C`J2$qwFcXv4uD;JJ|=(4(V7O<npobHeOPciWH`SqUZc~ntpV<k
zCyRV+@nk^h(W}RS5=XRy4=6{S#3Ik_pGm$aSaQ^Bhp5#ms?%oNj3XS<(+$_o&rxqo
z&ipF1hq!1jy`ge;JWtB>`>~xzHf1sb?>S7t2B~FhHQj=Fp<lJQ70`<uqt^xReo3(S
zG9)bYYv{qq<1Wt<KZ~@OIVa-U%Glz5F9U<?ri&6&@i7ny0jSI+DCZ4f^L)|x(FpaE
z@7V8|!*>ik&(<WED&H^n=kGHSjm>pQ@m~<z1dVm0nf4`yhfxb6@(T2t55AbUr33_Q
zZ`)RdPyUlpQ?+GvO=X1H1@K}aUhKdwzi6jwgX_MGZ1uhG9=w&lxzbC;l{J~P)Ml3I
z_bbbhylD%!SEUP<UEZJRDJ;GE_VCzP;*+a8iqC@I$B|;X--N5zrff%)D+#qg@=|yT
z4!rsDybr_m+PX_i98zi#eja(kCtG6CE&28HoUU3}Z9WcQm-zfGzdzXZL~H<3Z%L0k
zqQh#fq>QsiLCL8d(Et{8!sBPcmNhXtetEA1^j}?af{A*Fj476$Bv?(~dGt?rf2w)d
znx*SRY@`C`dZL}U-4(8VpVzJVjZFh?gC@Baz_O`~qWirE$AS(os*C;_GU?W0xq3He
z>F6!SdE|+uv<k?NqJlV!Seb$GuN3Iwa$Bfq-gUhfV&@oPSeSdt#L~-swiWgIK5H=?
zwE_cO81=CgZR1Gu^S=OgNvzome=Hi>w$vT%Q|Y{Yk1X#fY^6P;5eTEGWa%4aX6r|r
z@gA<bV(4@Jj-;e_Ib+q&7G=BUAJ^Dw;%Z{PF8CZFcvSV+neMF3B7cP>YyRy=iE(LM
zxpE86LE;y>a{n$)hG~~JXjf}{H^y_LW2{O#UO|mMUyG0lKXj18k225_&3W3g{Mq}a
z&iIbjrqyba3$)R0z%%G&`gy$sKQ~DN@7P3Ey31@kW8L=i=^JAgvO<Qu?k554SjqqG
zE><|W#(8{m@t7j`mVJReS@EOH+sXR#U$;+{;Oa_JYYV5_xma&MMSB_^!QIJyAdi&W
zH~aAtn(yU};mWGYy!_A<cUg^)CXA|GO!UMHdN!TkEu)kJ##hFZkvn{UxmHBpxpGF(
zPOA`_)giN#VrctFP*3QS1xdf*Ci<hthmX`v^k6xTr80xje^+w|GH|G>r92XUY-<NB
z*$>>sjsU+s6X4f>?qI!X?AsL&0uY87I#8Lt-I3xAVMlx0s23B#WIj~$F#ey9^=m`X
z_6e1}=f9YlINuGs;2US{cH9-~wO1z|;siO^1(QIT<x4>c+Yk6oqzLdHs^AWp>JlRB
zu5a-|*14pzRP%o5s7CdOvjkn{`l*=K<VA;`8+n;tjZd3*3SxJr9`J`}e>h!wCZ2%l
zUfXXpB%jmgk=(seWZyjEdL?0$x5Q#6ewK;^`Yz3=H*4|2Z!U2m{7I5eGpR;L|5opl
zAK<#4n^n05gBCrhPz=>+?shx$yjFiTB6WUzXvu8aa`13lT6p1TghKVjJC18{b;FB`
z=o}}$g;_g|!rP54-)U3ugm}>doHBB?0o49!0i~z4KJPeP!k(9`NUboP>E{wR?22F9
zT^z53xr!OMDbP?)Z`Fh+daqgBs+;O@Hm~)Zm%6!cCU_SFi=TZlMX`d4+ax8d{G|Ux
zD76S5hHx(d?9iP%rn*0;B4kFd;`5bVdzS7#hlz4Vkj4<gzfR4G_0H@UfsVMK1Rm4W
zzqS1xrJ#mUH!!r*t`jU5z3y2pb!a!|y&SkKj29zuw&NV{b#<Mg8)j7%SCUpIorirJ
zIrooUzKI$+T%Pw7n;sgq9YjVdEpLP}T9Aqv33Q*4ldWo1x_v!?wX227Dag}(D_6fc
z9*?<~dVJnf=hRhL_;+52P(r_o*Z8)^Dd~$DxCs&0xnsxA4w@ED0_;fW|D1OMwte=5
z#!l6_j3Y3kfwY44;Hsf(MciEmCL-ilRzY&gZlk!k?dFiLJzbO%m`H@1l4C-h&0hbY
zgT;lnO)ral(_ig{EQKU1K3v|Cp*(V#-d$bop3V@Mn|@bnQEUu>#BLY7&Cn{{?B1}6
zwBGwr(3Fxnjde!n#>Z-5<wuJfkL^D7_#!#6IQG|QQ25G|r3<sGwu471TaN0##Eg-P
zkvKjZ{ib+e-ckFZJjK&L{`~g<xBQv=#i##e?(Lhv(!kuW2cLT{l1JS*^0^sR@JS`E
zvxnnkP(Wgi8q01vUX3GR`w8KuP~>;=>DBVK7%ivVd6lXX4+~brWl-goS)5siir|l%
z<KuFcpP!cycXwj%Ow?<JX}LR`cy}<QxGD-}-F}%UWzm`RN&1=YnVQajGQxr$^9id}
zr+O$18<`E4K@B`S_q6(4)j!^dz3r74RRr{1_`0f6lCazD%%iM5h@!43Ej?}(y<ToS
z>SGPUHFgMHkBIi@Xb4{m;fM;nwD8YV-*Q|QMDm`_Rt4r|p3lZ~yHr_b-Rs0jRL4t$
zuMX(m4Eumi=Ro2<SJ!%5%*Hp=lJ|Td8q3-hjg~-oyYK~UAZ6yDWOXb7*=XHf(rc=G
zjG39$nF@K(l{cq(%%BSW*DIb|Cssn0ZHH5Wx5_afZ^x?OoAnPA87zeZnD3L9VkID_
z-b`8A0_-BuZwhz^i#p`<sf8~-q{$uwk1R2dEE>3+FdAotm}&i5;MS4w)VZurOVk|{
z9h$L;@@#HWn<;Ba*0`7S`t_+Q7Ck4L^J$c>SpAKR-o=4>+SVBtR`G?1CBaAFkjU)r
zFH{}(7nfkAfrm=__aJgNd{-n*n4iV`xCTe_KeUJ86JmJ^t@-z4RC}2gld7xlE#9^r
zhY3fBK9pTaB|*ArbZ-HBQv5qsHAJ}W=TtV2Lz=068+ma9U{@FT@AF>w=2k1hE=vZ~
zP(R$H_-<D!{HM9)26;N5N#Ni$E0a?LXLA)BV3%>4p|34pi+^R^BCc@ACN5<({>qEJ
zgpKdt&aGIL_4io%`msta<o<#qX}6wf?uhT!UdPW;?o@;phlyv=bgFtAMXna|hemxK
zdv=}Hsxfv^BTo0)yN30Ocu>9h;DNZ*gGscwviT(5f$!M?CCRQXRxBqW%kH6Qft1Xv
KH@?3n*!>IL=WR~_

literal 0
HcmV?d00001