deepshrink 0.3.3

Shrink media to a target size with one command. Local, private, no watermarks.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! End-to-end test for `--vmaf`: a quality-mode encode targeting a VMAF score
//! must produce a valid video and report a measured VMAF in a sane corridor.
//!
//! Requires ffmpeg/ffprobe **with the libvmaf filter**. Skips (passes) when any
//! of those is missing so local `cargo test` works without a full ffmpeg build.

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

fn have(tool: &str) -> bool {
    Command::new(tool)
        .arg("-version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

/// Whether the ffmpeg on PATH exposes the libvmaf filter.
fn have_libvmaf() -> bool {
    Command::new("ffmpeg")
        .args(["-hide_banner", "-filters"])
        .output()
        .map(|o| String::from_utf8_lossy(&o.stdout).contains("libvmaf"))
        .unwrap_or(false)
}

fn unique_dir() -> PathBuf {
    let mut d = std::env::temp_dir();
    d.push(format!("deepshrink-vmaf-it-{}", std::process::id()));
    std::fs::create_dir_all(&d).expect("create temp dir");
    d
}

fn generate_sample(dir: &Path) -> PathBuf {
    let sample = dir.join("sample.mp4");
    let status = Command::new("ffmpeg")
        .args([
            "-y",
            "-hide_banner",
            "-loglevel",
            "error",
            "-f",
            "lavfi",
            "-i",
            "testsrc2=duration=3:size=640x480:rate=30",
            "-c:v",
            "libx264",
            "-preset",
            "veryfast",
            "-b:v",
            "3M",
            "-pix_fmt",
            "yuv420p",
        ])
        .arg(&sample)
        .status()
        .expect("spawn ffmpeg");
    assert!(status.success(), "ffmpeg failed to generate the sample");
    sample
}

/// Pull the `"vmaf": <n>` value out of the JSON result line.
fn parse_json_vmaf(stdout: &str) -> Option<f64> {
    let key = "\"vmaf\":";
    let idx = stdout.rfind(key)? + key.len();
    let tail = stdout[idx..].trim_start();
    let end = tail.find([',', '}']).unwrap_or(tail.len());
    tail[..end].trim().parse::<f64>().ok()
}

#[test]
fn vmaf_quality_mode_reports_score() {
    if !have("ffmpeg") || !have("ffprobe") {
        eprintln!("skipping: ffmpeg/ffprobe not found in PATH");
        return;
    }
    if !have_libvmaf() {
        eprintln!("skipping: this ffmpeg build has no libvmaf filter");
        return;
    }

    let dir = unique_dir();
    let sample = generate_sample(&dir);
    let output = dir.join("sample.shrink.mp4");

    // Quality mode (no size target) + a VMAF target → CRF search.
    let out = Command::new(env!("CARGO_BIN_EXE_deepshrink"))
        .arg(&sample)
        .args(["--vmaf", "90", "--json"])
        .output()
        .expect("run deepshrink");
    assert!(
        out.status.success(),
        "deepshrink failed: {}",
        String::from_utf8_lossy(&out.stderr)
    );

    assert!(output.exists(), "expected output was not written");
    assert!(sample.exists(), "original was removed");

    let stdout = String::from_utf8_lossy(&out.stdout);
    let vmaf =
        parse_json_vmaf(&stdout).unwrap_or_else(|| panic!("no vmaf in JSON output: {stdout:?}"));
    // A measured score must land in a sane corridor; the synthetic pattern
    // compresses very well, so it should sit comfortably high.
    assert!(
        (60.0..=100.0).contains(&vmaf),
        "VMAF {vmaf} outside the expected corridor"
    );

    // The result must be a valid, playable H.264 video.
    let probe = Command::new("ffprobe")
        .args([
            "-v",
            "error",
            "-select_streams",
            "v:0",
            "-show_entries",
            "stream=codec_name",
            "-of",
            "csv=p=0",
        ])
        .arg(&output)
        .output()
        .expect("run ffprobe");
    assert!(probe.status.success(), "ffprobe rejected the output");
    let codec = String::from_utf8_lossy(&probe.stdout);
    assert!(
        codec.trim().starts_with("h264"),
        "unexpected codec: {codec:?}"
    );

    let _ = std::fs::remove_dir_all(&dir);
}