1use 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#[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#[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: bool,
45 metadata: Vec<MetadataField>,
46 verbose: u8,
47 quiet: bool,
48}
49
50impl Config {
51 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" => {
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 "-short" | "-progress" | "-exact" | "-noalpha" | "-low_memory" | "-noasm" | "-mt" => {},
145 "-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
167fn 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
201fn 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}