Skip to main content

webpkit_cli/cli/
cwebp.rs

1//! The `cwebp` drop-in: libwebp's `cwebp` command grammar, lossy by default.
2//!
3//! Accepts the familiar single-dash flags (`-o`, `-q`, `-m`, `-z`, `-lossless`,
4//! `-metadata`, `-quiet`, `-v`, ...). Like libwebp's `cwebp`, output is **lossy
5//! (`VP8 `) by default**; `-lossless` (or `-z`) switches to lossless (`VP8L`).
6//! `-q` is quality in lossy mode and effort in lossless mode. Unsupported lossy /
7//! preprocessing knobs are rejected with a clear message rather than silently
8//! ignored.
9
10use std::{ffi::OsString, path::PathBuf, process::ExitCode};
11
12use crate::{
13    codec::{self, EncodeMode},
14    effort,
15    error::CliError,
16    format::{self, InputFormat},
17    io::{Sink, Source},
18    metadata::{MetadataField, Selection},
19    report::Reporter,
20};
21
22/// Parse `cwebp`-style arguments, encode, and return a process exit code.
23#[must_use]
24pub fn main() -> ExitCode {
25    let args: Vec<OsString> = std::env::args_os().skip(1).collect();
26    match run(&args) {
27        Ok(()) => ExitCode::SUCCESS,
28        Err(err) => {
29            crate::report::error(&err);
30            err.exit_code()
31        },
32    }
33}
34
35/// A parsed `cwebp` invocation.
36#[derive(Default)]
37struct Config {
38    input: Option<PathBuf>,
39    output: Option<PathBuf>,
40    method: Option<i64>,
41    level: Option<i64>,
42    quality: Option<f64>,
43    /// Lossless (`VP8L`) output; set by `-lossless` or `-z`. Default is lossy.
44    lossless: bool,
45    metadata: Vec<MetadataField>,
46    verbose: u8,
47    quiet: bool,
48}
49
50impl Config {
51    /// The codec and knobs this invocation selects.
52    ///
53    /// Lossless maps `-m`/`-z`/`-q` onto the effort method; lossy takes its
54    /// quality from `-q` (default 75) and effort from `-m` (default Balanced).
55    fn encode_mode(&self) -> EncodeMode {
56        if self.lossless {
57            EncodeMode::Lossless(effort::resolve(self.method, self.level, self.quality))
58        } else {
59            EncodeMode::Lossy {
60                quality: effort::lossy_quality(self.quality.unwrap_or(75.0)),
61                method: effort::lossy_method(self.method),
62            }
63        }
64    }
65}
66
67fn run(args: &[OsString]) -> Result<(), CliError> {
68    let config = match parse(args)? {
69        Parsed::Run(config) => config,
70        Parsed::Handled => return Ok(()),
71    };
72    let reporter = Reporter::new(config.verbose, config.quiet);
73    let mode = config.encode_mode();
74    let input = config
75        .input
76        .ok_or_else(|| CliError::Usage("no input file (use `-` for stdin)".to_owned()))?;
77    let output = config
78        .output
79        .ok_or_else(|| CliError::Usage("no output file (use `-o <file>`, or `-o -`)".to_owned()))?;
80
81    let source = Source::from_arg(&input);
82    let sink = Sink::from_arg(&output);
83    let bytes = source.read()?;
84    let format = InputFormat::resolve(None, source.extension().as_deref(), &bytes);
85    reject_lossy_source(&bytes, format, &source.label())?;
86
87    let image = format::read_image(&bytes, format, None)?;
88    let metadata = Selection::from_fields(&config.metadata).apply(image.metadata());
89    let webp = codec::encode(&image, mode, metadata)?;
90    sink.write(&webp)?;
91    reporter.status(&format!(
92        "{} -> {} ({}x{}, {} bytes)",
93        source.label(),
94        sink.label(),
95        image.width(),
96        image.height(),
97        webp.len(),
98    ));
99    Ok(())
100}
101
102enum Parsed {
103    Run(Box<Config>),
104    Handled,
105}
106
107#[allow(
108    clippy::too_many_lines,
109    reason = "a flat cwebp flag table reads more clearly than fragmenting it"
110)]
111fn parse(args: &[OsString]) -> Result<Parsed, CliError> {
112    let mut config = Config::default();
113    let mut index = 0;
114    while index < args.len() {
115        let token = args[index].to_string_lossy().into_owned();
116        match token.as_str() {
117            "-h" | "-H" | "-help" | "--help" => {
118                print_help();
119                return Ok(Parsed::Handled);
120            },
121            "-version" | "--version" => {
122                print_version();
123                return Ok(Parsed::Handled);
124            },
125            "-o" => config.output = Some(PathBuf::from(value_os(args, &mut index, "-o")?)),
126            "-q" => config.quality = Some(parse_f64(&value(args, &mut index, "-q")?)?),
127            "-m" => config.method = Some(parse_i64(&value(args, &mut index, "-m")?)?),
128            // `-z` is a lossless preset, so it also switches to lossless output.
129            "-z" => {
130                config.level = Some(parse_i64(&value(args, &mut index, "-z")?)?);
131                config.lossless = true;
132            },
133            "-lossless" => config.lossless = true,
134            "-metadata" => {
135                config
136                    .metadata
137                    .extend(parse_metadata(&value(args, &mut index, "-metadata")?)?);
138            },
139            "-quiet" => config.quiet = true,
140            "-v" => config.verbose = config.verbose.saturating_add(1),
141            // Accepted for compatibility, but a no-op here. `-exact` preserves the
142            // RGB of fully-transparent pixels — already this encoder's behavior, as
143            // it never rewrites hidden RGB — so it is accepted rather than rejected.
144            "-short" | "-progress" | "-exact" | "-noalpha" | "-low_memory" | "-noasm" | "-mt" => {},
145            // Accepted-and-ignored options that consume one value. Alpha is always
146            // lossless here, so its tuning knobs have no effect.
147            "-alpha_q" | "-alpha_method" | "-alpha_filter" | "-blend_alpha" => {
148                let _ = value(args, &mut index, &token)?;
149            },
150            "--" => {
151                index += 1;
152                if index < args.len() {
153                    config.input = Some(PathBuf::from(&args[index]));
154                }
155            },
156            other if is_rejected(other) => return Err(reject(other)),
157            other if other.starts_with('-') && other.len() > 1 => {
158                return Err(CliError::Usage(format!("unknown option `{other}`")));
159            },
160            _ => config.input = Some(PathBuf::from(&args[index])),
161        }
162        index += 1;
163    }
164    Ok(Parsed::Run(Box::new(config)))
165}
166
167/// Rate-control and preprocessing knobs this encoder does not implement. They are
168/// rejected (rather than silently ignored) so a caller is never misled into
169/// thinking, e.g., a `-size` target or `-crop` took effect.
170fn is_rejected(flag: &str) -> bool {
171    matches!(
172        flag,
173        "-near_lossless"
174            | "-size"
175            | "-psnr"
176            | "-pass"
177            | "-sns"
178            | "-f"
179            | "-sharpness"
180            | "-segments"
181            | "-partition_limit"
182            | "-jpeg_like"
183            | "-sharp_yuv"
184            | "-hint"
185            | "-af"
186            | "-pre"
187            | "-map"
188            | "-crop"
189            | "-resize"
190            | "-preset"
191    )
192}
193
194fn reject(flag: &str) -> CliError {
195    CliError::Usage(format!(
196        "`{flag}` is a rate-control or preprocessing option unsupported by this \
197         encoder"
198    ))
199}
200
201/// Reject clearly-lossy source images with an actionable message.
202fn reject_lossy_source(bytes: &[u8], format: InputFormat, label: &str) -> Result<(), CliError> {
203    if bytes.starts_with(&[0xff, 0xd8, 0xff]) {
204        return Err(CliError::Format(format!(
205            "{label} is a JPEG (a lossy source); convert it to PNG first"
206        )));
207    }
208    if format == InputFormat::Raw {
209        return Err(CliError::Format(format!(
210            "{label}: unsupported input; encode from PNG, PPM, or PAM"
211        )));
212    }
213    Ok(())
214}
215
216fn value(args: &[OsString], index: &mut usize, flag: &str) -> Result<String, CliError> {
217    Ok(value_os(args, index, flag)?.to_string_lossy().into_owned())
218}
219
220fn value_os(args: &[OsString], index: &mut usize, flag: &str) -> Result<OsString, CliError> {
221    *index += 1;
222    args.get(*index)
223        .cloned()
224        .ok_or_else(|| CliError::Usage(format!("`{flag}` needs a value")))
225}
226
227fn parse_i64(text: &str) -> Result<i64, CliError> {
228    text.parse()
229        .map_err(|_| CliError::Usage(format!("expected an integer, got `{text}`")))
230}
231
232fn parse_f64(text: &str) -> Result<f64, CliError> {
233    text.parse()
234        .map_err(|_| CliError::Usage(format!("expected a number, got `{text}`")))
235}
236
237fn parse_metadata(list: &str) -> Result<Vec<MetadataField>, CliError> {
238    list.split(',')
239        .map(|item| match item.trim() {
240            "all" => Ok(MetadataField::All),
241            "none" => Ok(MetadataField::None),
242            "icc" => Ok(MetadataField::Icc),
243            "exif" => Ok(MetadataField::Exif),
244            "xmp" => Ok(MetadataField::Xmp),
245            other => Err(CliError::Usage(format!(
246                "unknown -metadata value `{other}`"
247            ))),
248        })
249        .collect()
250}
251
252#[allow(
253    clippy::print_stdout,
254    reason = "help/version print to stdout by CLI convention"
255)]
256fn print_help() {
257    println!(
258        "cwebp (webpkit) — encode PNG/PPM/PAM to WebP (lossy by default)\n\n\
259         Usage: cwebp [options] <input> -o <output.webp>\n\n\
260         Options:\n\
261         \x20 -o <file>        output file (`-` for stdout)\n\
262         \x20 -q <float>       lossy quality 0-100 (default 75); effort in -lossless mode\n\
263         \x20 -m <int>         method 0-6 (effort)\n\
264         \x20 -lossless        encode losslessly (VP8L) instead of lossy (VP8)\n\
265         \x20 -z <int>         lossless level 0-9 (implies -lossless)\n\
266         \x20 -metadata <list> all,none,icc,exif,xmp (default: all)\n\
267         \x20 -quiet / -v      quieter / more verbose\n\
268         \x20 -version         print version\n"
269    );
270}
271
272#[allow(
273    clippy::print_stdout,
274    reason = "help/version print to stdout by CLI convention"
275)]
276fn print_version() {
277    println!("cwebp (webpkit) {}", env!("CARGO_PKG_VERSION"));
278}