rivet-container 0.1.1

//! Per-format streaming-vs-legacy demuxer equality regression tests.
//!
//! For each container (MP4, MKV/WebM, MPEG-TS, AVI), construct via the
//! legacy `demux()` (which materialises the full `Vec<Vec<u8>>`), then
//! construct via `demux_streaming()` (the P1 trait API) and pull
//! `next_video_sample()` until EOF, asserting byte-for-byte equality of
//! the two sample streams.
//!
//! ## Why these tests are gated
//!
//! `demux_streaming()` and the `StreamingDemuxer` trait don't exist on
//! the `squad-streaming-qa` branch in isolation — they land at
//! integration time when the streaming-architect merges P1
//! (`squad-streaming-demuxer`) into this branch. We compile-gate the
//! body behind `--cfg streaming_api_landed` so:
//!
//!   - `cargo test -p container --tests` on this branch alone passes
//!     (the gated tests vanish).
//!   - The post-merge integration run flips the cfg and the regression
//!     guards activate without further wiring.
//!
//! The `_skip_when_streaming_api_absent` shim test runs in BOTH branches
//! (gated and ungated). When the cfg is OFF it logs a SKIP marker so a
//! human looking at the test output sees the gate explicitly. When the
//! cfg is ON it's a no-op next to the real tests.
//!
//! Per the QA design contract section "Coordination notes":
//!   "Use `#[cfg(streaming_api_landed)]` ... OR write the tests
//!    assuming the API exists and accept compile failure on your
//!    branch alone — document which approach in your final report."
//!
//! Picked the cfg-gate route so this branch stays cleanly compiling
//! end-to-end. Documented in the final report.

#[cfg(streaming_api_landed)]
mod gated_tests {
    use container::demux::{self, DemuxResult};
    use std::path::{Path, PathBuf};

    fn test_media_dir() -> PathBuf {
        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .parent()
            .unwrap()
            .parent()
            .unwrap()
            .join("test_media")
    }

    fn read_test_file(name: &str) -> Option<Vec<u8>> {
        std::fs::read(test_media_dir().join(name)).ok()
    }

    /// Walk a `StreamingDemuxer` to EOF, collecting all video sample
    /// payloads. Returns `(codec, samples)` so we can compare against
    /// the legacy DemuxResult byte-for-byte.
    ///
    /// Per the design contract:
    ///   pub trait StreamingDemuxer: Send {
    ///     fn header(&self) -> &DemuxHeader;
    ///     fn next_video_sample(&mut self) -> Result<Option<Sample>>;
    ///     fn audio(&self) -> Option<&AudioTrack>;
    ///   }
    ///   pub struct DemuxHeader { codec: String, info: StreamInfo }
    ///   pub struct Sample { data: Vec<u8>, pts_ticks: i64, duration_ticks: u32 }
    fn drain_streaming(input: &[u8]) -> anyhow::Result<(String, Vec<Vec<u8>>)> {
        let mut sd = demux::demux_streaming(input)?;
        let header = sd.header().clone();
        let mut out = Vec::new();
        while let Some(s) = sd.next_video_sample()? {
            out.push(s.data);
        }
        Ok((header.codec, out))
    }

    /// Byte-equality assertion against the FULL sample stream (not a
    /// truncated prefix). code-auditor flagged this as a risk because
    /// `length_prefixed_to_annexb_tracked` is per-stream stateful
    /// (`avc_tracker` / `mkv_tracker` — see
    /// `container::demux::demux_mp4` ~L223 and `demux_mkv` ~L1065)
    /// — a streaming demuxer that fails to thread tracker state per
    /// sample would diverge mid-stream once the first IRAP after a
    /// SPS/PPS-only sample lands. We iterate the entire `legacy.samples`
    /// vec; the loop has no early-exit. If the streaming demuxer ever
    /// returns fewer samples than legacy, the length-mismatch assertion
    /// fires before the per-sample loop; if it returns more, same.
    fn assert_byte_equal(legacy: &DemuxResult, streamed: &(String, Vec<Vec<u8>>), label: &str) {
        assert_eq!(
            legacy.codec, streamed.0,
            "{label}: codec mismatch (legacy={}, streaming={})",
            legacy.codec, streamed.0
        );
        assert_eq!(
            legacy.samples.len(),
            streamed.1.len(),
            "{label}: sample count mismatch (legacy={}, streaming={})",
            legacy.samples.len(),
            streamed.1.len(),
        );
        // Full-stream walk — NOT capped at first N samples. The
        // `i` index is the locator for the first divergence, not a
        // limit. Tracker-state drift in the AVCC→Annex-B helper would
        // surface several samples in (when the first IRAP after a
        // SPS-only sample drops PPS prepends), so an early-exit cap
        // would mask exactly the regression we're guarding against.
        for (i, (a, b)) in legacy.samples.iter().zip(streamed.1.iter()).enumerate() {
            assert_eq!(
                a.len(),
                b.len(),
                "{label}: sample {i} length differs (legacy={}, streaming={})",
                a.len(),
                b.len(),
            );
            assert_eq!(
                a,
                b,
                "{label}: sample {i} bytes differ (first byte legacy=0x{:02x} streaming=0x{:02x})",
                a.first().copied().unwrap_or(0),
                b.first().copied().unwrap_or(0),
            );
        }
    }

    /// MP4 — uses `Mp4StreamingDemuxer` walking the `mp4` crate's
    /// cursor reader one sample at a time. Length-prefixed AVCC →
    /// Annex-B conversion (Squad-14's tracked helper) must apply
    /// per-sample identically to the materialised path.
    #[test]
    fn streaming_mp4_h264_matches_legacy() {
        let Some(data) = read_test_file("bigbuck_bunny_8bit_750kbps_720p_60.0fps_h264.mp4") else {
            eprintln!("SKIP: BBB H.264 MP4 not in test_media");
            return;
        };
        let legacy = demux::demux(&data).expect("legacy demux mp4 h264");
        let streamed = drain_streaming(&data).expect("streaming demux mp4 h264");
        assert_byte_equal(&legacy, &streamed, "mp4-h264");
    }

    #[test]
    fn streaming_mp4_hevc_matches_legacy() {
        let Some(data) = read_test_file("bigbuck_bunny_8bit_750kbps_720p_60.0fps_hevc.mp4") else {
            eprintln!("SKIP: BBB HEVC MP4 not in test_media");
            return;
        };
        let legacy = demux::demux(&data).expect("legacy demux mp4 hevc");
        let streamed = drain_streaming(&data).expect("streaming demux mp4 hevc");
        assert_byte_equal(&legacy, &streamed, "mp4-hevc");
    }

    #[test]
    fn streaming_mp4_av1_matches_legacy() {
        let Some(data) = read_test_file("jellyfin_av1_main_1080p_24fps.mp4") else {
            eprintln!("SKIP: Jellyfin AV1 MP4 not in test_media");
            return;
        };
        let legacy = demux::demux(&data).expect("legacy demux mp4 av1");
        let streamed = drain_streaming(&data).expect("streaming demux mp4 av1");
        assert_byte_equal(&legacy, &streamed, "mp4-av1");
    }

    /// MKV — `MkvStreamingDemuxer` wraps matroska-demuxer's
    /// `next_frame` API which is already pull-shaped. Verifies the
    /// shared `length_prefixed_to_annexb_tracked` (Squad-14, Squad-2)
    /// produces identical Annex-B per sample.
    #[test]
    fn streaming_mkv_vp9_matches_legacy() {
        let Some(data) = read_test_file("bigbuck_bunny_8bit_750kbps_720p_60.0fps_vp9.mkv") else {
            eprintln!("SKIP: BBB VP9 MKV not in test_media");
            return;
        };
        let legacy = demux::demux(&data).expect("legacy demux mkv vp9");
        let streamed = drain_streaming(&data).expect("streaming demux mkv vp9");
        assert_byte_equal(&legacy, &streamed, "mkv-vp9");
    }

    /// MKV with H.264 video — exercises `mkv_tracker` (the
    /// `length_prefixed_to_annexb_tracked` SPS/PPS prepend helper for
    /// the matroska code path, distinct from the MP4 `avc_tracker`).
    /// Per code-auditor's coverage note: VP9 / AV1 / MPEG-2 / MPEG-4 /
    /// ProRes MKVs skip the tracker (`needs_annexb` is false); only
    /// AVC-in-MKV / HEVC-in-MKV exercise the tracker drift surface.
    /// Without this fixture, the equality suite is blind to a
    /// streaming MkvDemuxer that fails to thread tracker state per
    /// sample on the matroska AVC path.
    #[test]
    fn streaming_mkv_h264_matches_legacy() {
        let candidates = [
            "bigbuck_bunny_8bit_750kbps_720p_60.0fps_h264.mkv",
            "jellyfin_h264_high_l40_1080p_24fps.mkv",
            "h264_main_720p.mkv",
        ];
        let mut ran = false;
        for name in candidates {
            let Some(data) = read_test_file(name) else {
                continue;
            };
            let legacy = demux::demux(&data).expect("legacy demux mkv h264");
            let streamed = drain_streaming(&data).expect("streaming demux mkv h264");
            assert_byte_equal(&legacy, &streamed, &format!("mkv-h264-{name}"));
            ran = true;
            break;
        }
        if !ran {
            eprintln!(
                "SKIP: no MKV-h264 sample in test_media — tracker drift \
                 coverage gap on the matroska AVC code path."
            );
        }
    }

    /// MKV with HEVC video — exercises `mkv_tracker` for the HEVC
    /// VPS/SPS/PPS prepend variant. Same rationale as the MKV-h264
    /// test.
    #[test]
    fn streaming_mkv_hevc_matches_legacy() {
        let candidates = [
            "bigbuck_bunny_8bit_750kbps_720p_60.0fps_hevc.mkv",
            "jellyfin_hevc_main_1080p_24fps.mkv",
            "hevc_main_720p.mkv",
        ];
        let mut ran = false;
        for name in candidates {
            let Some(data) = read_test_file(name) else {
                continue;
            };
            let legacy = demux::demux(&data).expect("legacy demux mkv hevc");
            let streamed = drain_streaming(&data).expect("streaming demux mkv hevc");
            assert_byte_equal(&legacy, &streamed, &format!("mkv-hevc-{name}"));
            ran = true;
            break;
        }
        if !ran {
            eprintln!(
                "SKIP: no MKV-hevc sample in test_media — tracker drift \
                 coverage gap on the matroska HEVC code path."
            );
        }
    }

    #[test]
    fn streaming_webm_av1_matches_legacy() {
        let Some(data) = read_test_file("webmfiles_bbb_av1_main_webm.webm") else {
            eprintln!("SKIP: BBB AV1 WebM not in test_media");
            return;
        };
        let legacy = demux::demux(&data).expect("legacy demux webm av1");
        let streamed = drain_streaming(&data).expect("streaming demux webm av1");
        assert_byte_equal(&legacy, &streamed, "webm-av1");
    }

    /// MPEG-TS — `TsStreamingDemuxer` wraps the existing PES
    /// reassembler in `ts.rs`. The PES yield boundary is already a
    /// natural per-sample yield point.
    #[test]
    fn streaming_ts_matches_legacy() {
        // Squad-13 added MPEG-TS demux. test_media may have a TS file
        // under a few common names.
        let candidates = [
            "ts_h264_main_720p.ts",
            "ts_hevc_main_720p.ts",
            "ts_mpeg2_720p.ts",
            "bigbuck_bunny_h264.ts",
        ];
        let mut ran = false;
        for name in candidates {
            let Some(data) = read_test_file(name) else {
                continue;
            };
            let legacy = demux::demux(&data).expect("legacy demux ts");
            let streamed = drain_streaming(&data).expect("streaming demux ts");
            assert_byte_equal(&legacy, &streamed, &format!("ts-{name}"));
            ran = true;
        }
        if !ran {
            eprintln!("SKIP: no MPEG-TS sample in test_media");
        }
    }

    /// AVI — `AviStreamingDemuxer` converts the idx1-chunk walk
    /// (Squad-13) to a pull-style `next_video_sample()`.
    #[test]
    fn streaming_avi_matches_legacy() {
        let candidates = [
            "xvid_avi_720p.avi",
            "divx_avi_720p.avi",
            "bigbuck_bunny_xvid.avi",
        ];
        let mut ran = false;
        for name in candidates {
            let Some(data) = read_test_file(name) else {
                continue;
            };
            let legacy = demux::demux(&data).expect("legacy demux avi");
            let streamed = drain_streaming(&data).expect("streaming demux avi");
            assert_byte_equal(&legacy, &streamed, &format!("avi-{name}"));
            ran = true;
        }
        if !ran {
            eprintln!("SKIP: no AVI sample in test_media");
        }
    }

    /// Edge case — EOF detection. The streaming demuxer must return
    /// `Ok(None)` on the first call past the last sample, not a
    /// stream-error. Repeat-calling past EOF must keep returning
    /// `Ok(None)` (idempotent, not stateful exhaustion).
    #[test]
    fn streaming_eof_is_idempotent_ok_none() {
        let Some(data) = read_test_file("bigbuck_bunny_8bit_750kbps_720p_60.0fps_h264.mp4") else {
            eprintln!("SKIP: BBB H.264 MP4 not in test_media");
            return;
        };
        let mut sd = demux::demux_streaming(&data).expect("streaming demux");
        let mut count = 0;
        while sd.next_video_sample().expect("next ok").is_some() {
            count += 1;
        }
        assert!(count > 0, "must yield at least one sample");
        // Three more pulls must keep returning Ok(None).
        for i in 0..3 {
            assert!(
                sd.next_video_sample()
                    .expect("post-EOF must be Ok")
                    .is_none(),
                "post-EOF call {i} returned Some — streaming demuxer must be idempotent past EOF",
            );
        }
    }

    /// Edge case — error propagation. A truncated container must
    /// either fail at construction OR return Err from
    /// `next_video_sample()`. It must NOT silently return Ok(None)
    /// after partial data (which would mask data corruption).
    ///
    /// Truncate after the ftyp box so detect_container still routes
    /// to mp4 but the subsequent moov walk fails.
    #[test]
    fn streaming_truncated_input_propagates_error() {
        let Some(full) = read_test_file("bigbuck_bunny_8bit_750kbps_720p_60.0fps_h264.mp4") else {
            eprintln!("SKIP: BBB H.264 MP4 not in test_media");
            return;
        };
        // Keep just the ftyp box (32 bytes is comfortably enough to
        // pass detect_container's magic-byte check) plus a few more
        // bytes so size-fields are present but the moov is missing.
        let truncated = &full[..64.min(full.len())];
        let result = demux::demux_streaming(truncated);
        // EITHER construction fails OR the first pull fails. Both
        // are acceptable — the streaming contract just forbids
        // silent EOF on partial data.
        match result {
            Err(_) => { /* construction-time failure is fine */ }
            Ok(mut sd) => {
                let first = sd.next_video_sample();
                assert!(
                    first.is_err() || matches!(first, Ok(None)),
                    "truncated input must error or yield None at first pull, not Some"
                );
            }
        }
    }

    /// Sanity that the `header()` accessor returns identical metadata
    /// to what `legacy demux()` populates on `info`. The header is
    /// what `pipeline-eng` consumes to drive `create_decoder`.
    #[test]
    fn streaming_header_matches_legacy_info() {
        let candidates = [
            "bigbuck_bunny_8bit_750kbps_720p_60.0fps_h264.mp4",
            "bigbuck_bunny_8bit_750kbps_720p_60.0fps_hevc.mp4",
            "jellyfin_av1_main_1080p_24fps.mp4",
        ];
        for name in candidates {
            let Some(data) = read_test_file(name) else {
                continue;
            };
            let legacy = demux::demux(&data).expect("legacy");
            let sd = demux::demux_streaming(&data).expect("streaming");
            let h = sd.header();
            assert_eq!(h.codec, legacy.codec, "{name}: codec drift");
            assert_eq!(h.info.width, legacy.info.width, "{name}: width drift");
            assert_eq!(h.info.height, legacy.info.height, "{name}: height drift");
            assert_eq!(
                h.info.pixel_format, legacy.info.pixel_format,
                "{name}: pixel_format drift"
            );
            // frame_rate is f64 — exact equality required since both
            // paths derive from the same source bytes via the same
            // computation (no estimator drift expected).
            assert_eq!(
                h.info.frame_rate, legacy.info.frame_rate,
                "{name}: frame_rate drift"
            );
        }
    }

    // Avoid an unused-import warning when no test_media is present
    // and every test SKIPs early.
    #[allow(dead_code)]
    fn _silence_unused_path(_p: &Path) {}
}

/// Visible-in-output skip marker that runs regardless of cfg state.
/// Lets a human reading test output see "I checked, the streaming API
/// gate is currently OFF". Once `streaming-architect` flips the cfg
/// post-merge, this becomes a no-op next to the real tests.
#[test]
fn _streaming_equality_gate_status() {
    if cfg!(streaming_api_landed) {
        eprintln!(
            "streaming_equality: gate ON — the per-format equality \
             tests in `gated_tests` are active."
        );
    } else {
        eprintln!(
            "streaming_equality: gate OFF — the per-format equality \
             tests are compile-skipped because `demux_streaming()` is \
             not yet on this branch (P1 not merged in). Re-run with \
             `RUSTFLAGS=\"--cfg streaming_api_landed\"` after the \
             P1 merge to activate the regressions."
        );
    }
}