//! MPEG transport / program streams against ffmpeg: ffmpeg writes the files and decodes them as
//! the oracle. Video: frame count and display order exact, PTS exact against ffprobe, H.264 /
//! HEVC bit-exact, MPEG-2 within the IDCT tolerance of `filmcraft-mpeg2v` (±4, PSNR ≥ 58 dB);
//! random seeks give the frames of the sequential decode. Audio: LPCM sample-exact, MPEG audio
//! and AAC within a float-decoder tolerance, starting at the same sample.

mod common;

use std::path::{Path, PathBuf};

use common::*;
use filmcraft_codecs::MpegSource;
use filmcraft_media::{FrameRequest, MediaError, MediaSource};

/// Stereo test audio with different content per channel (tones and a chirp).
const NOISE: &[&str] =
    &["-f", "lavfi", "-i", "aevalsrc=exprs=0.3*sin(2*PI*441*t)+0.1*sin(2*PI*3100*t)|0.25*sin(2*PI*660*t)+0.1*sin(2*PI*(500+4000*t)*t):s=48000"];

/// A mono tone.
const MONO: &[&str] = &["-f", "lavfi", "-i", "sine=frequency=1000:sample_rate=48000"];

fn spec(name: &str) -> Vec<String> {
    let cat = |p: &[&[&str]]| p.concat().into_iter().map(String::from).collect::<Vec<_>>();
    match name {
        // broadcast-style SD: interlaced MPEG-2 + MPEG-1 layer II
        "ts_mpeg2_mp2.ts" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=720x576:rate=50,tinterlace=mode=interleave_top,setfield=tff"],
            NOISE,
            &["-t", "1.2", "-c:v", "mpeg2video", "-flags", "+ilme+ildct", "-bf", "2", "-g", "12", "-b:v", "6M", "-c:a", "mp2", "-b:a", "192k", "-f", "mpegts"],
        ]),
        "ts_h264_aac.ts" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"],
            NOISE,
            &["-t", "1.2", "-c:v", "libx264", "-bf", "2", "-g", "12", "-pix_fmt", "yuv420p", "-c:a", "aac", "-aac_pns", "0", "-b:a", "128k", "-f", "mpegts"],
        ]),
        // AVCHD-style BDAV (192-byte packets): H.264 + Blu-ray LPCM
        "m2ts_h264_lpcm.m2ts" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=640x360:rate=30000/1001"],
            NOISE,
            &[
                "-t",
                "1",
                "-c:v",
                "libx264",
                "-bf",
                "2",
                "-g",
                "15",
                "-pix_fmt",
                "yuv420p",
                "-c:a",
                "pcm_bluray",
                "-ac",
                "2",
                "-f",
                "mpegts",
                "-mpegts_m2ts_mode",
                "1",
            ],
        ]),
        // AVCHD audio is usually AC-3
        "m2ts_h264_ac3.mts" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=640x360:rate=30000/1001"],
            NOISE,
            &[
                "-t",
                "1",
                "-c:v",
                "libx264",
                "-bf",
                "2",
                "-g",
                "15",
                "-pix_fmt",
                "yuv420p",
                "-c:a",
                "ac3",
                "-b:a",
                "192k",
                "-ac",
                "2",
                "-f",
                "mpegts",
                "-mpegts_m2ts_mode",
                "1",
            ],
        ]),
        "ts_hevc_latm.ts" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"],
            NOISE,
            &[
                "-t",
                "1",
                "-c:v",
                "libx265",
                "-x265-params",
                "log-level=error:bframes=2:keyint=12",
                "-c:a",
                "aac",
                "-aac_pns",
                "0",
                "-b:a",
                "96k",
                "-f",
                "mpegts",
                "-mpegts_flags",
                "latm",
            ],
        ]),
        // DVD-style program streams
        "ps_mpeg2_mp2.vob" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=720x480:rate=30000/1001"],
            NOISE,
            &["-t", "1.2", "-c:v", "mpeg2video", "-bf", "2", "-g", "15", "-b:v", "5M", "-c:a", "mp2", "-b:a", "224k", "-f", "vob"],
        ]),
        "ps_mpeg2_lpcm.vob" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=720x576:rate=25"],
            NOISE,
            &["-t", "1", "-c:v", "mpeg2video", "-bf", "2", "-c:a", "pcm_dvd", "-ac", "2", "-f", "vob"],
        ]),
        "ps_mpeg2_lpcm16.vob" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=352x288:rate=25"],
            NOISE,
            &["-t", "0.6", "-c:v", "mpeg2video", "-c:a", "pcm_dvd", "-sample_fmt", "s16", "-ac", "2", "-f", "vob"],
        ]),
        "ps_mpeg2_ac3.vob" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=720x576:rate=25"],
            NOISE,
            &["-t", "1", "-c:v", "mpeg2video", "-bf", "2", "-c:a", "ac3", "-b:a", "192k", "-f", "vob"],
        ]),
        // ISO/IEC 11172-1 system stream
        "mpeg1_system.mpg" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=352x288:rate=25"],
            NOISE,
            &["-t", "1.2", "-c:v", "mpeg1video", "-bf", "2", "-b:v", "1500k", "-c:a", "mp2", "-b:a", "128k", "-f", "mpeg"],
        ]),
        // XDCAM HD422 in QuickTime (`xd5c`), MPEG-2 in MP4 (`mp4v`, esds object type 0x61) and
        // Matroska (`V_MPEG2`)
        "mov_xdcam_hd422.mov" => cat(&[
            &["-f", "lavfi", "-i", "testsrc2=size=1920x1080:rate=50,tinterlace=mode=interleave_top,setfield=tff"],
            &["-t", "0.4", "-c:v", "mpeg2video", "-pix_fmt", "yuv422p", "-flags", "+ilme+ildct", "-bf", "2", "-g", "12", "-b:v", "50M"],
        ]),
        "mp4_mpeg2.mp4" => cat(&[&["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"], &["-t", "0.6", "-c:v", "mpeg2video", "-bf", "2", "-g", "6"]]),
        "mkv_mpeg2.mkv" => {
            cat(&[&["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"], NOISE, &["-t", "0.6", "-c:v", "mpeg2video", "-bf", "2", "-g", "6", "-c:a", "mp2"]])
        }
        "audio.mp2" => cat(&[NOISE, &["-t", "1", "-c:a", "mp2", "-b:a", "224k", "-f", "mp2"]]),
        // mono MP2 at ffmpeg's default bit rate, 384 kbit/s, which ISO/IEC 11172-3 does not allow
        "audio_mono.mp2" => cat(&[MONO, &["-t", "1", "-c:a", "mp2", "-f", "mp2"]]),
        "ts_mpeg2_mono_mp2.ts" => {
            cat(&[&["-f", "lavfi", "-i", "testsrc2=size=320x240:rate=25"], MONO, &["-t", "1", "-c:v", "mpeg2video", "-c:a", "mp2", "-f", "mpegts"]])
        }
        "mkv_mono_mp2.mkv" => cat(&[MONO, &["-t", "1", "-c:a", "mp2"]]),
        "es_mpeg2.m2v" => {
            cat(&[&["-f", "lavfi", "-i", "testsrc2=size=352x288:rate=25"], &["-t", "1", "-c:v", "mpeg2video", "-bf", "2", "-g", "9", "-f", "mpeg2video"]])
        }
        other => panic!("unknown fixture {other}"),
    }
}

pub const ALL: &[&str] = &[
    "ts_mpeg2_mp2.ts",
    "ts_h264_aac.ts",
    "m2ts_h264_lpcm.m2ts",
    "m2ts_h264_ac3.mts",
    "ts_hevc_latm.ts",
    "ps_mpeg2_mp2.vob",
    "ps_mpeg2_lpcm.vob",
    "ps_mpeg2_lpcm16.vob",
    "ps_mpeg2_ac3.vob",
    "mpeg1_system.mpg",
    "mov_xdcam_hd422.mov",
    "mp4_mpeg2.mp4",
    "mkv_mpeg2.mkv",
    "audio.mp2",
    "audio_mono.mp2",
    "ts_mpeg2_mono_mp2.ts",
    "mkv_mono_mp2.mkv",
    "es_mpeg2.m2v",
];

fn make(ff: &Path, name: &str) -> PathBuf {
    let args = spec(name);
    let refs: Vec<&str> = args.iter().map(String::as_str).collect();
    fixture(ff, name, &refs).unwrap_or_else(|| panic!("could not generate {name}"))
}

fn open(p: &Path) -> MpegSource {
    MpegSource::open(p.file_name().unwrap().to_str().unwrap(), bytes(p)).unwrap()
}

/// ffprobe's video frames in display order: PTS (90 kHz). A program-stream picture
/// need not carry its own PTS; use the decoder's presentation timestamp for that picture.
fn ffprobe_frame_pts(file: &Path) -> Option<Vec<i64>> {
    let fp = filmcraft_testkit::ffprobe_or_skip("MPEG video frame presentation timestamps")?;
    let o = std::process::Command::new(fp)
        .args(["-v", "error", "-select_streams", "v:0", "-show_entries", "frame=pts,best_effort_timestamp", "-of", "json"])
        .arg(file)
        .output()
        .unwrap_or_else(|error| panic!("{}: cannot run ffprobe: {error}", file.display()));
    assert!(o.status.success(), "{}: ffprobe failed: {}", file.display(), String::from_utf8_lossy(&o.stderr));
    Some(parse_ffprobe_frame_pts(&o.stdout).unwrap_or_else(|error| panic!("{}: {error}", file.display())))
}

fn parse_ffprobe_frame_pts(bytes: &[u8]) -> Result<Vec<i64>, String> {
    let data: serde_json::Value = serde_json::from_slice(bytes).map_err(|error| format!("invalid ffprobe JSON: {error}"))?;
    let frames = data.get("frames").and_then(serde_json::Value::as_array).ok_or("ffprobe output is missing its frames array")?;
    if frames.is_empty() {
        return Err("ffprobe returned no video frames".into());
    }
    frames
        .iter()
        .enumerate()
        .map(|(index, frame)| {
            let field = if frame.get("pts").is_some() { "pts" } else { "best_effort_timestamp" };
            frame.get(field).and_then(serde_json::Value::as_i64).ok_or_else(|| format!("ffprobe video frame {index} is missing an integer {field}"))
        })
        .collect()
}

#[test]
fn ffprobe_pts_preserve_missing_raw_timestamps_and_side_data() {
    let output = br#"{"frames":[
        {"pts":131400,"best_effort_timestamp":131401,"side_data_list":[{},{}]},
        {"best_effort_timestamp":135000,"side_data_list":[{}]},
        {"pts":138600,"best_effort_timestamp":138600}
    ]}"#;
    assert_eq!(parse_ffprobe_frame_pts(output).unwrap(), [131400, 135000, 138600], "keep every display frame, with raw PTS preferred when present");
    assert_eq!(parse_ffprobe_frame_pts(br#"{"frames":[{"pts":-3600},{"pts":0},{"pts":9223372036854775807}]}"#).unwrap(), [-3600, 0, i64::MAX]);
}

#[test]
fn malformed_ffprobe_pts_fail_instead_of_dropping_frames() {
    for output in [
        "not JSON",
        "{}",
        r#"{"frames":{}}"#,
        r#"{"frames":[]}"#,
        r#"{"frames":[{}]}"#,
        r#"{"frames":[null]}"#,
        r#"{"frames":[{"pts":"N/A","best_effort_timestamp":135000}]}"#,
        r#"{"frames":[{"pts":null,"best_effort_timestamp":135000}]}"#,
        r#"{"frames":[{"pts":1.5}]}"#,
        r#"{"frames":[{"pts":9223372036854775808}]}"#,
        r#"{"frames":[{"best_effort_timestamp":"135000"}]}"#,
        r#"{"frames":[{"pts":131400},{"best_effort_timestamp":null},{"pts":138600}]}"#,
    ] {
        assert!(parse_ffprobe_frame_pts(output.as_bytes()).is_err(), "malformed oracle output must fail: {output}");
    }
}

/// Decode every frame in order and `seeks` random frames; compare with ffmpeg within `tol`.
/// Returns (max difference, PSNR).
fn check_video(ff: &Path, file: &Path, tol: u16, seeks: usize) -> (u16, f64) {
    let src = open(file);
    let v = src.info().video.clone().unwrap();
    let (w, h) = (v.width as usize, v.height as usize);
    let first = src.video_frame(FrameRequest::full(filmcraft_time::Tick::ZERO)).unwrap();
    let (cw, ch, pix) = match &first.data {
        filmcraft_frame::PixelData::Yuv8 { chroma: filmcraft_frame::Chroma::C422, .. } => (w / 2, h, "yuv422p"),
        _ => (w.div_ceil(2), h.div_ceil(2), "yuv420p"),
    };
    let raw = ffmpeg_frames(ff, file, pix);
    let fsize = w * h + 2 * cw * ch;
    let n = raw.len() / fsize;
    let rate = v.frame_rate;
    assert_eq!(src.info().duration, rate.tick_of(n as i64), "{}: duration = ffmpeg's {n} frames", file.display());
    let frame = |i: usize| raw_planes(&raw[i * fsize..(i + 1) * fsize], w, h, cw, ch, 1);
    let (mut worst, mut sse, mut cnt) = (0u16, 0f64, 0u64);
    let mut ours = Vec::new();
    for i in 0..n {
        let f = src.video_frame(FrameRequest::full(rate.tick_of(i as i64))).unwrap();
        let p = planes(&f);
        let r = frame(i);
        let d = max_diff(&p, &r);
        for (a, b) in p.iter().zip(&r) {
            for (x, y) in a.iter().zip(b) {
                sse += (*x as f64 - *y as f64).powi(2);
                cnt += 1;
            }
        }
        worst = worst.max(d);
        assert!(d <= tol, "{}: frame {i} differs by {d}", file.display());
        ours.push(p);
    }
    // random access on a fresh source gives the same frames
    let fresh = open(file);
    let mut rng = Rng(0x5EED);
    for _ in 0..seeks {
        let i = rng.below(n as u64) as usize;
        let f = fresh.video_frame(FrameRequest::full(rate.tick_of(i as i64))).unwrap();
        assert!(planes(&f) == ours[i], "{}: seek to frame {i} differs from the sequential decode", file.display());
    }
    // presentation timestamps in display order = ffprobe's
    if let Some(fp) = ffprobe_frame_pts(file) {
        let pts = src.video_pts();
        let missing: Vec<usize> = (0..pts.len()).filter(|&i| pts[i].is_none()).collect();
        assert!(missing.is_empty(), "{}: frames without PTS: {missing:?} (ffprobe {:?})", file.display(), &fp[..fp.len().min(12)]);
        let pts: Vec<i64> = pts.into_iter().flatten().collect();
        assert_eq!(pts, fp, "{}: frame PTS", file.display());
    }
    let psnr = if sse == 0.0 { f64::INFINITY } else { 10.0 * (255f64 * 255.0 * cnt as f64 / sse).log10() };
    (worst, psnr)
}

/// Our decoded audio from the first audio frame against ffmpeg's decode. Returns the max error.
fn check_audio(ff: &Path, file: &Path, tol: f32) -> f32 {
    let src = open(file);
    let a = src.info().audio().cloned().unwrap();
    let (start, len) = src.audio_extent().unwrap();
    let want = ffmpeg_audio_f32(ff, file, &[]);
    let ch = a.channels as usize;
    assert_eq!(want.len() % ch, 0);
    let n = want.len() / ch;
    assert_eq!(len as usize, n, "{}: audio samples = ffmpeg's", file.display());
    let buf = src.audio(start, n, a.sample_rate).unwrap();
    let mut worst = 0f32;
    for i in 0..n {
        for c in 0..ch {
            worst = worst.max((buf.channels[c][i] - want[i * ch + c]).abs());
        }
    }
    if worst > tol {
        // where it starts, and the lag that best aligns the two (diagnostics)
        let first_bad = (0..n * ch).find(|&k| (buf.channels[k % ch][k / ch] - want[k]).abs() > tol).map(|k| k / ch);
        let best = (-4000i64..=4000)
            .map(|lag| {
                let e: f64 = (4000..n.min(20_000))
                    .map(|i| {
                        let j = i as i64 + lag;
                        if j < 0 || j as usize >= n { 0.0 } else { (buf.channels[0][i] as f64 - want[j as usize * ch] as f64).powi(2) }
                    })
                    .sum();
                (e, lag)
            })
            .fold((f64::MAX, 0), |a, b| if b.0 < a.0 { b } else { a });
        let per: Vec<String> = (0..n.min(16 * 1152))
            .step_by(1152)
            .map(|s| {
                let e = (s..(s + 1152).min(n)).map(|i| (buf.channels[0][i] - want[i * ch]).abs()).fold(0f32, f32::max);
                let ours = (s..(s + 1152).min(n)).map(|i| buf.channels[0][i].abs()).fold(0f32, f32::max);
                format!("{e:.3}/{ours:.3}")
            })
            .collect();
        panic!(
            "{}: audio max error {worst}, first at sample {first_bad:?}, best lag {} (residual {:.3e}); per 1152 (err/peak): {per:?}",
            file.display(),
            best.1,
            best.0
        );
    }
    // a window read on a fresh source (random access) gives the same samples
    let fresh = open(file);
    let at = start + n as i64 / 3;
    let win = fresh.audio(at, 4800.min(n / 2), a.sample_rate).unwrap();
    for c in 0..ch {
        for (k, v) in win.channels[c].iter().enumerate() {
            let i = (at - start) as usize + k;
            assert!((v - buf.channels[c][i]).abs() <= 1e-6, "{}: random-access audio differs at {i}", file.display());
        }
    }
    worst
}

#[test]
fn transport_stream_mpeg2_and_mp2() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "ts_mpeg2_mp2.ts");
    let src = open(&f);
    let v = src.info().video.clone().unwrap();
    assert_eq!(src.info().container, "MPEG-2 TS");
    assert!(v.codec.starts_with("MPEG-2 Video (Main@"), "{}", v.codec);
    assert_eq!(v.pixel_format, "YUV 4:2:0 8-bit, interlaced (upper field first)");
    assert_eq!((v.width, v.height, v.par), (720, 576, (1, 1)));
    let (worst, psnr) = check_video(&ff, &f, 4, 12);
    assert!(psnr >= 58.0, "PSNR {psnr}");
    println!("ts_mpeg2_mp2: video max diff {worst}, PSNR {psnr:.2} dB");
    let a = src.info().audio().cloned().unwrap();
    assert_eq!((a.codec.as_str(), a.sample_rate, a.channels), ("MPEG Audio", 48_000, 2));
    let e = check_audio(&ff, &f, 2e-4);
    println!("ts_mpeg2_mp2: MP2 audio max error {e:.2e}");
}

#[test]
fn transport_stream_h264_and_aac() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "ts_h264_aac.ts");
    let src = open(&f);
    assert_eq!(src.info().video.as_ref().unwrap().codec, "H.264");
    check_video(&ff, &f, 0, 10);
    let e = check_audio(&ff, &f, 1e-4);
    println!("ts_h264_aac: AAC max error {e:.2e}");
}

#[test]
fn bdav_h264_with_lpcm_sample_exact() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "m2ts_h264_lpcm.m2ts");
    let src = open(&f);
    assert_eq!(src.info().container, "MPEG-2 TS (BDAV/AVCHD)");
    let a = src.info().audio().cloned().unwrap();
    assert_eq!((a.codec.as_str(), a.channels, a.bits_per_sample), ("LPCM (Blu-ray)", 2, Some(24)));
    check_video(&ff, &f, 0, 10);
    assert_eq!(check_audio(&ff, &f, 0.0), 0.0);
}

#[test]
fn avchd_ac3_audio() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "m2ts_h264_ac3.mts");
    let src = open(&f);
    check_video(&ff, &f, 0, 6);
    let a = src.info().audio().cloned().unwrap();
    if filmcraft_codecs::audio::AC3_DECODER {
        assert_eq!((a.codec.as_str(), a.channels), ("AC-3", 2));
        // AC-3 zero-bit mantissas carry decoder-specific dither (A/52 §7.3.4)
        let e = check_audio(&ff, &f, 5e-3);
        println!("m2ts_h264_ac3: AC-3 max error {e:.2e}");
    } else {
        assert_eq!(a.codec, "AC-3 (unsupported)");
        match src.audio(0, 100, 48_000) {
            Err(MediaError::Unsupported(why)) => assert!(why.contains("AC-3"), "{why}"),
            other => panic!("expected unsupported, got {:?}", other.map(|_| ())),
        }
    }
}

#[test]
fn transport_stream_hevc_and_latm() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "ts_hevc_latm.ts");
    let src = open(&f);
    assert_eq!(src.info().video.as_ref().unwrap().codec, "HEVC");
    assert_eq!(src.info().audio().unwrap().codec, "AAC (LATM)");
    check_video(&ff, &f, 0, 8);
    let e = check_audio(&ff, &f, 1e-4);
    println!("ts_hevc_latm: AAC (LATM) max error {e:.2e}");
}

#[test]
fn program_streams() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "ps_mpeg2_mp2.vob");
    let src = open(&f);
    assert_eq!(src.info().container, "MPEG-2 PS");
    let (worst, psnr) = check_video(&ff, &f, 4, 10);
    assert!(psnr >= 58.0);
    println!("ps_mpeg2_mp2: video max diff {worst}, PSNR {psnr:.2} dB");
    check_audio(&ff, &f, 2e-4);
    // DVD LPCM: sample-exact
    let f = make(&ff, "ps_mpeg2_lpcm.vob");
    let src = open(&f);
    assert_eq!(src.info().audio().unwrap().codec, "LPCM (DVD)");
    assert_eq!(src.info().audio().unwrap().bits_per_sample, Some(24));
    assert_eq!(check_audio(&ff, &f, 0.0), 0.0);
    check_video(&ff, &f, 4, 4);
    let f = make(&ff, "ps_mpeg2_lpcm16.vob");
    assert_eq!(open(&f).info().audio().unwrap().bits_per_sample, Some(16));
    assert_eq!(check_audio(&ff, &f, 0.0), 0.0);
    // AC-3 in private stream 1
    let f = make(&ff, "ps_mpeg2_ac3.vob");
    let src = open(&f);
    assert_eq!(src.info().audio().unwrap().codec, "AC-3");
    let e = check_audio(&ff, &f, 5e-3);
    println!("ps_mpeg2_ac3: AC-3 max error {e:.2e}");
    // MPEG-1 system stream
    let f = make(&ff, "mpeg1_system.mpg");
    let src = open(&f);
    assert_eq!(src.info().container, "MPEG-1 System");
    assert_eq!(src.info().video.as_ref().unwrap().codec, "MPEG-1 Video");
    let (worst, psnr) = check_video(&ff, &f, 4, 6);
    assert!(psnr >= 58.0);
    println!("mpeg1_system: video max diff {worst}, PSNR {psnr:.2} dB");
    check_audio(&ff, &f, 2e-4);
}

#[test]
fn video_elementary_stream() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "es_mpeg2.m2v");
    let src = filmcraft_codecs::open_bytes("es_mpeg2.m2v", bytes(&f)).unwrap();
    assert_eq!(src.info().container, "MPEG video elementary stream");
    let raw = ffmpeg_frames(&ff, &f, "yuv420p");
    let fsize = 352 * 288 * 3 / 2;
    let n = raw.len() / fsize;
    let rate = src.info().frame_rate();
    assert_eq!(src.info().duration, rate.tick_of(n as i64));
    for i in 0..n {
        let fr = src.video_frame(FrameRequest::full(rate.tick_of(i as i64))).unwrap();
        let d = max_diff(&planes(&fr), &raw_planes(&raw[i * fsize..(i + 1) * fsize], 352, 288, 176, 144, 1));
        assert!(d <= 4, "frame {i}: {d}");
    }
}

#[test]
fn mpeg2_in_quicktime_mp4_and_matroska() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    for (name, chroma) in [("mov_xdcam_hd422.mov", (2, 1)), ("mp4_mpeg2.mp4", (2, 2)), ("mkv_mpeg2.mkv", (2, 2))] {
        let f = make(&ff, name);
        let src = filmcraft_codecs::open_bytes(name, bytes(&f)).unwrap();
        let v = src.info().video.clone().unwrap();
        let (w, h) = (v.width as usize, v.height as usize);
        let (cw, ch) = (w / chroma.0, h / chroma.1);
        let raw = ffmpeg_frames(&ff, &f, if chroma.1 == 1 { "yuv422p" } else { "yuv420p" });
        let fsize = w * h + 2 * cw * ch;
        let n = raw.len() / fsize;
        assert!(n >= 10, "{name}: {n} frames");
        for i in 0..n {
            let fr = src.video_frame(FrameRequest::full(v.frame_rate.tick_of(i as i64))).unwrap();
            let d = max_diff(&planes(&fr), &raw_planes(&raw[i * fsize..(i + 1) * fsize], w, h, cw, ch, 1));
            assert!(d <= 4, "{name}: frame {i} differs by {d}");
        }
    }
}

#[test]
fn standalone_mp2_file() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "audio.mp2");
    let src = filmcraft_codecs::open_bytes("audio.mp2", bytes(&f)).unwrap();
    let a = src.info().audio().cloned().unwrap();
    assert_eq!((a.sample_rate, a.channels), (48_000, 2));
    let want = ffmpeg_audio_f32(&ff, &f, &[]);
    let n = want.len() / 2;
    let buf = src.audio(0, n, 48_000).unwrap();
    let worst = (0..n).map(|i| (buf.channels[0][i] - want[2 * i]).abs().max((buf.channels[1][i] - want[2 * i + 1]).abs())).fold(0f32, f32::max);
    assert!(worst <= 2e-4, "{worst}");
}

/// #809: mono MP2 at 384 kbit/s, ffmpeg's default, played as silence in every container because
/// symphonia rejects the bit rate / mode combinations ISO/IEC 11172-3 does not allow.
#[test]
fn mono_mp2_at_ffmpegs_default_bit_rate() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    let f = make(&ff, "audio_mono.mp2");
    assert_eq!(std::fs::read(&f).unwrap()[2] >> 4, 14, "384 kbit/s");
    let worst = check_audio(&ff, &make(&ff, "ts_mpeg2_mono_mp2.ts"), 2e-4);
    println!("ts_mpeg2_mono_mp2.ts: max error {worst}");
    // Matroska stores the encoder's 481-sample priming as `CodecDelay`. Whether ffmpeg's CLI trims
    // it depends on its version (9.x does; 2023-24 builds keep the priming samples), and until
    // #790 we trim it rounded to the millisecond. So for .mkv ffmpeg's decode is searched at
    // lags within a sample or two of 0 (trimmed) and of `CodecDelay` (kept). The plain .mp2 file
    // has no such ambiguity and must line up exactly.
    for name in ["audio_mono.mp2", "mkv_mono_mp2.mkv"] {
        let f = make(&ff, name);
        let file = bytes(&f);
        let src = filmcraft_codecs::open_bytes(name, file.clone()).unwrap();
        let a = src.info().audio().cloned().unwrap();
        assert_eq!((a.sample_rate, a.channels), (48_000, 1), "{name}");
        let want = ffmpeg_audio_f32(&ff, &f, &[]);
        let (delay, lags): (usize, Vec<i64>) = match name.ends_with(".mkv") {
            true => {
                let mkv = filmcraft_matroska::open(file).unwrap();
                let ns = mkv.tracks.first().map_or(0, |t| t.codec_delay_ns);
                let delay = ((ns * 48_000 + 500_000_000) / 1_000_000_000) as usize;
                assert!(delay > 0, "{name}: no CodecDelay");
                (delay, (-2..=2).chain(delay as i64 - 2..=delay as i64 + 2).collect())
            }
            false => (0, vec![0]),
        };
        // ours from sample 2 on, against ffmpeg's from sample 2 + lag (inside both decodes)
        let n = want.len() - delay - 6;
        let buf = src.audio(0, n, 48_000).unwrap();
        let (worst, lag) = lags
            .into_iter()
            .map(|lag| {
                let err = (2..n - 2).map(|i| (want[(i as i64 + lag) as usize] - buf.channels[0][i]).abs()).fold(0f32, f32::max);
                (err, lag)
            })
            .fold((f32::INFINITY, 0), |m, x| if x.0 < m.0 { x } else { m });
        let peak = want.iter().fold(0f32, |m, x| m.max(x.abs()));
        println!("{name}: max error {worst} at lag {lag} (CodecDelay {delay}), peak {peak}");
        assert!(peak > 0.1 && worst <= 2e-4, "{name}: peak {peak}, max error {worst} at lag {lag}");
    }
}

#[test]
fn truncated_and_corrupt_files_never_panic() {
    let ff = filmcraft_testkit::require_ffmpeg!();
    for name in ["ts_mpeg2_mp2.ts", "ps_mpeg2_mp2.vob", "ts_h264_aac.ts"] {
        let f = make(&ff, name);
        let full = std::fs::read(&f).unwrap();
        let mut rng = Rng(0xC0FFEE);
        let exercise = |data: Vec<u8>, rng: &mut Rng| {
            let Ok(s) = MpegSource::open(name, data.into()) else { return };
            let info = s.info().clone();
            if let Some(v) = &info.video {
                let frames = v.frame_rate.frame_at(info.duration).max(1);
                for _ in 0..3 {
                    let i = rng.below(frames as u64) as i64;
                    let _ = s.video_frame(FrameRequest::full(v.frame_rate.tick_of(i)));
                }
            }
            if let Some(a) = info.audio() {
                let _ = s.audio(rng.below(48_000) as i64, 2048, a.sample_rate);
            }
        };
        for k in 1..=8 {
            exercise(full[..full.len() * k / 9].to_vec(), &mut rng);
        }
        for _ in 0..12 {
            let mut m = full.clone();
            for _ in 0..40 {
                let i = rng.below(m.len() as u64) as usize;
                m[i] = rng.below(256) as u8;
            }
            exercise(m, &mut rng);
        }
    }
}

#[test]
#[ignore]
fn generate_fixtures() {
    let Some(ff) = filmcraft_testkit::ffmpeg_or_skip("codecs mpeg fixtures") else { return };
    for name in ALL {
        let out = [dir().join(name)];
        filmcraft_testkit::fixtures::generate_and_report(&format!("codecs/{name}"), &out, || {
            let args = spec(name);
            let refs: Vec<&str> = args.iter().map(String::as_str).collect();
            fixture(&ff, name, &refs)
        });
    }
}