use crate::cli::Command;
use crate::metadata::policy::{ExifPolicy, parse_tag_list};
use clap::ValueEnum;
#[cfg(feature = "anim-apng")]
pub use crate::converter::apng::ApngOptions;
pub use crate::converter::avif::{AlphaColorMode, AvifOptions, BitDepth, ColorModel};
pub use crate::converter::gif::GifOptions;
#[cfg(feature = "jxl")]
pub use crate::converter::jxl::{JxlBitDepthChoice, JxlColorEncodingChoice, JxlOptions};
#[cfg(feature = "opt-oxipng")]
pub use crate::converter::oxipng::{
OxipngFilter, OxipngInterlace, OxipngLevel, OxipngOptions, OxipngReduction, OxipngStrip,
};
pub use crate::converter::png::{CompressionType, FilterType, PngOptions};
pub use crate::converter::webp::WebpOptions;
#[cfg(feature = "anim-webp")]
pub use crate::converter::webp_anim::WebpAnimOptions;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum AnimatedInputPolicy {
#[default]
FirstFrame,
Error,
}
#[derive(
Clone, Copy, Debug, Default, ValueEnum, PartialEq, Eq, serde::Serialize, serde::Deserialize,
)]
pub enum HeifImagePolicy {
#[default]
Primary,
All,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ConversionConfig {
pub pattern: String,
pub output: String,
pub reverse_processing_order: bool,
pub overwrite_if_smaller: bool,
pub overwrite_existing: bool,
pub discard_if_larger_than_input: bool,
pub discard_input_alpha_channel: bool,
pub exif: ExifPolicy,
pub heif_image_policy: HeifImagePolicy,
pub animated_input: AnimatedInputPolicy,
pub max_animation_memory_mib: u64,
}
impl Default for ConversionConfig {
fn default() -> Self {
ConversionConfig {
pattern: String::new(),
output: String::new(),
reverse_processing_order: false,
overwrite_if_smaller: false,
overwrite_existing: false,
discard_if_larger_than_input: false,
discard_input_alpha_channel: false,
exif: ExifPolicy::default(),
heif_image_policy: HeifImagePolicy::default(),
animated_input: AnimatedInputPolicy::default(),
max_animation_memory_mib: 4096,
}
}
}
impl ConversionConfig {
#[must_use]
pub fn from_args(args: &crate::cli::CliArgs) -> Self {
ConversionConfig {
pattern: args.pattern.clone(),
output: args.output.clone().unwrap_or_default(),
reverse_processing_order: args.reverse_processing_order.unwrap_or_default(),
overwrite_if_smaller: args.overwrite_if_smaller.unwrap_or_default(),
overwrite_existing: args.overwrite_existing.unwrap_or_default(),
discard_if_larger_than_input: args.discard_if_larger_than_input.unwrap_or_default(),
discard_input_alpha_channel: args.discard_input_alpha_channel.unwrap_or_default(),
exif: exif_policy_from_args(args),
heif_image_policy: heif_image_policy_from_args(args),
animated_input: match args.animated_input {
Some(crate::cli::AnimatedInputArg::FirstFrame) | None => {
AnimatedInputPolicy::FirstFrame
}
Some(crate::cli::AnimatedInputArg::Error) => AnimatedInputPolicy::Error,
},
max_animation_memory_mib: args.max_animation_memory.unwrap_or(4096),
}
}
}
#[cfg(all(feature = "dec-heif", any(not(target_os = "windows"), target_abi = "llvm")))]
fn heif_image_policy_from_args(args: &crate::cli::CliArgs) -> HeifImagePolicy {
args.heif_image_policy.unwrap_or_default()
}
#[cfg(any(not(feature = "dec-heif"), all(target_os = "windows", not(target_abi = "llvm"))))]
fn heif_image_policy_from_args(_args: &crate::cli::CliArgs) -> HeifImagePolicy {
HeifImagePolicy::default()
}
fn exif_policy_from_args(args: &crate::cli::CliArgs) -> ExifPolicy {
use crate::cli::ExifPolicyArg;
if args.exif_except.is_some() && args.exif_only.is_some() {
unreachable!("clap enforces mutual exclusion");
}
let selector_lists_used = args.exif_except.is_some() || args.exif_only.is_some();
match args.exif {
Some(ExifPolicyArg::Filter) => match (&args.exif_except, &args.exif_only) {
(Some(tags), None) => selectors_or_exit(tags, true),
(None, Some(tags)) => selectors_or_exit(tags, false),
_ => exit_with_exif_error(
"--exif filter requires either --exif-except <TAGS> or --exif-only <TAGS>",
),
},
Some(ExifPolicyArg::Keep) if !selector_lists_used => ExifPolicy::Keep,
Some(ExifPolicyArg::Strip) if !selector_lists_used => ExifPolicy::Strip,
None if !selector_lists_used => ExifPolicy::Strip,
_ => exit_with_exif_error(
"--exif-except and --exif-only are mutually exclusive and require --exif filter",
),
}
}
fn selectors_or_exit(specs: &[String], except: bool) -> ExifPolicy {
match parse_tag_list(specs) {
Ok(selectors) if except => ExifPolicy::FilterExcept(selectors),
Ok(selectors) => ExifPolicy::KeepOnly(selectors),
Err(message) => exit_with_exif_error(&message),
}
}
fn exit_with_exif_error(message: &str) -> ! {
eprintln!("Error: {message}");
eprintln!("Run with --exif-list-tags to print recognized tag names.");
std::process::exit(2);
}
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum EncoderConfig {
Webp(WebpOptions),
WebpImage,
Avif(AvifOptions),
Png(PngOptions),
Jpeg,
#[cfg(feature = "jxl")]
Jxl(JxlOptions),
#[cfg(feature = "opt-oxipng")]
Oxipng(OxipngOptions),
#[cfg(feature = "anim-webp")]
WebpAnim(WebpAnimOptions),
#[cfg(feature = "anim-apng")]
Apng(ApngOptions),
Gif(GifOptions),
}
impl EncoderConfig {
#[must_use]
pub fn from_args(command: &Command) -> Option<Self> {
match command {
Command::Webp { lossless, quality } => Some(EncoderConfig::Webp(WebpOptions {
lossless: lossless.unwrap_or_default(),
quality: quality.unwrap_or(90.),
})),
Command::WebpImage {} => Some(EncoderConfig::WebpImage),
Command::Avif {
quality,
speed,
bit_depth,
color_model,
alpha_color_mode,
alpha_quality,
} => Some(EncoderConfig::Avif(AvifOptions {
quality: quality.unwrap_or(90.),
speed: speed.unwrap_or(3),
bit_depth: *bit_depth,
color_model: *color_model,
alpha_color_mode: *alpha_color_mode,
alpha_quality: alpha_quality.unwrap_or(90.),
})),
Command::Png {
compression_type,
filter_type,
} => Some(EncoderConfig::Png(PngOptions {
compression_type: *compression_type,
filter_type: *filter_type,
})),
Command::Jpeg {} => Some(EncoderConfig::Jpeg),
#[cfg(feature = "jxl")]
Command::Jxl {
quality,
distance,
lossless,
effort,
container,
original_profile,
decoding_speed,
intensity_target,
bit_depth,
color_encoding,
settings,
} => {
if let Some(quality) = quality
&& !(0.0..=100.0).contains(quality)
{
jxl_config_error("--quality must be between 0 and 100");
}
if let Some(distance) = distance
&& !(0.0..=25.0).contains(distance)
{
jxl_config_error("--distance must be between 0.0 and 25.0");
}
let bit_depth = bit_depth.map(|depth| match depth {
8 => JxlBitDepthChoice::Eight,
16 => JxlBitDepthChoice::Sixteen,
other => {
jxl_config_error(&format!("--bit-depth must be 8 or 16 (got {other})"));
}
});
let advanced = parse_jxl_settings(settings);
Some(EncoderConfig::Jxl(JxlOptions {
lossless: lossless.unwrap_or_default(),
quality: *quality,
distance: *distance,
effort: effort.unwrap_or(7),
container: container.unwrap_or_default(),
original_profile: original_profile.unwrap_or_default(),
decoding_speed: decoding_speed.unwrap_or(0),
intensity_target: *intensity_target,
bit_depth,
color_encoding: *color_encoding,
advanced,
#[cfg(feature = "exif")]
exif_policy: Default::default(),
}))
}
#[cfg(feature = "opt-oxipng")]
Command::Oxipng {
level,
zopfli,
zopfli_iterations,
interlace,
strip,
filters,
optimize_alpha,
no_reduction,
scale_16,
fix_errors,
timeout_secs,
} => Some(EncoderConfig::Oxipng(OxipngOptions {
level: level.unwrap_or_default(),
zopfli: zopfli.unwrap_or_default(),
zopfli_iterations: zopfli_iterations.unwrap_or(15),
interlace: interlace.unwrap_or_default(),
strip: strip.unwrap_or_default(),
strip_explicit: strip.is_some(),
#[cfg(feature = "exif")]
exif_policy: Default::default(),
filters: filters.clone(),
optimize_alpha: optimize_alpha.unwrap_or_default(),
no_reduction: no_reduction.clone(),
scale_16: scale_16.unwrap_or_default(),
fix_errors: fix_errors.unwrap_or_default(),
timeout: timeout_secs.map(std::time::Duration::from_secs),
})),
#[cfg(feature = "anim-webp")]
Command::WebpAnim {
lossless,
quality,
kmin,
kmax,
minimize_size,
allow_mixed,
method,
} => Some(EncoderConfig::WebpAnim(WebpAnimOptions {
lossless: lossless.unwrap_or_default(),
quality: quality.unwrap_or(90.),
kmin: *kmin,
kmax: *kmax,
minimize_size: minimize_size.unwrap_or_default(),
allow_mixed: allow_mixed.unwrap_or_default(),
method: *method,
})),
#[cfg(feature = "anim-apng")]
Command::Apng {
compression_type,
filter_type,
} => Some(EncoderConfig::Apng(ApngOptions {
compression_type: *compression_type,
filter_type: *filter_type,
})),
Command::Gif { speed } => Some(EncoderConfig::Gif(GifOptions { speed: *speed })),
Command::Clean {} => None,
}
}
}
#[cfg(feature = "jxl")]
fn jxl_config_error(message: &str) -> ! {
eprintln!("Error: {message}");
std::process::exit(2);
}
#[cfg(feature = "jxl")]
fn parse_jxl_settings(settings: &[String]) -> Vec<(String, i64)> {
let mut parsed = Vec::with_capacity(settings.len());
for setting in settings {
let Some((id, value)) = setting.split_once('=') else {
jxl_config_error(&format!(
"invalid --setting {setting:?}; expected ID=VALUE (e.g. --setting brotli_effort=9)"
));
};
let value = match value.trim().parse::<i64>() {
Ok(value) => value,
Err(_) => jxl_config_error(&format!(
"invalid --setting value {value:?} for id {id:?}; expected an integer"
)),
};
parsed.push((id.trim().to_string(), value));
}
parsed
}