GitCorner

Code

ossartcraftfilmcraft๐ŸŒ
f67d38b35cc5
//! M6.5 export settings: image sequences, audio-only formats, frame size / rate / scaling,
//! loudness normalization, two-pass and CBR H.264, the video limiter, overlays, metadata and the
//! QuickTime multiplexer. ffprobe / ffmpeg are used only as external test oracles.

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

use filmcraft_media::generators::GeneratorSource;
use filmcraft_media::{FrameRequest, Generator, MediaSource};
use filmcraft_project::{ItemKind, Label, MediaClip, MediaRef, SequenceSettings, TrackKind};
use filmcraft_render::SourceMap;
use filmcraft_time::TICKS_PER_SECOND;

use super::*;

/// A scratch directory under the workspace `target/`, removed when dropped.
struct Scratch(PathBuf);

impl Scratch {
    fn new(name: &str) -> Self {
        let d = filmcraft_testkit::fixtures::workspace_root().join("target").join("export-tests").join(format!("{name}-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&d);
        std::fs::create_dir_all(&d).unwrap();
        Scratch(d)
    }
    fn path(&self, name: &str) -> String {
        self.0.join(name).to_string_lossy().to_string()
    }
}

impl Drop for Scratch {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.0);
    }
}

/// A `w`ร—`h` 24 fps sequence: a colour matte (1 s) and optionally a 440 Hz tone at `tone_db`.
fn matte(color: [f32; 4], w: u32, h: u32, tone_db: Option<f32>) -> (Arc<Project>, ItemId, SourceMap) {
    let mut p = Project::new("m");
    let r = FrameRate::FPS_24;
    let dur = Tick(2 * TICKS_PER_SECOND);
    let mut m = SourceMap::default();
    let mut add = |p: &mut Project, g: GeneratorSource| {
        let info = g.info().clone();
        let id = p.add_item(
            &info.name.clone(),
            Label::Iris,
            ItemKind::Media(Box::new(MediaClip {
                media: MediaRef::Generator(g.generator.clone()),
                info,
                interpret: Default::default(),
                mark_in: None,
                mark_out: None,
                markers: vec![],
                offline: false,
                proxy: None,
                identity: None,
            })),
            None,
        );
        m.0.insert(id, Arc::new(g) as Arc<dyn MediaSource>);
        id
    };
    let v = add(&mut p, GeneratorSource::new(Generator::ColorMatte { color }, w, h, r, dur));
    let a = tone_db.map(|db| add(&mut p, GeneratorSource::new(Generator::Tone { hz: 440.0, db }, w, h, r, dur)));
    let seq = p.new_sequence("s", SequenceSettings { width: w, height: h, frame_rate: r, ..Default::default() }, 1, 1, None);
    let vi = p.make_track_item(v, TrackKind::Video, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
    p.sequence_mut(seq).unwrap().video_tracks[0].items.push(vi);
    if let Some(a) = a {
        let ai = p.make_track_item(a, TrackKind::Audio, Tick::ZERO, TimeRange::new(Tick::ZERO, r.tick_of(24)), r).unwrap();
        p.sequence_mut(seq).unwrap().audio_tracks[0].items.push(ai);
    }
    (Arc::new(p), seq, m)
}

fn ffprobe_json(args: &[&str], path: &str) -> Option<serde_json::Value> {
    let ffprobe = filmcraft_testkit::ffprobe_or_skip("export settings")?;
    let mut a = vec!["-v", "error", "-of", "json"];
    a.extend_from_slice(args);
    a.push(path);
    let out = std::process::Command::new(ffprobe).args(&a).output().unwrap();
    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
    Some(serde_json::from_slice(&out.stdout).unwrap())
}

fn files_in(dir: &Path) -> Vec<String> {
    let mut v: Vec<String> = std::fs::read_dir(dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().to_string()).collect();
    v.sort();
    v
}

/// Walk top-level boxes, including the extended-size `mdat`; never match codec payload bytes.
fn top_level_boxes(bytes: &[u8]) -> Vec<([u8; 4], usize, usize)> {
    let mut boxes = Vec::new();
    let mut offset = 0;
    while offset < bytes.len() {
        let header = &bytes[offset..offset + 8];
        let size = u32::from_be_bytes(header[..4].try_into().unwrap());
        let (size, header_len) = match size {
            0 => (bytes.len() - offset, 8),
            1 => (usize::try_from(u64::from_be_bytes(bytes[offset + 8..offset + 16].try_into().unwrap())).unwrap(), 16),
            n => (n as usize, 8),
        };
        assert!(size >= header_len && size <= bytes.len() - offset);
        boxes.push((header[4..8].try_into().unwrap(), offset, offset + size));
        offset += size;
    }
    boxes
}

/// #3459: MP4 uploads need `moov` before `mdat`, on disk and in browser downloads alike.
#[test]
fn mp4_faststart_preserves_video_and_audio_for_every_output() {
    let (p, seq, m) = matte([1.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("mp4-faststart");
    for multiplexer in [Multiplexer::Mp4, Multiplexer::Mov] {
        for mode in ["disk", "reserved", "memory"] {
            let ext = if multiplexer == Multiplexer::Mp4 { "mp4" } else { "mov" };
            let path = dir.path(&format!("{mode}.{ext}"));
            let captured = Arc::new(Mutex::new(Vec::new()));
            let mut settings = ExportSettings {
                format: Format::H264,
                multiplexer,
                path: path.clone(),
                range: Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(6))),
                hardware_encoding: HardwareEncoding::Off,
                gpu_rendering: GpuRendering::Off,
                audio: AudioSettings { codec: AudioCodec::Aac, ..Default::default() },
                ..Default::default()
            };
            if mode == "reserved" {
                settings.output_file = Some(Arc::new(std::fs::OpenOptions::new().read(true).write(true).create_new(true).open(&path).unwrap()));
            } else if mode == "memory" {
                let captured = captured.clone();
                settings.sink = Some(OutputSink(Arc::new(move |_, bytes| {
                    *captured.lock().unwrap() = bytes;
                    Ok(())
                })));
            }
            let report = export(&p, seq, &settings, &m, &Progress::default()).unwrap();
            let bytes = if mode == "memory" {
                assert!(!Path::new(&path).exists(), "a download must not create a disk file");
                std::mem::take(&mut *captured.lock().unwrap())
            } else {
                std::fs::read(&path).unwrap()
            };
            assert_eq!(report.frames, 6);
            assert_eq!(report.bytes, bytes.len() as u64);
            let boxes = top_level_boxes(&bytes);
            assert_eq!(boxes[0].0, *b"ftyp");
            let moov = boxes.iter().find(|b| b.0 == *b"moov").unwrap();
            let mdat = boxes.iter().find(|b| b.0 == *b"mdat").unwrap();
            assert_eq!(moov.1 < mdat.1, multiplexer == Multiplexer::Mp4, "{mode}.{ext}");
            let file = filmcraft_isobmff::open(bytes.as_slice()).unwrap();
            assert_eq!(file.tracks.len(), 2);
            let video = file.track_of_kind(filmcraft_isobmff::TrackKind::Video).unwrap();
            assert_eq!(file.tracks[video].samples.len(), 6);
            for (track, t) in file.tracks.iter().enumerate() {
                for (index, sample) in t.samples.iter().enumerate() {
                    assert!(sample.offset >= mdat.1 as u64 + 8);
                    assert!(sample.offset + u64::from(sample.size) <= mdat.2 as u64);
                    assert_eq!(file.read_sample(bytes.as_slice(), track, index).unwrap().len(), sample.size as usize);
                }
            }
            let src = filmcraft_codecs::open_bytes(&path, bytes.into()).unwrap();
            for frame in [0, 3, 5] {
                let rgba = src.video_frame(FrameRequest::full(FrameRate::FPS_24.tick_of(frame))).unwrap().to_rgba8();
                assert!(rgba[0] > 230 && rgba[1] < 30 && rgba[2] < 30, "{mode}.{ext}: frame {frame}");
            }
            let audio = src.audio(0, 12_000, 48_000).unwrap();
            assert_eq!(audio.channels.len(), 2);
            assert!(audio.channels.iter().all(|c| c.len() == 12_000 && c.iter().any(|v| v.abs() > 0.1)), "{mode}.{ext}: audible tone");
            // A -6 dB sine has RMS near 0.35; allow for AAC loss and boundary transients.
            let level = rms(&audio.channels);
            assert!((0.2..0.5).contains(&level), "{mode}.{ext}: decoded tone RMS {level}");
        }
    }
}

#[test]
fn mp4_faststart_reports_unreadable_reserved_output() {
    let (p, seq, m) = matte([1.0, 0.0, 0.0, 1.0], 64, 36, None);
    let dir = Scratch::new("mp4-faststart-write-only");
    let path = dir.path("write-only.mp4");
    let settings = ExportSettings {
        format: Format::H264,
        path: path.clone(),
        include_audio: false,
        range: Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(1))),
        output_file: Some(Arc::new(std::fs::OpenOptions::new().write(true).create_new(true).open(&path).unwrap())),
        ..Default::default()
    };
    let progress = Progress::default();
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| export(&p, seq, &settings, &m, &progress)));
    assert!(matches!(result.unwrap(), Err(ExportError::Io(_))));
    assert!(!progress.finished.load(std::sync::atomic::Ordering::Relaxed));
}

#[test]
fn image_sequences_are_numbered_like_premiere() {
    let (p, seq, m) = matte([1.0, 0.0, 0.0, 1.0], 320, 180, None);
    for (fmt, ext) in [(Format::PngSequence, "png"), (Format::TiffSequence, "tif"), (Format::BmpSequence, "bmp")] {
        let dir = Scratch::new(&format!("seq-{ext}"));
        let mut s = ExportSettings { format: fmt, path: dir.path(&format!("Shot 01.{ext}")), scale: 0.5, ..Default::default() };
        s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(12)));
        let prog = Progress::default();
        let r = export(&p, seq, &s, &m, &prog).unwrap();
        assert_eq!(r.frames, 12);
        assert_eq!(prog.done.load(Ordering::Relaxed), 12);
        let want: Vec<String> = (0..12).map(|i| format!("Shot 01{i:03}.{ext}")).collect();
        assert_eq!(files_in(&dir.0), want, "{fmt:?}");
        let img = image::open(dir.0.join(&want[5])).unwrap().to_rgb8();
        assert_eq!((img.width(), img.height()), (160, 90));
        let px = img.get_pixel(80, 45).0;
        assert!(px[0] > 240 && px[1] < 15, "{fmt:?} {px:?}");
    }
}

/// JPEG, Targa and DPX sequences (#779): numbered like the others, JPEG at the export quality,
/// Targa with alpha when asked; every still decoded by ffmpeg (external test oracle).
#[test]
fn jpeg_targa_and_dpx_sequences() {
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 0.5], 64, 36, None);
    let mut jpeg_sizes = Vec::new();
    for (fmt, ext, alpha, quality) in [
        (Format::JpegSequence, "jpg", false, 95),
        (Format::JpegSequence, "jpg", false, 20),
        (Format::TgaSequence, "tga", false, 90),
        (Format::TgaSequence, "tga", true, 90),
        (Format::DpxSequence, "dpx", false, 90),
    ] {
        let dir = Scratch::new(&format!("seq3-{ext}-{alpha}-{quality}"));
        let mut s = ExportSettings { format: fmt, path: dir.path(&format!("Shot.{ext}")), alpha, quality, ..Default::default() };
        s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(3)));
        assert_eq!(Format::from_name(fmt.id()), Some(fmt));
        assert!(fmt.is_image_sequence() && s.is_image_sequence() && !s.has_audio());
        let r = export(&p, seq, &s, &m, &Progress::default()).unwrap();
        assert_eq!(r.frames, 3);
        let want: Vec<String> = (0..3).map(|i| format!("Shot{i:03}.{ext}")).collect();
        assert_eq!(files_in(&dir.0), want, "{fmt:?}");
        let first = dir.0.join(&want[0]);
        let bytes = std::fs::read(&first).unwrap();
        match fmt {
            Format::JpegSequence => {
                let px = image::load_from_memory(&bytes).unwrap().to_rgb8().get_pixel(32, 18).0;
                assert!(px[2] > 100 && px[0] < 20, "{px:?}");
                jpeg_sizes.push(bytes.len());
            }
            Format::DpxSequence => assert_eq!(bytes.len(), 2048 + 64 * 36 * 4),
            _ => assert_eq!(bytes.len(), 18 + 64 * 36 * if alpha { 4 } else { 3 } + 26),
        }
        let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("jpeg / targa / dpx sequences") else { continue };
        let first = first.to_string_lossy().to_string();
        let out = std::process::Command::new(ffmpeg).args(["-v", "error", "-i", &first, "-f", "rawvideo", "-pix_fmt", "rgba", "-"]).output().unwrap();
        assert!(out.status.success(), "{first}: {}", String::from_utf8_lossy(&out.stderr));
        assert_eq!(out.stdout.len(), 64 * 36 * 4, "{first}");
        let at = (18 * 64 + 32) * 4;
        let px = &out.stdout[at..at + 4];
        if alpha {
            assert!((100..=160).contains(&px[3]) && px[2] > 200 && px[0] < 15, "{first} straight alpha: {px:?}");
        } else {
            assert!(px[3] == 255 && px[2] > 100 && px[2] < 240 && px[0] < 20, "{first} flattened over black: {px:?}");
        }
        // the top-left pixel is the top row (Targa is stored bottom-up), and all of it is blue
        assert!(out.stdout.as_chunks::<4>().0.iter().all(|p| p[2] > 100 && p[0] < 20), "{first}");
        // FilmCraft's own import (craft-dpx, and the Targa reader) reads the frame as ffmpeg does
        if matches!(fmt, Format::TgaSequence | Format::DpxSequence) {
            let ours = filmcraft_media::still::decode_raster(&first, &bytes).unwrap();
            assert_eq!((ours.width, ours.height), (64, 36), "{first}");
            assert_eq!(ours.rgba.len(), out.stdout.len(), "{first}: import and ffmpeg frame sizes differ");
            let worst = ours.rgba.iter().zip(&out.stdout).map(|(&a, &b)| a.abs_diff(b)).max().unwrap_or(0);
            assert!(worst <= 1, "{first}: import differs from ffmpeg by {worst}");
        }
    }
    assert!(jpeg_sizes[0] > jpeg_sizes[1], "quality 95 must be larger than quality 20: {jpeg_sizes:?}");
}

/// OpenEXR sequences (#806): numbered like the others, half-float linear light, RGBA with
/// premultiplied alpha when asked; ffprobe / ffmpeg (external test oracles) read every still.
#[test]
fn openexr_sequences() {
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 0.5], 64, 36, None);
    for alpha in [false, true] {
        let dir = Scratch::new(&format!("seq-exr-{alpha}"));
        let mut s = ExportSettings { format: Format::ExrSequence, path: dir.path("Shot.exr"), alpha, ..Default::default() };
        s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(3)));
        assert_eq!(Format::from_name("OpenEXR"), Some(Format::ExrSequence));
        assert!(s.is_image_sequence() && s.supports_alpha() && s.keeps_alpha() == alpha && !s.has_audio());
        let r = export(&p, seq, &s, &m, &Progress::default()).unwrap();
        assert_eq!(r.frames, 3);
        let want: Vec<String> = (0..3).map(|i| format!("Shot{i:03}.exr")).collect();
        assert_eq!(files_in(&dir.0), want);
        let first = dir.0.join(&want[0]);
        let bytes = std::fs::read(&first).unwrap();
        assert_eq!(&bytes[..4], &[0x76, 0x2F, 0x31, 0x01]);
        let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("OpenEXR sequences") else { continue };
        let out = std::process::Command::new(ffmpeg)
            .args(["-v", "error", "-i"])
            .arg(&first)
            .args(["-f", "rawvideo", "-pix_fmt", "gbrapf32le", "-"])
            .output()
            .unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        let n = 64 * 36;
        assert_eq!(out.stdout.len(), n * 16);
        let plane = |p: usize| -> Vec<f32> { out.stdout[p * n * 4..(p + 1) * n * 4].as_chunks::<4>().0.iter().map(|b| f32::from_le_bytes(*b)).collect() };
        let (g, b, r, a) = (plane(0), plane(1), plane(2), plane(3));
        for i in 0..n {
            assert!(g[i].abs() < 1e-3 && r[i].abs() < 1e-3, "pixel {i}: no red or green");
            if alpha {
                // pure blue (linear 1.0) at 50 % opacity, premultiplied
                assert!((a[i] - 0.5).abs() < 0.01 && (b[i] - a[i]).abs() < 2e-3, "pixel {i}: {} / {}", b[i], a[i]);
            } else {
                // flattened over black, then linearised: well below the encoded half level
                assert!(a[i] == 1.0 && b[i] > 0.1 && b[i] < 0.5, "pixel {i}: {} / {}", b[i], a[i]);
            }
        }
    }
}

/// Compressed OpenEXR sequences (#874): the export setting reaches every still, which shrinks
/// and (ffmpeg as the external oracle) decodes to the same pixels as the uncompressed file.
#[test]
fn openexr_sequences_compress() {
    let (p, seq, m) = matte([0.2, 0.6, 1.0, 0.5], 64, 36, None);
    let mut files = Vec::new();
    for c in ExrCompression::ALL {
        let dir = Scratch::new(&format!("seq-exr-{c:?}"));
        let mut s = ExportSettings { format: Format::ExrSequence, path: dir.path("c.exr"), alpha: true, exr_compression: c, ..Default::default() };
        s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(1)));
        export(&p, seq, &s, &m, &Progress::default()).unwrap();
        let path = dir.0.join("c000.exr");
        let bytes = std::fs::read(&path).unwrap();
        let at = bytes.windows(24).position(|w| w == b"compression\0compression\0").unwrap() + 28;
        assert_eq!(bytes[at], [0, 1, 2, 3][files.len()], "{c:?}");
        files.push((c, path, bytes.len(), dir));
    }
    let plain = files[0].2;
    for (c, _, len, _) in &files[1..] {
        assert!(*len < plain / 2, "{c:?}: {len} bytes vs {plain} uncompressed");
    }
    let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("compressed OpenEXR sequences") else { return };
    let decode = |path: &Path| {
        let out =
            std::process::Command::new(&ffmpeg).args(["-v", "error", "-i"]).arg(path).args(["-f", "rawvideo", "-pix_fmt", "gbrapf32le", "-"]).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        out.stdout
    };
    let want = decode(&files[0].1);
    assert_eq!(want.len(), 64 * 36 * 16);
    for (c, path, _, _) in &files[1..] {
        assert!(decode(path) == want, "{c:?} decodes differently");
    }
}

/// `alpha` keeps straight alpha in PNG and TIFF sequences; off (the default) flattens over black (#160)
/// and writes RGB files without an alpha channel (#1863).
#[test]
fn image_sequences_keep_alpha_when_asked() {
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 0.5], 64, 36, None);
    for (fmt, ext) in [(Format::PngSequence, "png"), (Format::TiffSequence, "tif")] {
        for alpha in [false, true] {
            let dir = Scratch::new(&format!("alpha-{ext}-{alpha}"));
            let mut s = ExportSettings { format: fmt, path: dir.path(&format!("a.{ext}")), alpha, ..Default::default() };
            s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2)));
            export(&p, seq, &s, &m, &Progress::default()).unwrap();
            let file = dir.0.join(format!("a000.{ext}"));
            if fmt == Format::PngSequence {
                let colour_type = std::fs::read(&file).unwrap()[25];
                assert_eq!(colour_type, if alpha { 6 } else { 2 }, "PNG colour type, alpha={alpha}");
            }
            let img = image::open(&file).unwrap();
            let px = img.to_rgba8().get_pixel(32, 18).0;
            assert_eq!(img.color().has_alpha(), alpha, "{fmt:?} alpha channel written, alpha={alpha}");
            if alpha {
                assert!((100..=160).contains(&px[3]) && px[2] > 200 && px[0] < 15, "{fmt:?} straight alpha: {px:?}");
            } else {
                assert!(px[3] == 255 && px[2] > 100 && px[2] < 240 && px[0] < 15, "{fmt:?} flattened over black: {px:?}");
            }
        }
    }
    // the PNG size estimate counts the channels actually written, as TIFF's does
    let rate = FrameRate::FPS_24;
    let png = |alpha| ExportSettings { format: Format::PngSequence, alpha, ..Default::default() }.estimate_bytes(320, 180, rate, 48_000, rate.tick_of(1));
    assert_eq!(png(false) * 4, png(true) * 3, "PNG estimate: {} RGB vs {} RGBA", png(false), png(true));
}

/// Four blue stripes with alpha 0, 127, 128 and 255. Reverse them on frame two, then
/// clear the whole picture: a decoder must not retain opaque pixels from earlier frames.
struct GifAlphaSource(filmcraft_media::SharedSource);

impl MediaSource for GifAlphaSource {
    fn info(&self) -> &filmcraft_media::MediaInfo {
        self.0.info()
    }

    fn video_frame(&self, req: FrameRequest) -> filmcraft_media::Result<Arc<filmcraft_frame::VideoFrame>> {
        let frame = FrameRate::FPS_24.frame_at(req.time);
        let mut rgba = Vec::with_capacity(64 * 36 * 4);
        for _ in 0..36 {
            for x in 0..64 {
                let stripe = if frame == 1 { 3 - x / 16 } else { x / 16 };
                let alpha = if frame >= 2 { 0 } else { [0, 127, 128, 255][stripe] };
                rgba.extend_from_slice(&[0, 0, 255, alpha]);
            }
        }
        Ok(Arc::new(filmcraft_frame::VideoFrame::rgba8(64, 36, rgba)))
    }

    fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> filmcraft_media::Result<filmcraft_frame::AudioBuffer> {
        self.0.audio(start, frames, sample_rate)
    }
}

#[test]
fn gif_alpha_threshold_and_disposal_roundtrip() {
    use image::AnimationDecoder;
    let (p, seq, mut sources) = matte([0.0, 0.0, 1.0, 1.0], 64, 36, None);
    for source in sources.0.values_mut() {
        *source = Arc::new(GifAlphaSource(source.clone()));
    }
    for alpha in [false, true] {
        let dir = Scratch::new(&format!("gif-alpha-{alpha}"));
        let settings = ExportSettings {
            format: Format::Gif,
            path: dir.path("alpha.gif"),
            alpha,
            range: Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(3))),
            ..Default::default()
        };
        let result = export(&p, seq, &settings, &sources, &Progress::default()).unwrap();
        assert_eq!(result.frames, 3);
        let bytes = std::fs::read(&settings.path).unwrap();
        let decoder = image::codecs::gif::GifDecoder::new(std::io::Cursor::new(bytes)).unwrap();
        let frames = decoder.into_frames().collect_frames().unwrap();
        assert_eq!(frames.len(), 3);
        for (i, frame) in frames.iter().enumerate() {
            assert_eq!(frame.buffer().dimensions(), (64, 36));
            assert_eq!(frame.delay().numer_denom_ms(), (u32::from(gif_delay_cs(FrameRate::FPS_24, i as i64)) * 10, 1));
            for stripe in 0..4 {
                let source_alpha = if i == 2 { 0 } else { [0, 127, 128, 255][if i == 1 { 3 - stripe } else { stripe }] };
                let px = frame.buffer().get_pixel(stripe as u32 * 16 + 8, 18).0;
                let expected_alpha = if alpha && source_alpha < 128 { 0 } else { 255 };
                assert_eq!(px[3], expected_alpha, "alpha={alpha}, frame={i}, stripe={stripe}: {px:?}");
                if expected_alpha != 0 {
                    assert!(px[0] < 15 && px[1] < 15, "blue: {px:?}");
                    if source_alpha == 0 {
                        assert!(px[2] < 15, "flattened transparent pixel: {px:?}");
                    } else if alpha || source_alpha == 255 {
                        assert!(px[2] > 240, "straight blue survives palette quantization: {px:?}");
                    } else {
                        assert!((100..240).contains(&px[2]), "partial alpha flattened over black: {px:?}");
                    }
                }
            }
        }
        if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("GIF transparency") {
            let decoded = std::process::Command::new(ffmpeg)
                .args(["-v", "error", "-i", &settings.path, "-frames:v", "3", "-fps_mode", "passthrough", "-f", "rawvideo", "-pix_fmt", "rgba", "-"])
                .output()
                .unwrap();
            assert!(decoded.status.success(), "{}", String::from_utf8_lossy(&decoded.stderr));
            assert_eq!(decoded.stdout.len(), 3 * 64 * 36 * 4);
            for (actual, expected) in decoded.stdout.as_chunks::<{ 64 * 36 * 4 }>().0.iter().zip(&frames) {
                for (actual, expected) in actual.as_chunks::<4>().0.iter().zip(expected.buffer().pixels()) {
                    assert_eq!(actual[3], expected.0[3], "ffmpeg alpha, alpha={alpha}");
                    if actual[3] == 255 {
                        assert_eq!(*actual, expected.0, "ffmpeg opaque color, alpha={alpha}");
                    }
                }
            }
        }
    }
}

/// A full grayscale ramp, repeated four times, with one transparent pixel surrounded by
/// opaque black / near-black pixels. Moving the hole also exercises animated frame disposal.
struct GifPaletteSource(filmcraft_media::SharedSource);

impl MediaSource for GifPaletteSource {
    fn info(&self) -> &filmcraft_media::MediaInfo {
        self.0.info()
    }

    fn video_frame(&self, req: FrameRequest) -> filmcraft_media::Result<Arc<filmcraft_frame::VideoFrame>> {
        let second = FrameRate::FPS_24.frame_at(req.time) != 0;
        let hole = if second { (17, 17) } else { (16, 16) };
        let mut rgba = Vec::with_capacity(32 * 32 * 4);
        for y in 0..32 {
            for x in 0..32 {
                let shade = ((y * 32 + x) % 256) as u8;
                let shade = if second { 255 - shade } else { shade };
                let px = if (x, y) == hole {
                    [0, 0, 0, 0]
                } else if (x, y) == (hole.0 - 1, hole.1) || (x, y) == (hole.0 + 1, hole.1) {
                    [0, 0, 0, 255]
                } else if (x, y) == (hole.0, hole.1 - 1) || (x, y) == (hole.0, hole.1 + 1) {
                    [1, 2, 3, 255]
                } else {
                    [shade, shade, shade, 255]
                };
                rgba.extend_from_slice(&px);
            }
        }
        Ok(Arc::new(filmcraft_frame::VideoFrame::rgba8(32, 32, rgba)))
    }

    fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> filmcraft_media::Result<filmcraft_frame::AudioBuffer> {
        self.0.audio(start, frames, sample_rate)
    }
}

#[test]
fn gif_palette_quantization_preserves_isolated_transparency_and_dark_pixels() {
    use image::AnimationDecoder;
    let (p, seq, mut sources) = matte([0.0, 0.0, 0.0, 1.0], 32, 32, None);
    for source in sources.0.values_mut() {
        *source = Arc::new(GifPaletteSource(source.clone()));
    }
    let dir = Scratch::new("gif-palette-alpha");
    let settings = ExportSettings {
        format: Format::Gif,
        path: dir.path("palette.gif"),
        alpha: true,
        range: Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2))),
        ..Default::default()
    };
    // Count the actual rendered colors after binary-alpha conversion, not just source colors:
    // exceeding GIF's 256-entry palette must survive the render pipeline on both frames.
    let pipe = pipeline::Pipeline::new(p.clone(), seq, &settings, false).unwrap();
    let expected: Vec<Vec<[u8; 4]>> = (0..2)
        .map(|i| {
            let rgba = pipe.frame(i, &sources).0;
            let pixels: Vec<_> = rgba.as_chunks::<4>().0.iter().map(|&[r, g, b, a]| if a < 128 { [0; 4] } else { [r, g, b, 255] }).collect();
            let colors: std::collections::HashSet<_> = pixels.iter().copied().collect();
            assert!(colors.len() >= 257, "frame {i}: only {} post-conversion colors", colors.len());
            assert_eq!(pixels.iter().filter(|p| p[3] == 0).count(), 1, "frame {i}: an isolated transparent pixel");
            assert!(colors.contains(&[0, 0, 0, 255]), "frame {i}: opaque black");
            assert!(colors.contains(&[1, 2, 3, 255]), "frame {i}: opaque near-black");
            pixels
        })
        .collect();
    assert_eq!(export(&p, seq, &settings, &sources, &Progress::default()).unwrap().frames, 2);
    let bytes = std::fs::read(&settings.path).unwrap();
    let frames = image::codecs::gif::GifDecoder::new(std::io::Cursor::new(bytes)).unwrap().into_frames().collect_frames().unwrap();
    assert_eq!(frames.len(), 2);
    for (i, (frame, expected)) in frames.iter().zip(&expected).enumerate() {
        assert_eq!(frame.buffer().dimensions(), (32, 32));
        for (at, (actual, expected)) in frame.buffer().pixels().zip(expected).enumerate() {
            assert_eq!(actual[3], expected[3], "frame {i}, pixel {at}: alpha must be exact, including opaque dark pixels");
            if expected[3] == 255 {
                // Palette reduction is lossy. For this grayscale ramp, allow at most 16/255
                // error per RGB channel (about 6% of the range), never any loss of opacity.
                for channel in 0..3 {
                    assert!(actual[channel].abs_diff(expected[channel]) <= 16, "frame {i}, pixel {at}: {:?} vs {expected:?}", actual.0);
                }
            }
        }
    }
}

/// Thumbnails (`encode_png`) and an 8-bit PNG Export Frame keep the alpha they are given: only the
/// sequence's `alpha` switch drops it (#1863).
#[test]
fn png_stills_keep_their_alpha_channel() {
    let half = filmcraft_render::Image::filled(4, 2, [0.0, 0.0, 0.5, 0.5]);
    let thumb = encode_png(half.to_rgba8(), 4, 2).unwrap();
    assert_eq!(thumb[25], 6, "encode_png colour type");
    let frame = still::encode(&half, still::StillFormat::Png, 8).unwrap();
    assert_eq!(frame[25], 6, "Export Frame PNG colour type");
}

#[test]
fn wav_and_aiff_audio_only() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("audio");
    // WAV, 24-bit mono at 44.1 kHz
    let wav = dir.path("a.wav");
    let mut s = ExportSettings { format: Format::Wav, path: wav.clone(), ..Default::default() };
    s.audio = AudioSettings { sample_rate: Some(44_100), channels: 1, bits: 24, ..Default::default() };
    s.range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 2)));
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let b = std::fs::read(&wav).unwrap();
    assert_eq!(u16::from_le_bytes([b[22], b[23]]), 1, "mono");
    assert_eq!(u32::from_le_bytes(b[24..28].try_into().unwrap()), 44_100);
    assert_eq!(u16::from_le_bytes([b[34], b[35]]), 24);
    assert_eq!(u32::from_le_bytes(b[40..44].try_into().unwrap()), 22_050 * 3, "0.5 s of 24-bit mono");
    // AIFF, 16-bit stereo at the sequence rate
    let aif = dir.path("a.aif");
    let mut s = ExportSettings { format: Format::Aiff, path: aif.clone(), ..Default::default() };
    s.range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 2)));
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let b = std::fs::read(&aif).unwrap();
    assert_eq!(&b[..4], b"FORM");
    assert_eq!(&b[8..12], b"AIFF");
    assert_eq!(u16::from_be_bytes([b[20], b[21]]), 2);
    assert_eq!(u32::from_be_bytes(b[22..26].try_into().unwrap()), 24_000);
    if let Some(j) = ffprobe_json(&["-show_streams"], &aif) {
        let st = &j["streams"][0];
        assert_eq!(st["codec_name"], "pcm_s16be");
        assert_eq!(st["sample_rate"], "48000");
        assert_eq!(st["channels"], 2);
    }
    if let Some(j) = ffprobe_json(&["-show_streams"], &wav) {
        assert_eq!(j["streams"][0]["codec_name"], "pcm_s24le");
    }
}

/// Root-mean-square level of decoded planar audio.
fn rms(planes: &[Vec<f32>]) -> f32 {
    let n = planes.iter().map(Vec::len).sum::<usize>().max(1);
    (planes.iter().flatten().map(|s| s * s).sum::<f32>() / n as f32).sqrt()
}

#[test]
fn aac_audio_writes_m4a_and_adts() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("aac-audio");
    let range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND)));
    let m4a = dir.path("a.m4a");
    write_and_check_m4a_aac(&p, seq, &m, &m4a, range);

    let adts = dir.path("a.aac");
    write_and_check_adts_aac(&p, seq, &m, &adts, range);
    if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("AAC Audio decode") {
        for path in [&m4a, &adts] {
            let out = std::process::Command::new(&ffmpeg).args(["-v", "error", "-xerror", "-i", path, "-f", "null", "-"]).output().unwrap();
            assert!(out.status.success() && out.stderr.is_empty(), "{path}: {}", String::from_utf8_lossy(&out.stderr));
        }
    }
}

fn write_and_check_m4a_aac(p: &Arc<Project>, seq: ItemId, sources: &SourceMap, path: &str, range: Option<TimeRange>) {
    let settings = ExportSettings { format: Format::Aac, path: path.to_owned(), range, ..Default::default() };
    assert!(!settings.has_video());
    assert_eq!(settings.audio_codec(), AudioCodec::Aac);
    assert_eq!(settings.extension(), "m4a");
    let report = export(p, seq, &settings, sources, &Progress::default()).unwrap();
    assert_eq!(report.frames, 48_000, "one second of samples");
    let bytes = std::fs::read(path).unwrap();
    let file = filmcraft_isobmff::open(bytes.clone()).unwrap();
    assert_eq!(file.tracks.len(), 1, "audio only");
    let t = &file.tracks[0];
    let filmcraft_isobmff::CodecConfig::Aac(cfg) = &t.entries[0].codec else { panic!("not AAC: {:?}", t.entries[0].codec) };
    assert_eq!((cfg.object_type, cfg.sample_rate, cfg.channel_config), (2, 48_000, 2));
    assert!(t.samples.len() >= 48_000 / 1024, "{} access units", t.samples.len());
    let mut dec = craft_audio::aac::Decoder::new(&cfg.asc).unwrap();
    let mut pcm: Vec<Vec<f32>> = Vec::new();
    for i in 0..t.samples.len() {
        let out = dec.decode(&file.read_sample(&bytes, 0, i).unwrap()).unwrap();
        pcm.resize(out.len(), Vec::new());
        pcm.iter_mut().zip(out).for_each(|(a, b)| a.extend(b));
    }
    // the -6 dBFS tone (RMS about 0.35) survives the round trip
    assert!((0.2..0.5).contains(&rms(&pcm)), "rms {}", rms(&pcm));
    if let Some(j) = ffprobe_json(&["-show_streams", "-show_format"], path) {
        assert_eq!(j["streams"].as_array().unwrap().len(), 1);
        let st = &j["streams"][0];
        assert_eq!(st["codec_name"], "aac");
        assert_eq!(st["sample_rate"], "48000");
        assert_eq!(st["channels"], 2);
        let d: f64 = j["format"]["duration"].as_str().unwrap().parse().unwrap();
        assert!((d - 1.0).abs() < 0.03, "duration {d}");
    }
}

fn write_and_check_adts_aac(p: &Arc<Project>, seq: ItemId, sources: &SourceMap, path: &str, range: Option<TimeRange>) {
    let mut settings = ExportSettings { format: Format::Aac, path: path.to_owned(), range, ..Default::default() };
    settings.audio = AudioSettings { sample_rate: Some(44_100), channels: 1, bitrate_kbps: 128, ..Default::default() };
    export(p, seq, &settings, sources, &Progress::default()).unwrap();
    let b = std::fs::read(path).unwrap();
    // AAC-LC 44.1 kHz (index 4) mono: 00010 0100 0001 000
    let mut dec = craft_audio::aac::Decoder::new(&[0x12, 0x08]).unwrap();
    let (mut pos, mut units, mut pcm) = (0usize, 0usize, vec![Vec::new()]);
    while pos < b.len() {
        let h = &b[pos..pos + 7];
        assert_eq!((h[0], h[1] & 0xF6), (0xFF, 0xF0), "ADTS sync at {pos}");
        assert_eq!(h[1] & 0x01, 1, "no CRC");
        assert_eq!(((h[2] >> 2) & 0x0F, ((h[2] & 1) << 2) | (h[3] >> 6)), (4, 1), "44.1 kHz mono");
        let len = ((h[3] as usize & 0x03) << 11) | ((h[4] as usize) << 3) | (h[5] as usize >> 5);
        assert!(len > 7 && pos + len <= b.len(), "frame length {len} at {pos}");
        pcm[0].extend(dec.decode(&b[pos + 7..pos + len]).unwrap().swap_remove(0));
        pos += len;
        units += 1;
    }
    assert!(units >= 44_100 / 1024, "{units} frames");
    assert!((0.2..0.5).contains(&rms(&pcm)), "rms {}", rms(&pcm));
    if let Some(j) = ffprobe_json(&["-show_streams", "-show_format"], path) {
        assert_eq!(j["format"]["format_name"], "aac");
        let st = &j["streams"][0];
        assert_eq!(st["codec_name"], "aac");
        assert_eq!(st["sample_rate"], "44100");
        assert_eq!(st["channels"], 1);
    }
}

#[test]
fn aac_audio_settings_and_names() {
    assert_eq!(Format::from_name("m4a"), Some(Format::Aac));
    assert_eq!(Format::from_name("AAC Audio"), Some(Format::Aac));
    assert_eq!(Format::from_name(Format::Aac.id()), Some(Format::Aac));
    assert!(Format::ALL.contains(&Format::Aac) && Format::Aac.is_audio_only() && !Format::H264.is_audio_only());
    let s = ExportSettings { format: Format::Aac, include_audio: false, ..Default::default() };
    let sum = s.summary(1920, 1080, FrameRate::FPS_24, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert_eq!(sum.video, "No video");
    assert_eq!(sum.audio, "AAC, 320 kbps, 48000 Hz, Stereo");
    assert_eq!(sum.estimated_bytes, 400_000, "320 kbps for 10 s, no picture");
    let preset = presets::find_builtin("AAC Audio 48 kHz 320 kbps").unwrap();
    assert_eq!(preset.settings.format, Format::Aac);
}

/// Decode the first second of an MP3 export with the media pool's decoder: (sample rate, planar
/// samples).
fn decode_mp3(path: &str) -> (u32, Vec<Vec<f32>>) {
    let bytes: Arc<[u8]> = std::fs::read(path).unwrap().into();
    let src = filmcraft_codecs::AudioFileSource::decode(path, bytes).unwrap();
    let info = src.info().audio_streams[0].clone();
    // the exported second, past the encoder delay
    let buf = src.audio(i64::from(craft_audio::mp3::DELAY), info.sample_rate as usize, info.sample_rate).unwrap();
    assert_eq!(buf.channels.len(), info.channels as usize);
    (info.sample_rate, buf.channels)
}

#[test]
fn mp3_export_writes_layer_iii_frames() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("mp3-audio");
    let range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND)));
    let path = dir.path("a.mp3");
    let s = ExportSettings { format: Format::Mp3, path: path.clone(), range, ..Default::default() };
    assert!(!s.has_video());
    assert_eq!((s.audio_codec(), s.extension()), (AudioCodec::Mp3, "mp3"));
    let r = export(&p, seq, &s, &m, &Progress::default()).unwrap();
    assert_eq!(r.frames, 48_000, "one second of samples");
    let b = std::fs::read(&path).unwrap();
    // MPEG-1 Layer III, no CRC, 320 kbit/s (index 14), 48 kHz (index 1), joint stereo
    assert_eq!((b[0], b[1], b[2] >> 4, (b[2] >> 2) & 3, b[3] >> 6), (0xFF, 0xFB, 14, 1, 1));
    // whole 960-byte frames covering the second and the encoder delay
    assert_eq!(b.len(), 960 * (48_000 + craft_audio::mp3::DELAY as usize).div_ceil(1152));
    let (rate, pcm) = decode_mp3(&path);
    assert_eq!((rate, pcm.len()), (48_000, 2));
    // the -6 dBFS tone (RMS about 0.35) survives the round trip
    assert!((0.2..0.5).contains(&rms(&pcm)), "rms {}", rms(&pcm));

    // what MP3 cannot carry maps onto what it can: 96 kHz 5.1 at 1000 kbps becomes 48 kHz stereo
    // at 320 kbps; mono 22.05 kHz at 64 kbps is MPEG-2
    let wide = dir.path("wide.mp3");
    let mut s = ExportSettings { format: Format::Mp3, path: wide.clone(), range, ..Default::default() };
    s.audio = AudioSettings { sample_rate: Some(96_000), channels: 6, bitrate_kbps: 1000, ..Default::default() };
    assert_eq!(s.mp3_stream(48_000), (48_000, 2, 320));
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    assert_eq!(decode_mp3(&wide).1.len(), 2);
    let lsf = dir.path("lsf.mp3");
    let mut s = ExportSettings { format: Format::Mp3, path: lsf.clone(), range, ..Default::default() };
    s.audio = AudioSettings { sample_rate: Some(22_050), channels: 1, bitrate_kbps: 64, ..Default::default() };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let b = std::fs::read(&lsf).unwrap();
    assert_eq!((b[1] >> 3) & 3, 2, "MPEG-2");
    let (rate, pcm) = decode_mp3(&lsf);
    assert_eq!((rate, pcm.len()), (22_050, 1));
    assert!((0.2..0.5).contains(&rms(&pcm)), "rms {}", rms(&pcm));
    if let Some(j) = ffprobe_json(&["-show_streams", "-show_format"], &path) {
        assert_eq!(j["format"]["format_name"], "mp3");
        let st = &j["streams"][0];
        assert_eq!((st["codec_name"].as_str(), st["sample_rate"].as_str(), st["channels"].as_u64()), (Some("mp3"), Some("48000"), Some(2)));
    }
    if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("MP3 decode") {
        for f in [&path, &wide, &lsf] {
            let out = std::process::Command::new(&ffmpeg).args(["-v", "error", "-xerror", "-i", f, "-f", "null", "-"]).output().unwrap();
            assert!(out.status.success() && out.stderr.is_empty(), "{f}: {}", String::from_utf8_lossy(&out.stderr));
        }
    }
}

#[test]
fn mp3_settings_and_names() {
    assert_eq!(Format::from_name("MP3"), Some(Format::Mp3));
    assert_eq!(Format::from_name(Format::Mp3.id()), Some(Format::Mp3));
    assert!(Format::ALL.contains(&Format::Mp3) && Format::Mp3.is_audio_only());
    let s = ExportSettings { format: Format::Mp3, ..Default::default() };
    let sum = s.summary(1920, 1080, FrameRate::FPS_24, 44_100, Tick(10 * TICKS_PER_SECOND));
    assert_eq!(sum.video, "No video");
    assert_eq!(sum.audio, "MP3, 320 kbps, 44100 Hz, Stereo");
    assert_eq!(sum.estimated_bytes, 400_000, "320 kbps for 10 s");
    // the bit rate snaps to a Layer III one, the codec setting cannot leak into other formats
    let mut s = ExportSettings { format: Format::Mp3, ..Default::default() };
    s.audio.bitrate_kbps = 300;
    s.audio.sample_rate = Some(16_000);
    assert_eq!(s.summary(1920, 1080, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)).audio, "MP3, 160 kbps, 16000 Hz, Stereo");
    let mut mov = ExportSettings { format: Format::ProRes, ..Default::default() };
    mov.audio.codec = AudioCodec::Mp3;
    assert_eq!(mov.audio_codec(), AudioCodec::Pcm);
    let preset = presets::find_builtin("MP3 48 kHz 320 kbps").unwrap();
    assert_eq!((preset.settings.format, preset.settings.audio.bitrate_kbps), (Format::Mp3, 320));
    assert_eq!(serde_json::to_value(Format::Mp3).unwrap(), "mp3");
}

#[test]
fn wav_export_honours_explicit_sample_rates() {
    let (project, sequence, sources) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("wav-sample-rates");
    for rate in [1, 4000, 7350, 8000, 48_000, 192_000, 192_001, 200_000, 352_800, 384_000] {
        let settings = ExportSettings {
            format: Format::Wav,
            path: dir.path(&format!("{rate}.wav")),
            audio: AudioSettings { sample_rate: Some(rate), ..Default::default() },
            range: Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 4))),
            ..Default::default()
        };
        settings.validate().unwrap();
        let resolved = settings.resolve(64, 36, FrameRate::FPS_24, 48_000);
        assert_eq!(resolved.sample_rate, rate, "requested {rate} Hz");
        export(&project, sequence, &settings, &sources, &Progress::default()).unwrap();
        let bytes = std::fs::read(&settings.path).unwrap();
        assert_eq!(u32::from_le_bytes(bytes[24..28].try_into().unwrap()), rate);
        assert_eq!(u32::from_le_bytes(bytes[40..44].try_into().unwrap()), rate / 4 * 4, "quarter-second stereo 16-bit PCM");
        if let Some(probe) = ffprobe_json(&["-show_streams"], &settings.path) {
            assert_eq!(probe["streams"][0]["sample_rate"], rate.to_string());
        }
    }
    let settings = ExportSettings { format: Format::Wav, ..Default::default() };
    assert_eq!(settings.resolve(64, 36, FrameRate::FPS_24, 44_100).sample_rate, 44_100);
}

#[test]
fn aac_export_rejects_unsupported_explicit_sample_rates() {
    let (project, sequence, sources) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("aac-sample-rates");
    for rate in [4000, 192_001, 200_000, 384_000] {
        let settings = ExportSettings {
            path: dir.path(&format!("{rate}.mp4")),
            audio: AudioSettings { sample_rate: Some(rate), ..Default::default() },
            range: Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 4))),
            ..Default::default()
        };
        let error = export(&project, sequence, &settings, &sources, &Progress::default()).unwrap_err();
        assert!(error.to_string().contains("sample rate"), "{error}");
        assert!(!Path::new(&settings.path).exists(), "an unsupported rate must not produce a substitute file");
    }
}

#[test]
fn flac_is_lossless_against_wav() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("flac");
    let range = Some(TimeRange::new(Tick::ZERO, Tick(3 * TICKS_PER_SECOND / 2)));
    let audio = AudioSettings { channels: 2, bits: 24, ..Default::default() };
    let (wav, flac) = (dir.path("a.wav"), dir.path("a.flac"));
    let w = ExportSettings { format: Format::Wav, path: wav.clone(), range, audio: audio.clone(), ..Default::default() };
    export(&p, seq, &w, &m, &Progress::default()).unwrap();
    let f = ExportSettings { format: Format::Flac, path: flac.clone(), range, audio, ..Default::default() };
    let prog = Progress::default();
    let r = export(&p, seq, &f, &m, &prog).unwrap();
    assert_eq!(r.frames, 72_000, "1.5 s at 48 kHz");
    // one progress step per second of audio
    assert_eq!((prog.total.load(Ordering::Relaxed), prog.done.load(Ordering::Relaxed)), (2, 2));
    let (wb, fb) = (std::fs::read(&wav).unwrap(), std::fs::read(&flac).unwrap());
    assert_eq!(&fb[..4], b"fLaC");
    assert!(fb.len() * 2 < wb.len(), "a tone compresses: FLAC {} bytes, WAV {}", fb.len(), wb.len());
    // STREAMINFO was filled in at the end: total samples
    let si = &fb[8..42];
    assert_eq!((u64::from(si[13] & 0x0F) << 32) | u64::from(u32::from_be_bytes(si[14..18].try_into().unwrap())), 72_000);

    // the same samples through FilmCraft's own readers
    let decode = |name: &str, bytes: Vec<u8>| filmcraft_codecs::open_bytes(name, bytes.into()).unwrap().audio(0, 72_000, 48_000).unwrap();
    let (a, b) = (decode("a.wav", wb), decode("a.flac", fb));
    assert_eq!(a.channels.len(), 2);
    for (ca, cb) in a.channels.iter().zip(&b.channels) {
        assert_eq!(ca.len(), cb.len());
        let worst = ca.iter().zip(cb).map(|(x, y)| (x - y).abs()).fold(0.0f32, f32::max);
        assert!(worst < 1e-6, "differs by {worst}");
        assert!(ca.iter().any(|v| v.abs() > 0.1), "the tone is there");
    }
    // and bit for bit through ffmpeg
    if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("flac export") {
        let raw = |path: &str| {
            let out = std::process::Command::new(&ffmpeg).args(["-v", "error", "-i", path, "-f", "s32le", "-c:a", "pcm_s32le", "-"]).output().unwrap();
            assert!(out.status.success() && out.stderr.is_empty(), "{}", String::from_utf8_lossy(&out.stderr));
            out.stdout
        };
        let (a, b) = (raw(&wav), raw(&flac));
        assert_eq!(a.len(), 72_000 * 2 * 4);
        assert!(a == b, "FLAC must decode to the WAV's samples exactly");
    }
    if let Some(j) = ffprobe_json(&["-show_streams"], &flac) {
        let st = &j["streams"][0];
        assert_eq!((st["codec_name"].as_str(), st["sample_rate"].as_str(), st["bits_per_raw_sample"].as_str()), (Some("flac"), Some("48000"), Some("24")));
    }
}

#[test]
fn flac_audio_in_mp4_and_mov() {
    let (p, seq, m) = matte([0.2, 0.4, 0.6, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("flac-in");
    // 1.5 s at 48 kHz: 17 full FLAC frames of 4096 samples and a last one of 2368
    let range = Some(TimeRange::new(Tick::ZERO, Tick(3 * TICKS_PER_SECOND / 2)));
    let audio = AudioSettings { codec: AudioCodec::Flac, bits: 24, ..Default::default() };
    let wav = dir.path("ref.wav");
    export(&p, seq, &ExportSettings { format: Format::Wav, path: wav.clone(), range, audio: audio.clone(), ..Default::default() }, &m, &Progress::default())
        .unwrap();
    for (format, mux, name) in
        [(Format::H264, Multiplexer::Mp4, "a.mp4"), (Format::H264, Multiplexer::Mov, "b.mov"), (Format::ProRes, Multiplexer::Mp4, "c.mov")]
    {
        let path = dir.path(name);
        let s = ExportSettings { format, multiplexer: mux, path: path.clone(), range, audio: audio.clone(), ..Default::default() };
        assert_eq!(s.audio_codec(), AudioCodec::Flac, "{name}");
        assert!(s.summary(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)).audio.starts_with("FLAC (lossless) 24-bit"), "{name}");
        export(&p, seq, &s, &m, &Progress::default()).unwrap();
        let bytes = std::fs::read(&path).unwrap();
        // `dfLa` was rewritten at the end: STREAMINFO with frame sizes, total samples and the MD5
        let at = bytes.windows(4).position(|w| w == b"dfLa").unwrap() + 4 + 4 + 4;
        let si = &bytes[at..at + 34];
        assert_eq!(bytes[at - 4], 0x80, "{name}: STREAMINFO is the last metadata block");
        assert!(si[4..10].iter().any(|&b| b != 0), "{name}: frame sizes");
        assert_eq!(u32::from_be_bytes(si[14..18].try_into().unwrap()), 72_000, "{name}: total samples");
        assert!(si[18..34].iter().any(|&b| b != 0), "{name}: MD5");
        // FilmCraft's own importer reads the FLAC track back, sample-accurately long
        let src = filmcraft_codecs::open_bytes(name, bytes.into()).unwrap();
        let a = src.audio(0, 72_000, 48_000).unwrap();
        assert!(a.channels.iter().all(|c| c.len() == 72_000) && a.channels[0].iter().any(|v| v.abs() > 0.1), "{name}");
        if let Some(j) = ffprobe_json(&["-show_streams", "-count_packets"], &path) {
            let st = j["streams"].as_array().unwrap().iter().find(|s| s["codec_type"] == "audio").unwrap().clone();
            assert_eq!((st["codec_name"].as_str(), st["sample_rate"].as_str(), st["channels"].as_u64()), (Some("flac"), Some("48000"), Some(2)), "{name}");
            assert_eq!(st["nb_read_packets"].as_str(), Some("18"), "{name}: one FLAC frame per packet");
            assert_eq!(st["duration_ts"].as_u64(), Some(72_000), "{name}: the short last frame is timed exactly");
        }
        // the audio decodes to the WAV export's samples bit for bit
        if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("flac in containers") {
            let raw = |path: &str| {
                let out = std::process::Command::new(&ffmpeg)
                    .args(["-v", "error", "-i", path, "-map", "0:a", "-f", "s32le", "-c:a", "pcm_s32le", "-"])
                    .output()
                    .unwrap();
                assert!(out.status.success() && out.stderr.is_empty(), "{name}: {}", String::from_utf8_lossy(&out.stderr));
                out.stdout
            };
            assert!(raw(&path) == raw(&wav), "{name}: FLAC must decode to the WAV's samples exactly");
        }
    }
    // MXF stays PCM whatever is asked for
    let mxf = ExportSettings { format: Format::MxfOp1a, audio: audio.clone(), ..Default::default() };
    assert_eq!(mxf.audio_codec(), AudioCodec::Pcm);
}

#[test]
fn flac_settings_round_trip_and_summary() {
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "flac"})).unwrap();
    assert_eq!((s.format, s.audio_codec(), s.audio.flac_level, s.has_video()), (Format::Flac, AudioCodec::Flac, 5, false));
    assert_eq!((s.extension(), Format::from_name("FLAC"), Format::Flac.id()), ("flac", Some(Format::Flac), "flac"));
    // settings saved before FLAC read the default level
    let old: AudioSettings = serde_json::from_value(serde_json::json!({"bits": 24})).unwrap();
    assert_eq!(old.flac_level, 5);
    let sum = ExportSettings { format: Format::Flac, ..Default::default() }.summary(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND));
    assert!(sum.audio.starts_with("FLAC (lossless) 16-bit, level 5, 48000 Hz"), "{}", sum.audio);
    assert_eq!(sum.video, "No video");
    // estimated below PCM
    let pcm = ExportSettings { format: Format::Wav, ..Default::default() }.estimate_bytes(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND));
    let flac = ExportSettings { format: Format::Flac, ..Default::default() }.estimate_bytes(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND));
    assert!(flac < pcm, "{flac} < {pcm}");
}

#[test]
fn invalid_export_allocations_are_rejected_before_rendering() {
    let (project, sequence, _) = matte([1.0, 0.0, 0.0, 1.0], 64, 36, None);
    for size in [(0, 36), (64, 0), (u32::MAX, u32::MAX), (32768, 16384), (40000, 16)] {
        let settings = ExportSettings { frame_size: Some(size), ..Default::default() };
        assert!(settings.validate().is_err(), "{size:?}");
        assert!(pipeline::Pipeline::new(project.clone(), sequence, &settings, false).is_err());
    }
    for size in [(15360, 8640), (16384, 8192)] {
        assert!(ExportSettings { frame_size: Some(size), ..Default::default() }.validate().is_ok(), "{size:?} is a real output size");
    }
    for scale in [0.0, -1.0, f32::NAN, f32::INFINITY, 1e30] {
        let settings = ExportSettings { scale, ..Default::default() };
        assert!(pipeline::Pipeline::new(project.clone(), sequence, &settings, false).is_err(), "scale {scale}");
    }
    for rate in [0, 384_001, u32::MAX] {
        let settings = ExportSettings { audio: AudioSettings { sample_rate: Some(rate), ..Default::default() }, ..Default::default() };
        assert!(settings.validate().is_err());
    }
}

#[test]
fn hostile_export_ranges_are_rejected_before_time_arithmetic() {
    let (project, seq, sources) = matte([1.0, 0.0, 0.0, 1.0], 64, 36, None);
    for range in [
        TimeRange::new(Tick(i64::MIN), Tick(i64::MAX)),
        TimeRange::new(Tick(i64::MAX), Tick(1)),
        TimeRange::new(Tick::ZERO, Tick(-1)),
        TimeRange::new(Tick::ZERO, Tick::ZERO),
    ] {
        let settings = ExportSettings { range: Some(range), ..Default::default() };
        assert!(settings.validate().is_err());
        assert!(export_range(&project, seq, &settings).is_err());
        assert!(export(&project, seq, &settings, &sources, &Progress::default()).is_err());
    }
}

#[test]
fn frame_size_rate_and_scaling() {
    let (p, seq, m) = matte([1.0, 0.0, 0.0, 1.0], 320, 180, Some(-12.0));
    let dir = Scratch::new("size");
    let path = dir.path("square.mp4");
    let s = ExportSettings {
        format: Format::H264,
        path: path.clone(),
        frame_size: Some((256, 256)),
        frame_rate: Some(FrameRate::new(12, 1)),
        scaling: Scaling::ScaleToFit,
        ..Default::default()
    };
    let r = export(&p, seq, &s, &m, &Progress::default()).unwrap();
    assert_eq!(r.frames, 12, "1 s at 12 fps");
    let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
    let src = filmcraft_codecs::open_bytes("square.mp4", bytes).unwrap();
    let v = src.info().video.clone().unwrap();
    assert_eq!((v.width, v.height), (256, 256));
    let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 2))).unwrap().to_rgba8();
    let at = |x: usize, y: usize| &f[(y * 256 + x) * 4..(y * 256 + x) * 4 + 3];
    assert!(at(128, 128)[0] > 200, "picture in the middle: {:?}", at(128, 128));
    assert!(at(128, 10)[0] < 40, "letterbox bar on top: {:?}", at(128, 10));
    assert!(at(128, 245)[0] < 40, "letterbox bar below: {:?}", at(128, 245));
    if let Some(j) = ffprobe_json(&["-count_frames", "-show_streams", "-select_streams", "v:0"], &path) {
        let st = &j["streams"][0];
        assert_eq!(st["r_frame_rate"], "12/1");
        assert_eq!(st["nb_read_frames"], "12");
        assert_eq!(st["width"], 256);
    }
    // fill crops instead of letterboxing
    let path = dir.path("fill.mov");
    let s = ExportSettings {
        format: Format::ProRes,
        path: path.clone(),
        frame_size: Some((200, 200)),
        scaling: Scaling::ScaleToFill,
        include_audio: false,
        ..Default::default()
    };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
    let src = filmcraft_codecs::open_bytes("fill.mov", bytes).unwrap();
    let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 2))).unwrap().to_rgba8();
    assert!(f[(5 * 200 + 100) * 4] > 200, "filled to the top edge");
}

/// Integrated loudness of planar audio.
fn lufs(planar: &[Vec<f32>], sr: u32) -> (f64, f64) {
    let refs: Vec<&[f32]> = planar.iter().map(Vec::as_slice).collect();
    let s = filmcraft_audio_dsp::loudness::measure(&refs, sr as f64);
    (s.integrated_lufs, s.true_peak_dbtp)
}

fn read_wav16(path: &str) -> Vec<Vec<f32>> {
    let b = std::fs::read(path).unwrap();
    let ch = u16::from_le_bytes([b[22], b[23]]) as usize;
    let data = &b[44..];
    let mut out = vec![Vec::new(); ch];
    for (i, s) in data.as_chunks::<2>().0.iter().enumerate() {
        out[i % ch].push(i16::from_le_bytes([s[0], s[1]]) as f32 / 32768.0);
    }
    out
}

#[test]
fn loudness_normalization_hits_target_and_true_peak() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("loud");
    for target in [-23.0, -16.0, -14.0] {
        let path = dir.path(&format!("n{}.wav", -target as i32));
        let mut s = ExportSettings { format: Format::Wav, path: path.clone(), ..Default::default() };
        s.effects.loudness = LoudnessNormalization { enabled: true, target_lufs: target, true_peak_dbtp: -1.0 };
        let prog = Progress::default();
        export(&p, seq, &s, &m, &prog).unwrap();
        let (i, tp) = lufs(&read_wav16(&path), 48_000);
        assert!((i - target).abs() < 0.5, "target {target}: measured {i:.2} LUFS");
        assert!(tp <= -0.9, "true peak {tp:.2} dBTP");
        let rep = prog.loudness.lock().unwrap().unwrap();
        assert!((rep.measured_lufs + rep.gain_db - target).abs() < 0.1, "unlimited tone needs no correction");
    }
    // a target the peaks cannot reach: the limiter holds the true-peak ceiling
    let path = dir.path("hot.wav");
    let mut s = ExportSettings { format: Format::Wav, path: path.clone(), ..Default::default() };
    s.effects.loudness = LoudnessNormalization { enabled: true, target_lufs: -3.0, true_peak_dbtp: -3.0 };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let (_, tp) = lufs(&read_wav16(&path), 48_000);
    assert!(tp <= -2.8, "limited true peak {tp:.2} dBTP");
    // and through the stepped H.264 + AAC path, decoded by our AAC decoder
    let path = dir.path("loud.mp4");
    let mut s = ExportSettings { format: Format::H264, path: path.clone(), ..Default::default() };
    s.effects.loudness = LoudnessNormalization { enabled: true, target_lufs: -20.0, true_peak_dbtp: -1.0 };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
    let src = filmcraft_codecs::open_bytes("loud.mp4", bytes).unwrap();
    let a = src.audio(4800, 38_400, 48_000).unwrap();
    let (i, _) = lufs(&a.channels, 48_000);
    assert!((i + 20.0).abs() < 0.5, "AAC: {i:.2} LUFS");
}

#[test]
fn two_pass_and_cbr_h264() {
    let (p, seq, m) = matte([0.2, 0.5, 0.8, 1.0], 320, 180, None);
    let dir = Scratch::new("2pass");
    for mode in [BitrateMode::Vbr2Pass, BitrateMode::Cbr] {
        let path = dir.path(&format!("{mode:?}.mp4"));
        let s = ExportSettings { format: Format::H264, path: path.clone(), bitrate_mode: mode, bitrate_kbps: 2000, include_audio: false, ..Default::default() };
        let prog = Progress::default();
        let r = export(&p, seq, &s, &m, &prog).unwrap();
        assert_eq!(r.frames, 24);
        let passes = if mode == BitrateMode::Vbr2Pass { 2 } else { 1 };
        assert_eq!(prog.total.load(Ordering::Relaxed), 24 * passes);
        assert_eq!(prog.done.load(Ordering::Relaxed), 24 * passes);
        let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
        let src = filmcraft_codecs::open_bytes("x.mp4", bytes).unwrap();
        let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 2))).unwrap().to_rgba8();
        assert!((f[2] as i32 - 204).abs() < 12 && (f[1] as i32 - 127).abs() < 12, "{mode:?}: {:?}", &f[..4]);
    }
}

#[test]
fn crf_h264() {
    // settings saved before CRF existed read as the default; the range is checked
    let old: ExportSettings = serde_json::from_value(serde_json::json!({"format": "h264", "bitrateMode": "vbr1Pass"})).unwrap();
    assert_eq!(old.crf, DEFAULT_CRF);
    let c: ExportSettings = serde_json::from_value(serde_json::json!({"bitrateMode": "crf", "crf": 18.0})).unwrap();
    assert_eq!((c.bitrate_mode, c.crf), (BitrateMode::Crf, 18.0));
    for bad in [-1.0, 51.5, f32::NAN, f32::INFINITY] {
        assert!(ExportSettings { bitrate_mode: BitrateMode::Crf, crf: bad, ..Default::default() }.validate().is_err(), "{bad}");
    }
    // the value only matters in CRF mode
    assert!(ExportSettings { crf: f32::NAN, ..Default::default() }.validate().is_ok());
    let summary = c.summary(1920, 1080, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert!(summary.video.contains("CRF (constant quality) 18"), "{}", summary.video);

    // one pass at constant quality: a lower factor spends more bits, and both decode to the picture
    let (p, seq, m) = matte([0.2, 0.5, 0.8, 1.0], 320, 180, None);
    let dir = Scratch::new("crf");
    let mut sizes = Vec::new();
    for crf in [10.0, 40.0] {
        let path = dir.path(&format!("crf{crf}.mp4"));
        let s = ExportSettings { format: Format::H264, path: path.clone(), bitrate_mode: BitrateMode::Crf, crf, include_audio: false, ..Default::default() };
        let prog = Progress::default();
        let r = export(&p, seq, &s, &m, &prog).unwrap();
        assert_eq!((r.frames, prog.total.load(Ordering::Relaxed)), (24, 24));
        let bytes: Arc<[u8]> = std::fs::read(&path).unwrap().into();
        sizes.push(bytes.len());
        let src = filmcraft_codecs::open_bytes("x.mp4", bytes).unwrap();
        let f = src.video_frame(FrameRequest::full(Tick(TICKS_PER_SECOND / 2))).unwrap().to_rgba8();
        assert!((f[2] as i32 - 204).abs() < 12 && (f[1] as i32 - 127).abs() < 12, "CRF {crf}: {:?}", &f[..4]);
    }
    assert!(sizes[0] > sizes[1], "CRF 10 {} bytes, CRF 40 {} bytes", sizes[0], sizes[1]);
}

#[test]
fn h264_profile_level_and_keyframes() {
    let (p, seq, m) = matte([0.5, 0.5, 0.5, 1.0], 320, 180, None);
    let dir = Scratch::new("profile");
    let path = dir.path("main.mp4");
    let s = ExportSettings {
        format: Format::H264,
        path: path.clone(),
        h264_profile: H264Profile::Main,
        h264_level: Some(51),
        keyframe_distance: Some(6),
        include_audio: false,
        ..Default::default()
    };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    if let Some(j) = ffprobe_json(&["-show_streams"], &path) {
        assert_eq!(j["streams"][0]["profile"], "Main");
        assert_eq!(j["streams"][0]["level"], 51);
    }
    if let Some(j) = ffprobe_json(&["-show_frames", "-select_streams", "v:0", "-show_entries", "frame=key_frame"], &path) {
        let keys = j["frames"].as_array().unwrap().iter().filter(|f| f["key_frame"] == 1).count();
        assert_eq!(keys, 4, "24 frames, a keyframe every 6");
    }
}

/// H.264 High 10 (#1221): MP4 and MOV carry a 10-bit stream ffmpeg decodes without a message;
/// All Intra makes High 10 Intra with every frame a keyframe; the grey matte keeps its 10-bit code.
#[test]
fn h264_high10_and_all_intra_export() {
    let (p, seq, m) = matte([0.5, 0.5, 0.5, 1.0], 320, 180, None);
    let dir = Scratch::new("high10");
    for (ext, intra) in [("mp4", false), ("mov", false), ("mp4", true)] {
        let path = dir.path(&format!("high10_{intra}.{ext}"));
        let mut s = ExportSettings {
            format: Format::H264,
            path: path.clone(),
            h264_profile: H264Profile::High10,
            h264_intra_only: intra,
            bitrate_mode: BitrateMode::Crf,
            crf: 18.0,
            include_audio: false,
            ..Default::default()
        };
        if ext == "mov" {
            s.multiplexer = Multiplexer::Mov;
        }
        s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(12)));
        let summary = s.summary(320, 180, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)).video;
        assert_eq!(summary.contains("every frame a keyframe"), intra, "{summary}");
        assert!(summary.contains(if intra { "High 10 Intra (10-bit)" } else { "High 10 (10-bit)" }), "{summary}");
        let high = ExportSettings { h264_profile: H264Profile::High, ..s.clone() }.summary(320, 180, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)).video;
        assert!(high.contains("High (8-bit)") || high.contains("High Intra (8-bit)"), "{high}");
        export(&p, seq, &s, &m, &Progress::default()).unwrap();
        let Some(j) = ffprobe_json(&["-show_streams"], &path) else { return };
        let st = &j["streams"][0];
        assert_eq!(st["profile"], if intra { "High 10 Intra" } else { "High 10" }, "{path}");
        assert_eq!(st["pix_fmt"], "yuv420p10le", "{path}");
        if let Some(j) = ffprobe_json(&["-show_frames", "-select_streams", "v:0", "-show_entries", "frame=key_frame"], &path) {
            let keys = j["frames"].as_array().unwrap().iter().filter(|f| f["key_frame"] == 1).count();
            assert_eq!(keys == 12, intra, "{path}: {keys} keyframes of 12");
        }
        let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("export high10") else { return };
        let out = std::process::Command::new(ffmpeg)
            .args(["-v", "warning", "-i", &path, "-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "yuv420p10le", "-"])
            .output()
            .unwrap();
        assert!(out.status.success() && out.stderr.is_empty(), "{path}: {}", String::from_utf8_lossy(&out.stderr));
        // 50 % grey renders as RGBA 127 or 128: Y = 64 + 876 * 127/255 = 500 .. 64 + 876 * 128/255 = 504
        let y0 = u16::from_le_bytes([out.stdout[2 * (90 * 320 + 160)], out.stdout[2 * (90 * 320 + 160) + 1]]);
        assert!((499..=505).contains(&y0), "{path}: Y {y0}");
    }
}

#[test]
fn video_limiter_clamps_luma() {
    let (p, seq, m) = matte([1.0, 1.0, 1.0, 1.0], 64, 36, None);
    let dir = Scratch::new("limiter");
    let mut s = ExportSettings { format: Format::PngSequence, path: dir.path("w.png"), ..Default::default() };
    s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(1)));
    s.effects.video_limiter = VideoLimiter { enabled: true, min_percent: 0.0, max_percent: 80.0 };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let img = image::open(dir.0.join("w000.png")).unwrap().to_rgb8();
    let mx = img.pixels().flat_map(|p| p.0).max().unwrap();
    assert!((200..=204).contains(&mx), "white limited to 80 %: {mx}");
    let mut px = vec![255u8, 255, 255, 255, 0, 0, 0, 255];
    limit_rgba8(&mut px, 10.0, 90.0);
    assert!(px[0] <= 230 && px[4] >= 25, "{px:?}");
}

#[test]
fn overlays_draw_where_placed() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 320, 180, None);
    let dir = Scratch::new("overlay");
    // a 10ร—10 green PNG as the image overlay
    let logo = dir.path("logo.png");
    image::RgbaImage::from_pixel(10, 10, image::Rgba([0, 255, 0, 255])).save(&logo).unwrap();
    let mut s = ExportSettings { format: Format::PngSequence, path: dir.path("o.png"), ..Default::default() };
    s.range = Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(1)));
    s.effects.image_overlay = ImageOverlay { enabled: true, path: logo, placement: Placement::TopRight, size_percent: 10.0, ..Default::default() };
    s.effects.name_overlay =
        TextOverlay { enabled: true, text: "CLIENT REVIEW".into(), placement: Placement::BottomCenter, size_percent: 8.0, ..Default::default() };
    s.effects.timecode_overlay = TextOverlay { enabled: true, placement: Placement::TopLeft, size_percent: 8.0, ..Default::default() };
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    let img = image::open(dir.0.join("o000.png")).unwrap().to_rgb8();
    let count = |x0: u32, x1: u32, y0: u32, y1: u32, f: &dyn Fn([u8; 3]) -> bool| {
        (y0..y1).flat_map(|y| (x0..x1).map(move |x| (x, y))).filter(|&(x, y)| f(img.get_pixel(x, y).0)).count()
    };
    let green = |p: [u8; 3]| p[1] > 200 && p[0] < 60;
    let white = |p: [u8; 3]| p[0] > 200 && p[1] > 200 && p[2] > 200;
    assert!(count(260, 320, 0, 60, &green) > 200, "logo top right");
    assert_eq!(count(0, 160, 0, 180, &green), 0, "no logo on the left");
    assert!(count(60, 260, 140, 180, &white) > 50, "name bottom centre");
    assert!(count(0, 160, 0, 40, &white) > 50, "timecode top left");
    assert_eq!(count(0, 320, 70, 110, &white), 0, "nothing in the middle");
}

#[test]
fn metadata_and_quicktime_multiplexer() {
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 1.0], 160, 90, Some(-12.0));
    let dir = Scratch::new("meta");
    let path = dir.path("m.mov");
    let mut s = ExportSettings { format: Format::H264, path: path.clone(), multiplexer: Multiplexer::Mov, ..Default::default() };
    s.metadata = ExportMetadata { title: "Test Title".into(), creator: "FilmCraft Tests".into(), copyright: "CC0".into(), ..Default::default() };
    s.audio.codec = AudioCodec::Pcm;
    s.audio.bits = 24;
    assert_eq!(s.extension(), "mov");
    export(&p, seq, &s, &m, &Progress::default()).unwrap();
    if let Some(j) = ffprobe_json(&["-show_format", "-show_streams"], &path) {
        assert!(j["format"]["format_name"].as_str().unwrap().contains("mov"));
        let tags = &j["format"]["tags"];
        assert_eq!(tags["title"], "Test Title");
        assert_eq!(tags["copyright"], "CC0");
        let codecs: Vec<&str> = j["streams"].as_array().unwrap().iter().map(|s| s["codec_name"].as_str().unwrap()).collect();
        assert_eq!(codecs, ["h264", "pcm_s24le"]);
    }
}

#[test]
fn interlaced_output_is_rejected_honestly() {
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 1.0], 160, 90, None);
    let s = ExportSettings { format: Format::ProRes, path: "unused.mov".into(), field_order: FieldOrder::UpperFirst, ..Default::default() };
    let e = export(&p, seq, &s, &m, &Progress::default()).unwrap_err();
    assert!(e.to_string().contains("progressive"), "{e}");
}

#[test]
fn settings_serde_and_estimates() {
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "prores", "frameSize": [1280, 720], "proresProfile": "lt"})).unwrap();
    assert_eq!(s.format, Format::ProRes);
    assert_eq!(s.frame_size, Some((1280, 720)));
    assert!(s.include_audio, "defaults fill the rest");
    let back: ExportSettings = serde_json::from_value(serde_json::to_value(&s).unwrap()).unwrap();
    assert_eq!(back.prores_profile, "lt");
    // 10 s of 20 Mbps H.264 + 320 kbps AAC โ‰ˆ 25.4 MB
    let h = ExportSettings::default();
    let b = h.estimate_bytes(1920, 1080, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert!((b as f64 - 25.4e6).abs() < 0.2e6, "{b}");
    assert_eq!(format_bytes(b), "25 MB");
    // adaptive bitrate scales with the frame size
    let a = ExportSettings { adaptive_bitrate: Some(0.2), ..Default::default() };
    assert_eq!(a.resolve(1920, 1080, FrameRate::FPS_30, 48_000).target_kbps, 12_442);
    assert_eq!(a.resolve(3840, 2160, FrameRate::FPS_30, 48_000).target_kbps, 49_766);
}

#[test]
fn builtin_presets_are_valid_and_unique() {
    let all = builtin_presets();
    assert!(all.len() >= 24);
    let mut keys: Vec<String> = all.iter().map(|p| presets::preset_key(&p.name)).collect();
    keys.sort();
    keys.dedup();
    assert_eq!(keys.len(), all.len(), "unique names");
    for p in &all {
        p.settings.validate().unwrap();
        assert!(p.builtin && !p.category.is_empty() && !p.description.is_empty(), "{}", p.name);
    }
    assert_eq!(presets::find_builtin("match source - adaptive high bitrate").unwrap().name, presets::DEFAULT_PRESET);
    let json = serde_json::to_value(&all[0]).unwrap();
    let back: ExportPreset = serde_json::from_value(json).unwrap();
    assert_eq!(back.settings.adaptive_bitrate, Some(0.2));
}

/// The short-form presets: 9:16 1080ร—1920 H.264 filling the frame at the sequence's rate, with
/// loudness normalization on at the platforms' level, and the sharing site's own bitrate.
#[test]
fn short_form_presets_are_vertical_and_loudness_normalized() {
    for (name, kbps, max_kbps) in
        [("TikTok 1080ร—1920", 10_000, 12_000), ("Instagram Reels 1080ร—1920", 8_000, 10_000), ("YouTube Shorts 1080ร—1920", 12_000, 16_000)]
    {
        let p = presets::find_builtin(name).unwrap_or_else(|| panic!("{name} is a built-in preset"));
        let s = &p.settings;
        assert_eq!((p.category.as_str(), s.format, s.frame_size, s.frame_rate), ("Web & Social", Format::H264, Some((1080, 1920)), None), "{name}");
        assert_eq!(s.scaling, Scaling::ScaleToFill, "{name}");
        assert_eq!((s.bitrate_kbps, s.max_bitrate_kbps, s.bitrate_mode), (kbps, Some(max_kbps), BitrateMode::Vbr1Pass), "{name}");
        assert_eq!((s.audio.codec, s.audio.sample_rate), (AudioCodec::Aac, Some(48_000)), "{name}");
        let l = &s.effects.loudness;
        assert!(l.enabled, "{name}");
        assert_eq!((l.target_lufs, l.true_peak_dbtp), (presets::SHORT_FORM_LUFS, presets::SHORT_FORM_PEAK_DBTP), "{name}");
        // found whatever the case, as `--preset` and the preset browser look names up
        assert_eq!(presets::find_builtin(&name.to_lowercase()).map(|p| p.name), Some(name.to_string()));
    }
}

/// #108: the default 320 kbps is more than AAC can carry in stereo at 22.05 kHz (6 bits per sample
/// and channel). The export failed with "bitrate out of range"; it is now capped to the limit.
#[test]
fn aac_bitrate_is_capped_for_low_sample_rates() {
    let mut s = ExportSettings::default();
    s.audio.bitrate_kbps = 320;
    for (rate, ch) in [(22_050, 2), (16_000, 2), (8_000, 6), (48_000, 2)] {
        let enc = aac_factory(Format::H264, rate, ch, &s).expect("AAC is always available");
        assert!(enc.is_ok(), "{rate} Hz ร— {ch}: {:?}", enc.err());
    }
}

#[test]
fn a_time_left_reads_like_a_clock() {
    use std::time::Duration;
    let f = |ms: u64| format_eta(Duration::from_millis(ms));
    assert_eq!(f(0), "0 s");
    assert_eq!(f(1), "1 s", "rounded up: never say 0 s while there is time left");
    assert_eq!(f(45_000), "45 s");
    assert_eq!(f(59_001), "1:00");
    assert_eq!(f(60_000), "1:00");
    assert_eq!(f(125_000), "2:05");
    assert_eq!(f(3_599_000), "59:59");
    assert_eq!(f(3_600_000), "1:00:00");
    assert_eq!(f(3_725_000), "1:02:05");
    assert_eq!(f(100 * 3600 * 1000), "100:00:00");
    assert!(!format_eta(Duration::MAX).is_empty(), "the largest duration cannot overflow");
}

#[test]
fn av1_is_an_mp4_format_that_needs_a_registered_encoder() {
    for name in ["av1", "AV1", "av01"] {
        assert_eq!(Format::from_name(name), Some(Format::Av1), "{name}");
    }
    assert_eq!(Format::from_name(Format::Av1.id()), Some(Format::Av1));
    assert_eq!((Format::Av1.extension(), Format::Av1.label()), ("mp4", "AV1"));
    assert!(Format::ALL.contains(&Format::Av1));
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "av1"})).unwrap();
    assert_eq!(s.format, Format::Av1);
    assert_eq!(serde_json::to_value(&s).unwrap()["format"], "av1");
    // MP4 with AAC only: a QuickTime multiplexer setting left over from H.264 does not apply
    let a = ExportSettings { format: Format::Av1, ..Default::default() };
    assert_eq!((a.audio_codec(), a.extension()), (AudioCodec::Aac, "mp4"));
    let mov = ExportSettings { multiplexer: Multiplexer::Mov, ..a.clone() };
    assert_eq!((mov.audio_codec(), mov.extension()), (AudioCodec::Aac, "mp4"));
    let b = a.estimate_bytes(1920, 1088, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert!((b as f64 - 25.4e6).abs() < 0.2e6, "{b}");
    let summary = a.summary(1920, 1088, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert_eq!(summary.format, "AV1 (MP4)");
    assert!(summary.video.contains("AV1 Main"), "{}", summary.video);
    let e = ExportSettings { bitrate_mode: BitrateMode::Vbr2Pass, ..a.clone() }.validate().unwrap_err();
    assert!(e.to_string().contains("two-pass"), "{e}");
    let e = ExportSettings { bitrate_mode: BitrateMode::Crf, ..a.clone() }.validate().unwrap_err();
    assert!(e.to_string().contains("no CRF mode"), "{e}");
    assert!(!Format::Av1.has_builtin_encoder());
    assert!(!available(Format::Av1), "nothing registered an encoder for it");
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 1.0], 160, 96, None);
    let sc = Scratch::new("av1-missing");
    let err = export(&p, seq, &ExportSettings { path: sc.path("x.mp4"), include_audio: false, ..a.clone() }, &m, &Progress::default()).unwrap_err().to_string();
    assert!(err.contains("AV1") && err.contains("encoder not available"), "{err}");
}

#[test]
fn h265_is_a_format_that_needs_a_registered_encoder() {
    use std::sync::atomic::{AtomicBool, Ordering};
    // names, ids, files and serialized settings
    for name in ["hevc", "H.265", "h265", "HVC1", "x265"] {
        assert_eq!(Format::from_name(name), Some(Format::Hevc), "{name}");
    }
    assert_eq!(Format::from_name(Format::Hevc.id()), Some(Format::Hevc));
    assert_eq!((Format::Hevc.extension(), Format::Hevc.label()), ("mp4", "H.265 (HEVC)"));
    assert!(Format::ALL.contains(&Format::Hevc) && Format::ALL.len() == 22);
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "hevc"})).unwrap();
    assert_eq!(s.format, Format::Hevc);
    assert_eq!(serde_json::to_value(&s).unwrap()["format"], "hevc");

    // it is H.264's family: MP4 with AAC, or QuickTime; the same size estimate
    let h = ExportSettings { format: Format::Hevc, ..Default::default() };
    assert_eq!((h.audio_codec(), h.extension()), (AudioCodec::Aac, "mp4"));
    assert_eq!(ExportSettings { multiplexer: Multiplexer::Mov, ..h.clone() }.extension(), "mov");
    // 10 s of 20 Mbps video + 320 kbps AAC โ‰ˆ 25.4 MB, like H.264
    let b = h.estimate_bytes(1920, 1080, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert!((b as f64 - 25.4e6).abs() < 0.2e6, "{b}");
    let summary = h.summary(1920, 1080, FrameRate::FPS_25, 48_000, Tick(10 * TICKS_PER_SECOND));
    assert_eq!(summary.format, "H.265 (HEVC) (MP4)");
    assert!(summary.video.contains("HEVC Main") && summary.video.contains("Target 20.00 Mbps"), "{}", summary.video);

    // a hardware encoder has one pass
    let e = ExportSettings { bitrate_mode: BitrateMode::Vbr2Pass, ..h.clone() }.validate().unwrap_err();
    assert!(e.to_string().contains("two-pass"), "{e}");
    assert!(ExportSettings { bitrate_mode: BitrateMode::Cbr, ..h.clone() }.validate().is_ok());
    let e = ExportSettings { bitrate_mode: BitrateMode::Crf, ..h.clone() }.validate().unwrap_err();
    assert!(e.to_string().contains("CRF"), "{e}");

    // formats with a built-in encoder are always available; this one only when a registered probe says so
    assert!(Format::ALL.iter().filter(|f| f.has_builtin_encoder()).all(|f| available(*f)));
    assert!(!Format::Hevc.has_builtin_encoder());
    static HERE: AtomicBool = AtomicBool::new(false);
    fn probe() -> bool {
        HERE.load(Ordering::SeqCst)
    }
    assert!(!available(Format::Hevc), "nothing registered an encoder for it");
    // and an export says so, honestly
    let (p, seq, m) = matte([0.0, 0.0, 1.0, 1.0], 160, 90, None);
    let sc = Scratch::new("h265-missing");
    let err = export(&p, seq, &ExportSettings { path: sc.path("x.mp4"), include_audio: false, ..h.clone() }, &m, &Progress::default()).unwrap_err().to_string();
    assert!(err.contains("H.265") && err.contains("encoder not available"), "{err}");
    register_format_probe(Format::Hevc, probe);
    register_format_probe(Format::Hevc, probe); // the same probe twice is harmless
    assert!(!available(Format::Hevc));
    HERE.store(true, Ordering::SeqCst);
    assert!(available(Format::Hevc));
    HERE.store(false, Ordering::SeqCst);
    assert!(!available(Format::Hevc));
}

#[test]
fn extreme_bitrates_do_not_overflow_resolution() {
    let s = ExportSettings { bitrate_kbps: u32::MAX, adaptive_bitrate: None, ..Default::default() };
    let resolved = s.resolve(1920, 1080, FrameRate::FPS_30, 48_000);
    assert_eq!(resolved.target_kbps, u32::MAX);
    assert_eq!(resolved.max_kbps, u32::MAX);
}

#[test]
fn extreme_bitrates_do_not_overflow_encoder_setup() {
    for max_bitrate_kbps in [None, Some(u32::MAX)] {
        let settings = ExportSettings { bitrate_kbps: u32::MAX, max_bitrate_kbps, ..Default::default() };
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| super::h264_factory(Format::H264, 64, 36, FrameRate::FPS_24, &settings)));
        assert!(result.is_ok(), "an extreme bitrate must return an encoder result without overflowing its fallback");
        assert!(result.unwrap().unwrap().is_err(), "an unrepresentable encoder buffer rate must be rejected");
    }
}

#[test]
fn tiff_size_estimate_tracks_alpha_and_real_output() {
    let (project, sequence, sources) = matte([0.0, 0.0, 1.0, 0.5], 320, 180, None);
    let rate = FrameRate::FPS_24;
    let duration = rate.tick_of(1);
    for alpha in [false, true] {
        let dir = Scratch::new(&format!("tiff-size-{alpha}"));
        let mut settings = ExportSettings { format: Format::TiffSequence, path: dir.path("frame.tif"), alpha, ..Default::default() };
        settings.range = Some(TimeRange::new(Tick::ZERO, duration));
        settings.validate().unwrap();

        let expected = 320_u64 * 180 * if alpha { 4 } else { 3 };
        let summary = settings.summary(320, 180, rate, 48_000, duration);
        assert_eq!(summary.estimated_bytes, expected, "alpha={alpha}");
        assert_eq!(settings.estimate_bytes(320, 180, rate, 48_000, duration), expected);
        let result = export(&project, sequence, &settings, &sources, &Progress::default()).unwrap();
        assert_eq!(result.frames, 1);
        let paths = files_in(&dir.0);
        assert_eq!(paths.len(), 1, "{paths:?}");
        let actual_bytes = std::fs::metadata(dir.0.join(&paths[0])).unwrap().len();
        assert!(actual_bytes.abs_diff(summary.estimated_bytes) < 1024, "alpha={alpha}: estimate={} actual={actual_bytes}", summary.estimated_bytes);
    }

    // Other uncompressed formats already have the correct channel policy.
    for format in [Format::BmpSequence, Format::TgaSequence] {
        let rgb = ExportSettings { format, alpha: false, ..Default::default() };
        let rgba = ExportSettings { format, alpha: true, ..Default::default() };
        assert_eq!(rgb.estimate_bytes(320, 180, rate, 48_000, duration), 320 * 180 * 3);
        let expected = if format == Format::BmpSequence { 3 } else { 4 };
        assert_eq!(rgba.estimate_bytes(320, 180, rate, 48_000, duration), 320 * 180 * expected);
    }
}

#[test]
fn gpu_rendering_is_off_by_default() {
    assert_eq!(ExportSettings::default().gpu_rendering, crate::GpuRendering::Off);
    // settings saved before the field existed get the default too
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "h264"})).unwrap();
    assert_eq!(s.gpu_rendering, crate::GpuRendering::Off);
    let auto: ExportSettings = serde_json::from_value(serde_json::json!({"format": "h264", "gpuRendering": "auto"})).unwrap();
    assert_eq!(auto.gpu_rendering, crate::GpuRendering::Auto);
}

/// Brief large peaks over a quiet bed exercise loudness lost during limiter release.
struct CrestSource(filmcraft_media::SharedSource, Arc<std::sync::atomic::AtomicUsize>);
impl MediaSource for CrestSource {
    fn info(&self) -> &filmcraft_media::MediaInfo {
        self.0.info()
    }
    fn video_frame(&self, req: FrameRequest) -> filmcraft_media::Result<Arc<filmcraft_frame::VideoFrame>> {
        self.0.video_frame(req)
    }
    fn audio(&self, start: i64, frames: usize, sample_rate: u32) -> filmcraft_media::Result<filmcraft_frame::AudioBuffer> {
        self.1.fetch_add(1, Ordering::Relaxed);
        let samples: Vec<f32> = (0..frames)
            .map(|i| {
                let at = start + i as i64;
                let phase = at.rem_euclid(sample_rate as i64 / 4);
                let amplitude = if phase < sample_rate as i64 / 500 { 0.9 } else { 0.08 };
                amplitude * (std::f32::consts::TAU * 1000.0 * at as f32 / sample_rate as f32).sin()
            })
            .collect();
        Ok(filmcraft_frame::AudioBuffer { sample_rate, channels: vec![samples.clone(), samples] })
    }
}

#[test]
fn loudness_normalization_corrects_limiter_loss_and_bounds_impossible_targets() {
    use std::cell::Cell;
    let (p, seq, mut sources) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let reads = Arc::new(std::sync::atomic::AtomicUsize::new(0));
    for source in sources.0.values_mut() {
        *source = Arc::new(CrestSource(source.clone(), reads.clone()));
    }
    let range = TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND));
    let mut settings = ExportSettings::default();
    settings.effects.loudness = LoudnessNormalization { enabled: true, target_lufs: -14.0, true_peak_dbtp: -2.0 };
    for target in [-14.0, 2.0] {
        settings.effects.loudness.target_lufs = target;
        let mut audio = audio_out::AudioOut::new(p.clone(), seq, &settings, range).unwrap();
        let chunks = Cell::new(0);
        audio
            .measure(&settings, &sources, &|| {
                chunks.set(chunks.get() + 1);
                false
            })
            .unwrap();
        let report = audio.loudness.unwrap();
        let result = audio.rest(&sources).unwrap();
        let (integrated, peak) = lufs(&result, 48_000);
        eprintln!("target {target}: output {integrated:.3} LUFS, {peak:.3} dBTP, gain {:.3}, chunks {}", report.gain_db, chunks.get());
        assert!(chunks.get() <= 5, "one raw pass plus at most four limited trials");
        assert_eq!(result[0].len(), 48_000, "measuring must rewind output and limiter latency");
        assert!(peak <= -1.8, "limiting must remain enabled: {peak}");
        if target == -14.0 {
            assert!((integrated - target).abs() < 0.15, "achieved {integrated}");
            assert!(report.gain_db > target - report.measured_lufs + 0.3, "fixture must require limiter correction");
        } else {
            assert!(integrated < target - 1.0, "impossible target sacrifices loudness, not peak ceiling");
        }
    }
    // Cancel after raw measurement and one limited trial, before further refinement.
    // Record source reads at cancellation to prove no further mixing occurs.
    let mut audio = audio_out::AudioOut::new(p, seq, &settings, range).unwrap();
    let chunks = Cell::new(0);
    let reads_at_cancel = Cell::new(None);
    let cancel = || {
        chunks.set(chunks.get() + 1);
        if chunks.get() > 2 {
            reads_at_cancel.set(Some(reads.load(Ordering::Relaxed)));
            true
        } else {
            false
        }
    };
    assert!(matches!(audio.measure(&settings, &sources, &cancel), Err(ExportError::Cancelled)));
    assert_eq!(chunks.get(), 3);
    assert_eq!(reads_at_cancel.get(), Some(reads.load(Ordering::Relaxed)));
}

/// 32-bit integer and float audio in every container that takes them, read back by ffprobe (an
/// external oracle) and, where FilmCraft imports the format, by FilmCraft's own readers.
#[test]
fn thirty_two_bit_audio_in_every_container() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(-6.0));
    let dir = Scratch::new("pcm32");
    let range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 2)));
    let cases: [(Format, SampleFormat, &str, &str, &str); 8] = [
        (Format::Wav, SampleFormat::Float32, "f.wav", "pcm_f32le", "32"),
        (Format::Wav, SampleFormat::Int32, "i.wav", "pcm_s32le", "32"),
        (Format::Aiff, SampleFormat::Float32, "f.aif", "pcm_f32be", "32"),
        (Format::Aiff, SampleFormat::Int32, "i.aif", "pcm_s32be", "32"),
        (Format::ProRes, SampleFormat::Float32, "f.mov", "pcm_f32le", "32"),
        (Format::ProRes, SampleFormat::Int32, "i.mov", "pcm_s32le", "32"),
        (Format::MxfOp1a, SampleFormat::Int32, "i.mxf", "pcm_s32le", "32"),
        (Format::Flac, SampleFormat::Int32, "i.flac", "flac", "32"),
    ];
    for (format, sf, name, codec, bits) in cases {
        let path = dir.path(name);
        let mut s = ExportSettings { format, path: path.clone(), range, ..Default::default() };
        s.audio.set_sample_format(sf);
        assert!(s.supports_sample_format(sf), "{name}");
        export(&p, seq, &s, &m, &Progress::default()).unwrap_or_else(|e| panic!("{name}: {e}"));
        let bytes = std::fs::read(&path).unwrap();
        // FilmCraft's own importer: the -6 dB tone at a peak of 0.5
        if !matches!(format, Format::MxfOp1a) {
            let src = filmcraft_codecs::open_bytes(name, bytes.into()).unwrap_or_else(|e| panic!("{name}: {e}"));
            let a = src.audio(0, 24_000, 48_000).unwrap();
            let peak = a.channels[0].iter().fold(0.0f32, |m, v| m.max(v.abs()));
            assert!((peak - 0.5).abs() < 0.01, "{name}: peak {peak}");
        }
        if let Some(j) = ffprobe_json(&["-show_streams"], &path) {
            let st = j["streams"].as_array().unwrap().iter().find(|s| s["codec_type"] == "audio").unwrap().clone();
            assert_eq!(st["codec_name"].as_str(), Some(codec), "{name}");
            let depth = if codec == "flac" { &st["bits_per_raw_sample"] } else { &st["bits_per_sample"] };
            assert_eq!(depth.as_str().map(str::to_string).or_else(|| depth.as_u64().map(|v| v.to_string())).as_deref(), Some(bits), "{name}");
        }
    }
    // every 32-bit file holds the same samples (float exactly, integers within one step of 2^-31)
    if let Some(ffmpeg) = filmcraft_testkit::ffmpeg_or_skip("32-bit audio") {
        let raw = |name: &str| {
            let out = std::process::Command::new(&ffmpeg)
                .args(["-v", "error", "-i", &dir.path(name), "-map", "0:a", "-f", "f32le", "-c:a", "pcm_f32le", "-"])
                .output()
                .unwrap();
            assert!(out.status.success(), "{name}: {}", String::from_utf8_lossy(&out.stderr));
            out.stdout.as_chunks::<4>().0.iter().map(|b| f32::from_le_bytes(*b)).collect::<Vec<f32>>()
        };
        let reference = raw("f.wav");
        assert_eq!(reference.len(), 24_000 * 2);
        for name in ["f.aif", "f.mov"] {
            assert!(raw(name) == reference, "{name}: float samples differ from the WAV's");
        }
        for name in ["i.wav", "i.aif", "i.mov", "i.mxf", "i.flac"] {
            let got = raw(name);
            assert_eq!(got.len(), reference.len(), "{name}");
            let worst = got.iter().zip(&reference).map(|(a, b)| (a - b).abs()).fold(0.0f32, f32::max);
            assert!(worst < 1e-6, "{name}: differs by {worst}");
        }
    }
}

/// The mix is 32-bit float: 32-bit float export keeps a +6 dB tone's peaks of 2.0, integers clip
/// them at full scale.
#[test]
fn float_export_keeps_peaks_above_full_scale() {
    let (p, seq, m) = matte([0.0, 0.0, 0.0, 1.0], 64, 36, Some(6.0));
    let dir = Scratch::new("pcm-hot");
    let range = Some(TimeRange::new(Tick::ZERO, Tick(TICKS_PER_SECOND / 4)));
    let peak = |sf: SampleFormat, name: &str| {
        let path = dir.path(name);
        let mut s = ExportSettings { format: Format::Wav, path: path.clone(), range, ..Default::default() };
        s.audio.set_sample_format(sf);
        export(&p, seq, &s, &m, &Progress::default()).unwrap();
        let src = filmcraft_codecs::open_bytes(name, std::fs::read(&path).unwrap().into()).unwrap();
        src.audio(0, 12_000, 48_000).unwrap().channels[0].iter().fold(0.0f32, |m, v| m.max(v.abs()))
    };
    let float = peak(SampleFormat::Float32, "f.wav");
    assert!((float - 2.0).abs() < 0.02, "float keeps +6 dBFS: {float}");
    for (sf, name) in [(SampleFormat::Int32, "i32.wav"), (SampleFormat::Int24, "i24.wav"), (SampleFormat::Int16, "i16.wav")] {
        let p = peak(sf, name);
        assert!(p <= 1.0 && p > 0.99, "{name} clips at full scale: {p}");
    }
}

#[test]
fn sample_formats_each_codec_and_container_stores() {
    use SampleFormat::*;
    let supported = |format: Format, codec: AudioCodec| {
        let s = ExportSettings { format, audio: AudioSettings { codec, ..Default::default() }, ..Default::default() };
        SampleFormat::ALL.iter().filter(|&&f| s.supports_sample_format(f)).copied().collect::<Vec<_>>()
    };
    assert_eq!(supported(Format::Wav, AudioCodec::Auto), [Int16, Int24, Int32, Float32]);
    assert_eq!(supported(Format::Aiff, AudioCodec::Auto), [Int16, Int24, Int32, Float32]);
    assert_eq!(supported(Format::ProRes, AudioCodec::Pcm), [Int16, Int24, Int32, Float32]);
    assert_eq!(supported(Format::MxfOp1a, AudioCodec::Auto), [Int16, Int24, Int32]);
    assert_eq!(supported(Format::MxfOpAtom, AudioCodec::Auto), [Int16, Int24, Int32]);
    assert_eq!(supported(Format::Flac, AudioCodec::Auto), [Int16, Int24, Int32]);
    assert_eq!(supported(Format::ProRes, AudioCodec::Flac), [Int16, Int24, Int32]);
    assert!(supported(Format::H264, AudioCodec::Auto).is_empty(), "MP4 is AAC");
    assert!(supported(Format::Mp3, AudioCodec::Auto).is_empty(), "MP3 has no sample size");
    // `bits` rounds down to a size; `float` only with 32
    let fmt = |bits, float| AudioSettings { bits, float, ..Default::default() }.sample_format();
    assert_eq!(
        [fmt(0, false), fmt(20, false), fmt(24, false), fmt(31, false), fmt(32, false), fmt(64, false), fmt(32, true)],
        [Int16, Int16, Int24, Int24, Int32, Int32, Float32]
    );
}

/// Hostile or contradictory settings (CLI, control channel, MCP, old presets) are errors, never
/// a panic or a silently different file.
#[test]
fn unsupported_sample_formats_are_refused() {
    let refused = |format: Format, codec: AudioCodec, bits: u16, float: bool| {
        let s = ExportSettings { format, path: "x".into(), audio: AudioSettings { codec, bits, float, ..Default::default() }, ..Default::default() };
        s.validate().err().map(|e| e.to_string())
    };
    assert!(refused(Format::Wav, AudioCodec::Auto, 24, true).is_some_and(|e| e.contains("32")));
    assert!(refused(Format::Flac, AudioCodec::Auto, 32, true).is_some_and(|e| e.contains("FLAC")));
    assert!(refused(Format::ProRes, AudioCodec::Flac, 32, true).is_some_and(|e| e.contains("FLAC")));
    assert!(refused(Format::MxfOp1a, AudioCodec::Auto, 32, true).is_some_and(|e| e.contains("MXF")));
    for (format, codec) in [(Format::Wav, AudioCodec::Auto), (Format::Aiff, AudioCodec::Auto), (Format::ProRes, AudioCodec::Pcm)] {
        assert_eq!(refused(format, codec, 32, true), None, "{format:?}");
    }
    assert_eq!(refused(Format::Flac, AudioCodec::Auto, 32, false), None);
    assert_eq!(refused(Format::MxfOp1a, AudioCodec::Auto, 32, false), None);
    // AAC has no sample size: the PCM / FLAC choice is ignored, as before
    assert_eq!(refused(Format::H264, AudioCodec::Auto, 32, true), None);
    // no audio, nothing to refuse
    let s = ExportSettings {
        format: Format::MxfOp1a,
        include_audio: false,
        audio: AudioSettings { bits: 32, float: true, ..Default::default() },
        ..Default::default()
    };
    assert!(s.validate().is_ok());
}

#[test]
fn sample_format_settings_round_trip_summary_and_estimate() {
    let s: ExportSettings = serde_json::from_value(serde_json::json!({"format": "wav", "audio": {"bits": 32, "float": true}})).unwrap();
    assert_eq!(s.audio.sample_format(), SampleFormat::Float32);
    let back: ExportSettings = serde_json::from_value(serde_json::to_value(&s).unwrap()).unwrap();
    assert_eq!(back.audio.sample_format(), SampleFormat::Float32);
    // settings saved before 32-bit audio read integers
    let old: AudioSettings = serde_json::from_value(serde_json::json!({"bits": 24})).unwrap();
    assert_eq!((old.float, old.sample_format()), (false, SampleFormat::Int24));
    let sum = |sf: SampleFormat, format: Format| {
        let mut s = ExportSettings { format, ..Default::default() };
        s.audio.set_sample_format(sf);
        (
            s.summary(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)).audio,
            s.estimate_bytes(64, 36, FrameRate::FPS_24, 48_000, Tick(TICKS_PER_SECOND)),
        )
    };
    let (f, f_bytes) = sum(SampleFormat::Float32, Format::Wav);
    assert!(f.starts_with("Uncompressed 32-bit float PCM, 48000 Hz"), "{f}");
    let (i, _) = sum(SampleFormat::Int32, Format::Wav);
    assert!(i.starts_with("Uncompressed 32-bit PCM"), "{i}");
    let (_, i16_bytes) = sum(SampleFormat::Int16, Format::Wav);
    assert!(f_bytes > i16_bytes * 19 / 10 && f_bytes < i16_bytes * 21 / 10, "{f_bytes} vs {i16_bytes}");
    let (flac, _) = sum(SampleFormat::Int32, Format::Flac);
    assert!(flac.starts_with("FLAC (lossless) 32-bit"), "{flac}");
}

/// FilmCraft imports its own 32-bit FLAC (symphonia rejected the frame header's 32-bit size code
/// as reserved: "unsupported media"), at full scale and with noise, sample for sample.
#[test]
fn own_importer_reads_32_bit_flac_at_full_scale() {
    let n = 20_000usize;
    let mut seed = 7u64;
    let noise: Vec<i32> = (0..n)
        .map(|_| {
            seed ^= seed << 13;
            seed ^= seed >> 7;
            seed ^= seed << 17;
            (seed >> 32) as u32 as i32
        })
        .collect();
    let extremes: Vec<i32> = (0..n).map(|i| if i % 3 == 0 { i32::MAX } else { i32::MIN + 1 }).collect();
    for level in [0u8, 5, 8] {
        let mut enc =
            craft_audio::flac::Encoder::new(craft_audio::flac::EncoderConfig { level, ..craft_audio::flac::EncoderConfig::new(48_000, 2, 32) }).unwrap();
        let mut file = enc.header(&[]);
        file.extend(enc.encode(&[&extremes, &noise]).unwrap());
        file.extend(enc.finish());
        let at = craft_audio::flac::STREAMINFO_OFFSET as usize;
        file[at..at + 34].copy_from_slice(&enc.streaminfo());
        let src = filmcraft_codecs::open_bytes("x.flac", file.into()).unwrap_or_else(|e| panic!("level {level}: {e}"));
        let a = src.audio(0, n, 48_000).unwrap();
        for (c, want) in [&extremes, &noise].iter().enumerate() {
            let got = &a.channels[c];
            assert_eq!(got.len(), n, "level {level} channel {c}");
            for (i, (&g, &w)) in got.iter().zip(want.iter()).enumerate() {
                let w = (f64::from(w) / 2_147_483_648.0) as f32;
                assert!((g - w).abs() <= 1e-6, "level {level} channel {c} sample {i}: {g} vs {w}");
            }
        }
    }
}

#[cfg(unix)]
#[test]
fn gif_output_goes_through_the_reserved_handle_and_a_displaced_path_is_an_error() {
    let (p, seq, m) = matte([1.0, 0.0, 0.0, 1.0], 32, 18, None);
    let dir = Scratch::new("gif-reserved");
    let path = dir.path("out.gif");
    let file = Arc::new(std::fs::OpenOptions::new().read(true).write(true).create_new(true).open(&path).unwrap());
    let settings = ExportSettings {
        format: Format::Gif,
        path: path.clone(),
        include_audio: false,
        range: Some(TimeRange::new(Tick::ZERO, FrameRate::FPS_24.tick_of(2))),
        output_file: Some(file.clone()),
        ..Default::default()
    };
    // the entry still names the reservation: the GIF lands there
    export(&p, seq, &settings, &m, &Progress::default()).unwrap();
    assert!(std::fs::read(&path).unwrap().starts_with(b"GIF8"), "the reserved file holds the GIF");
    // the directory entry is replaced after the reservation: no success for a file nobody can reach,
    // and the replacement is left alone
    std::fs::remove_file(&path).unwrap();
    std::fs::write(&path, b"decoy").unwrap();
    assert!(export(&p, seq, &settings, &m, &Progress::default()).is_err());
    assert_eq!(std::fs::read(&path).unwrap(), b"decoy", "the replaced entry must not be written");
}