shrivel 0.2.1

Cross-platform FFmpeg orchestrator that transcodes videos to HEVC or AV1
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

//! Command-line interface definition.

use std::path::PathBuf;

use clap::{Parser, ValueEnum};

/// Output video codec.
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum Codec {
    #[default]
    Hevc,
    Av1,
}

impl std::fmt::Display for Codec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            Self::Hevc => "hevc",
            Self::Av1 => "av1",
        })
    }
}

/// Which encoder backend to use.
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub enum EncoderChoice {
    /// Probe the available encoders and pick the first one that works.
    Auto,
    /// NVIDIA NVENC (`hevc_nvenc` or `av1_nvenc`).
    Nvenc,
    /// Intel Quick Sync Video (`hevc_qsv` or `av1_qsv`).
    Qsv,
    /// AMD AMF (`hevc_amf` or `av1_amf`).
    Amf,
    /// Apple VideoToolbox (`hevc_videotoolbox`, HEVC only).
    Videotoolbox,
    /// CPU encoding with x265 (`libx265`) or SVT-AV1 (`libsvtav1`).
    Software,
}

/// Batch re-encode videos by orchestrating FFmpeg.
#[derive(Debug, Parser)]
#[command(name = "shrivel", version, about, long_about = None)]
pub struct Cli {
    /// Output video codec.
    #[arg(long, value_enum, default_value_t = Codec::default())]
    pub codec: Codec,
    /// Video file or directory containing source videos.
    #[arg(short, long, value_name = "DIR", default_value = "input")]
    pub input: PathBuf,

    /// Directory where converted videos are written (created if missing).
    #[arg(short, long, value_name = "DIR", default_value = "output")]
    pub output: PathBuf,

    /// Normalized compression value (0-51). Lower generally means better
    /// quality; shrivel maps it to the selected encoder's native scale.
    #[arg(
        long,
        value_name = "N",
        default_value_t = 26,
        value_parser = clap::value_parser!(u8).range(0..=51)
    )]
    pub cq: u8,

    /// Target frame rate. Omit to keep the source frame rate.
    #[arg(long, value_name = "FPS", value_parser = parse_fps)]
    pub fps: Option<f64>,

    /// Skip files whose video stream already uses the selected codec.
    #[arg(long, alias = "skip-hevc")]
    pub skip_same_codec: bool,

    /// Apply a light spatial/temporal denoise filter (hqdn3d).
    #[arg(long)]
    pub denoise: bool,

    /// Encoder backend.
    #[arg(short, long, value_enum, default_value_t = EncoderChoice::Auto)]
    pub encoder: EncoderChoice,

    /// Comma-separated list of input file extensions to process.
    #[arg(
        long,
        value_name = "EXT,...",
        value_delimiter = ',',
        default_value = "mp4"
    )]
    pub ext: Vec<String>,

    /// Do not overwrite output files that already exist (skip them instead).
    #[arg(long)]
    pub skip_existing: bool,

    /// Target width for scaling. Height is calculated automatically.
    #[arg(long, value_name = "WIDTH", value_parser = clap::value_parser!(u32).range(1..))]
    pub scale: Option<u32>,

    /// Print the FFmpeg commands that would run without executing them.
    #[arg(long)]
    pub dry_run: bool,
}

fn parse_fps(s: &str) -> Result<f64, String> {
    let value: f64 = s
        .parse()
        .map_err(|_| format!("`{s}` is not a valid number"))?;
    if value.is_finite() && value > 0.0 {
        Ok(value)
    } else {
        Err("frame rate must be greater than zero".to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn fps_parser_accepts_positive_numbers() {
        assert_eq!(parse_fps("29.97"), Ok(29.97));
        assert_eq!(parse_fps("30"), Ok(30.0));
    }

    #[test]
    fn fps_parser_rejects_invalid_values() {
        assert!(parse_fps("0").is_err());
        assert!(parse_fps("-5").is_err());
        assert!(parse_fps("abc").is_err());
        assert!(parse_fps("inf").is_err());
    }
}