c60dbd12a5
#719 is failing tests due to requiring a newer version of rust than we currently specify. This PR updates to 1.85.1 and sets the edition to 2024. I've also updated dependencies and runner images, using the ubuntu arm runner which removes the need for qemu and other hacks. Closes #719.
432 lines
14 KiB
Rust
432 lines
14 KiB
Rust
#![warn(trivial_casts, trivial_numeric_casts, unused_import_braces)]
|
|
#![deny(missing_debug_implementations, missing_copy_implementations)]
|
|
#![warn(clippy::expl_impl_clone_on_copy)]
|
|
#![warn(clippy::float_cmp_const)]
|
|
#![warn(clippy::linkedlist)]
|
|
#![warn(clippy::map_flatten)]
|
|
#![warn(clippy::match_same_arms)]
|
|
#![warn(clippy::mem_forget)]
|
|
#![warn(clippy::mut_mut)]
|
|
#![warn(clippy::mutex_integer)]
|
|
#![warn(clippy::needless_continue)]
|
|
#![warn(clippy::path_buf_push_overwrite)]
|
|
#![warn(clippy::range_plus_one)]
|
|
#![allow(clippy::cognitive_complexity)]
|
|
|
|
#[cfg(not(feature = "parallel"))]
|
|
mod rayon;
|
|
|
|
#[cfg(feature = "zopfli")]
|
|
use std::num::NonZeroU8;
|
|
use std::{
|
|
ffi::OsString, fs::DirBuilder, io::Write, path::PathBuf, process::ExitCode, time::Duration,
|
|
};
|
|
|
|
use clap::ArgMatches;
|
|
mod cli;
|
|
use indexmap::IndexSet;
|
|
use log::{Level, LevelFilter, error, warn};
|
|
use oxipng::{Deflaters, InFile, Options, OutFile, PngError, RowFilter, StripChunks};
|
|
use rayon::prelude::*;
|
|
|
|
use crate::cli::DISPLAY_CHUNKS;
|
|
|
|
fn main() -> ExitCode {
|
|
let matches = cli::build_command()
|
|
// Set the value parser for filters which isn't appropriate to do in the build_command function
|
|
.mut_arg("filters", |arg| {
|
|
arg.value_parser(|x: &str| {
|
|
parse_numeric_range_opts(x, 0, RowFilter::LAST)
|
|
.map_err(|_| "Invalid option for filters")
|
|
})
|
|
})
|
|
.after_help("Run `oxipng --help` to see full details of all options")
|
|
.after_long_help("")
|
|
.get_matches_from(std::env::args());
|
|
|
|
let (out_file, out_dir, opts) = match parse_opts_into_struct(&matches) {
|
|
Ok(x) => x,
|
|
Err(x) => {
|
|
error!("{x}");
|
|
return ExitCode::FAILURE;
|
|
}
|
|
};
|
|
|
|
let files = collect_files(
|
|
#[cfg(windows)]
|
|
matches
|
|
.get_many::<PathBuf>("files")
|
|
.unwrap()
|
|
.cloned()
|
|
.flat_map(apply_glob_pattern)
|
|
.collect(),
|
|
#[cfg(not(windows))]
|
|
matches
|
|
.get_many::<PathBuf>("files")
|
|
.unwrap()
|
|
.cloned()
|
|
.collect(),
|
|
&out_dir,
|
|
&out_file,
|
|
matches.get_flag("recursive"),
|
|
true,
|
|
);
|
|
|
|
let parallel_files = matches.get_flag("parallel-files");
|
|
let summary = if parallel_files {
|
|
files
|
|
.into_par_iter()
|
|
.map(|(input, output)| process_file(&input, &output, &opts))
|
|
.min()
|
|
} else {
|
|
files
|
|
.into_iter()
|
|
.map(|(input, output)| process_file(&input, &output, &opts))
|
|
.min()
|
|
};
|
|
|
|
match summary.unwrap_or(OptimizationResult::Skipped) {
|
|
OptimizationResult::Ok => ExitCode::SUCCESS,
|
|
OptimizationResult::Failed => ExitCode::FAILURE,
|
|
OptimizationResult::Skipped => ExitCode::from(3),
|
|
}
|
|
}
|
|
|
|
#[derive(Eq, PartialEq, Ord, PartialOrd)]
|
|
enum OptimizationResult {
|
|
Ok,
|
|
Failed,
|
|
Skipped,
|
|
}
|
|
|
|
fn collect_files(
|
|
files: Vec<PathBuf>,
|
|
out_dir: &Option<PathBuf>,
|
|
out_file: &OutFile,
|
|
recursive: bool,
|
|
top_level: bool, //explicitly specify files
|
|
) -> Vec<(InFile, OutFile)> {
|
|
let mut in_out_pairs = Vec::new();
|
|
let allow_stdin = top_level && files.len() == 1;
|
|
for input in files {
|
|
let using_stdin = allow_stdin && input.to_str() == Some("-");
|
|
if !using_stdin && input.is_dir() {
|
|
if recursive {
|
|
match input.read_dir() {
|
|
Ok(dir) => {
|
|
let files = dir.filter_map(|x| x.ok().map(|x| x.path())).collect();
|
|
in_out_pairs
|
|
.extend(collect_files(files, out_dir, out_file, recursive, false));
|
|
}
|
|
Err(e) => {
|
|
warn!("{}: {}", input.display(), e);
|
|
}
|
|
}
|
|
} else {
|
|
warn!("{} is a directory, skipping", input.display());
|
|
}
|
|
continue;
|
|
};
|
|
let out_file =
|
|
if let (Some(out_dir), &OutFile::Path { preserve_attrs, .. }) = (out_dir, out_file) {
|
|
let path = Some(out_dir.join(input.file_name().unwrap()));
|
|
OutFile::Path {
|
|
path,
|
|
preserve_attrs,
|
|
}
|
|
} else {
|
|
(*out_file).clone()
|
|
};
|
|
let in_file = if using_stdin {
|
|
InFile::StdIn
|
|
} else {
|
|
// Skip non png files if not given on top level
|
|
if !top_level && {
|
|
let extension = input.extension().map(|f| f.to_ascii_lowercase());
|
|
extension != Some(OsString::from("png"))
|
|
&& extension != Some(OsString::from("apng"))
|
|
} {
|
|
continue;
|
|
}
|
|
InFile::Path(input)
|
|
};
|
|
in_out_pairs.push((in_file, out_file));
|
|
}
|
|
in_out_pairs
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
fn apply_glob_pattern(path: PathBuf) -> Vec<PathBuf> {
|
|
let matches = path
|
|
.to_str()
|
|
// Use MatchOptions::default() to disable case-sensitivity
|
|
.and_then(|pattern| glob::glob_with(pattern, glob::MatchOptions::default()).ok())
|
|
.map(|paths| paths.flatten().collect::<Vec<_>>());
|
|
|
|
match matches {
|
|
Some(paths) if !paths.is_empty() => paths,
|
|
_ => vec![path],
|
|
}
|
|
}
|
|
|
|
fn parse_opts_into_struct(
|
|
matches: &ArgMatches,
|
|
) -> Result<(OutFile, Option<PathBuf>, Options), String> {
|
|
let log_level = match matches.get_count("verbose") {
|
|
_ if matches.get_flag("quiet") => LevelFilter::Off,
|
|
0 => LevelFilter::Info,
|
|
1 => LevelFilter::Debug,
|
|
_ => LevelFilter::Trace,
|
|
};
|
|
env_logger::builder()
|
|
.filter_module(module_path!(), log_level)
|
|
.format(|buf, record| {
|
|
match record.level() {
|
|
Level::Error | Level::Warn => {
|
|
let style = buf.default_level_style(record.level());
|
|
writeln!(buf, "{style}{}{style:#}", record.args())
|
|
}
|
|
// Leave info, debug and trace unstyled
|
|
_ => writeln!(buf, "{}", record.args()),
|
|
}
|
|
})
|
|
.init();
|
|
|
|
let mut opts = match matches.get_one::<String>("optimization") {
|
|
None => Options::default(),
|
|
Some(x) if x == "max" => Options::max_compression(),
|
|
Some(level) => Options::from_preset(level.parse::<u8>().unwrap()),
|
|
};
|
|
|
|
if let Some(x) = matches.get_one::<IndexSet<u8>>("filters") {
|
|
opts.filter.clear();
|
|
for &f in x {
|
|
opts.filter.insert(f.try_into().unwrap());
|
|
}
|
|
}
|
|
|
|
if let Some(&num) = matches.get_one::<u64>("timeout") {
|
|
opts.timeout = Some(Duration::from_secs(num));
|
|
}
|
|
|
|
let out_dir = if let Some(path) = matches.get_one::<PathBuf>("output_dir") {
|
|
if !path.exists() {
|
|
match DirBuilder::new().recursive(true).create(path) {
|
|
Ok(()) => (),
|
|
Err(x) => return Err(format!("Could not create output directory {x}")),
|
|
};
|
|
} else if !path.is_dir() {
|
|
return Err(format!(
|
|
"{} is an existing file (not a directory), cannot create directory",
|
|
path.display()
|
|
));
|
|
}
|
|
Some(path.to_owned())
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let out_file = if matches.get_flag("pretend") {
|
|
OutFile::None
|
|
} else if matches.get_flag("stdout") {
|
|
OutFile::StdOut
|
|
} else {
|
|
OutFile::Path {
|
|
path: matches.get_one::<PathBuf>("output_file").cloned(),
|
|
preserve_attrs: matches.get_flag("preserve"),
|
|
}
|
|
};
|
|
|
|
opts.optimize_alpha = matches.get_flag("alpha");
|
|
|
|
opts.scale_16 = matches.get_flag("scale16");
|
|
|
|
// The default value for fast depends on the preset - make sure we don't change when not provided
|
|
if matches.get_flag("fast") {
|
|
opts.fast_evaluation = matches.get_flag("fast");
|
|
}
|
|
|
|
opts.force = matches.get_flag("force");
|
|
|
|
opts.fix_errors = matches.get_flag("fix");
|
|
|
|
opts.bit_depth_reduction = !matches.get_flag("no-bit-reduction");
|
|
|
|
opts.color_type_reduction = !matches.get_flag("no-color-reduction");
|
|
|
|
opts.palette_reduction = !matches.get_flag("no-palette-reduction");
|
|
|
|
opts.grayscale_reduction = !matches.get_flag("no-grayscale-reduction");
|
|
|
|
if matches.get_flag("no-reductions") {
|
|
opts.bit_depth_reduction = false;
|
|
opts.color_type_reduction = false;
|
|
opts.palette_reduction = false;
|
|
opts.grayscale_reduction = false;
|
|
opts.interlace = None;
|
|
}
|
|
|
|
opts.idat_recoding = !matches.get_flag("no-recoding");
|
|
|
|
if let Some(x) = matches.get_one::<String>("interlace") {
|
|
opts.interlace = if x == "keep" {
|
|
None
|
|
} else {
|
|
x.parse::<u8>().unwrap().try_into().ok()
|
|
};
|
|
}
|
|
|
|
if let Some(keep) = matches.get_one::<String>("keep") {
|
|
let mut keep_display = false;
|
|
let mut names = keep
|
|
.split(',')
|
|
.filter_map(|name| {
|
|
if name == "display" {
|
|
keep_display = true;
|
|
return None;
|
|
}
|
|
Some(parse_chunk_name(name))
|
|
})
|
|
.collect::<Result<IndexSet<_>, _>>()?;
|
|
if keep_display {
|
|
names.extend(DISPLAY_CHUNKS.iter().copied());
|
|
}
|
|
opts.strip = StripChunks::Keep(names);
|
|
}
|
|
|
|
if let Some(strip) = matches.get_one::<String>("strip") {
|
|
if strip == "safe" {
|
|
opts.strip = StripChunks::Safe;
|
|
} else if strip == "all" {
|
|
opts.strip = StripChunks::All;
|
|
} else {
|
|
const FORBIDDEN_CHUNKS: [[u8; 4]; 5] =
|
|
[*b"IHDR", *b"IDAT", *b"tRNS", *b"PLTE", *b"IEND"];
|
|
let names = strip
|
|
.split(',')
|
|
.map(|x| {
|
|
if x == "safe" || x == "all" {
|
|
return Err(
|
|
"'safe' or 'all' presets for --strip should be used by themselves"
|
|
.to_owned(),
|
|
);
|
|
}
|
|
let name = parse_chunk_name(x)?;
|
|
if FORBIDDEN_CHUNKS.contains(&name) {
|
|
return Err(format!("{x} chunk is not allowed to be stripped"));
|
|
}
|
|
Ok(name)
|
|
})
|
|
.collect::<Result<_, _>>()?;
|
|
opts.strip = StripChunks::Strip(names);
|
|
}
|
|
}
|
|
|
|
if matches.get_flag("strip-safe") {
|
|
opts.strip = StripChunks::Safe;
|
|
}
|
|
|
|
#[cfg(feature = "zopfli")]
|
|
if matches.get_flag("zopfli") {
|
|
let iterations = *matches.get_one::<i64>("iterations").unwrap();
|
|
opts.deflate = Deflaters::Zopfli {
|
|
iterations: NonZeroU8::new(iterations as u8).unwrap(),
|
|
};
|
|
}
|
|
if let (Deflaters::Libdeflater { compression }, Some(x)) =
|
|
(&mut opts.deflate, matches.get_one::<i64>("compression"))
|
|
{
|
|
*compression = *x as u8;
|
|
}
|
|
|
|
#[cfg(feature = "parallel")]
|
|
if let Some(&threads) = matches.get_one::<usize>("threads") {
|
|
rayon::ThreadPoolBuilder::new()
|
|
.num_threads(threads)
|
|
.build_global()
|
|
.map_err(|err| err.to_string())?;
|
|
}
|
|
|
|
Ok((out_file, out_dir, opts))
|
|
}
|
|
|
|
fn parse_chunk_name(name: &str) -> Result<[u8; 4], String> {
|
|
name.trim()
|
|
.as_bytes()
|
|
.try_into()
|
|
.map_err(|_| format!("Invalid chunk name {name}"))
|
|
}
|
|
|
|
fn parse_numeric_range_opts(
|
|
input: &str,
|
|
min_value: u8,
|
|
max_value: u8,
|
|
) -> Result<IndexSet<u8>, String> {
|
|
const ERROR_MESSAGE: &str = "Not a valid input";
|
|
let mut items = IndexSet::new();
|
|
|
|
// one value
|
|
if let Ok(one_value) = input.parse::<u8>() {
|
|
if (min_value <= one_value) && (one_value <= max_value) {
|
|
items.insert(one_value);
|
|
return Ok(items);
|
|
}
|
|
}
|
|
|
|
// a range ("A-B")
|
|
let range_values = input.split('-').collect::<Vec<&str>>();
|
|
if range_values.len() == 2 {
|
|
let first_opt = range_values[0].parse::<u8>();
|
|
let second_opt = range_values[1].parse::<u8>();
|
|
if let (Ok(first), Ok(second)) = (first_opt, second_opt) {
|
|
if min_value <= first && first < second && second <= max_value {
|
|
for i in first..=second {
|
|
items.insert(i);
|
|
}
|
|
return Ok(items);
|
|
}
|
|
}
|
|
return Err(ERROR_MESSAGE.to_owned());
|
|
}
|
|
|
|
// a list ("A,B[,…]")
|
|
let list_items = input.split(',').collect::<Vec<&str>>();
|
|
if list_items.len() > 1 {
|
|
for value in list_items {
|
|
if let Ok(value_int) = value.parse::<u8>() {
|
|
if (min_value <= value_int)
|
|
&& (value_int <= max_value)
|
|
&& !items.contains(&value_int)
|
|
{
|
|
items.insert(value_int);
|
|
continue;
|
|
}
|
|
}
|
|
return Err(ERROR_MESSAGE.to_owned());
|
|
}
|
|
return Ok(items);
|
|
}
|
|
|
|
Err(ERROR_MESSAGE.to_owned())
|
|
}
|
|
|
|
fn process_file(input: &InFile, output: &OutFile, opts: &Options) -> OptimizationResult {
|
|
match oxipng::optimize(input, output, opts) {
|
|
// For optimizing single files, this will return the correct exit code always.
|
|
// For recursive optimization, the correct choice is a bit subjective.
|
|
// We're choosing to return a 0 exit code if ANY file in the set
|
|
// runs correctly.
|
|
// The reason for this is that recursion may pick up files that are not
|
|
// PNG files, and return an error for them.
|
|
// We don't really want to return an error code for those files.
|
|
Ok(_) => OptimizationResult::Ok,
|
|
Err(e @ PngError::C2PAMetadataPreventsChanges) => {
|
|
warn!("{input}: {e}");
|
|
OptimizationResult::Skipped
|
|
}
|
|
Err(e) => {
|
|
error!("{input}: {e}");
|
|
OptimizationResult::Failed
|
|
}
|
|
}
|
|
}
|