Skip to main content

webpkit_cli/
effort.rs

1//! Map cwebp's effort dials onto the three-level codec presets.
2//!
3//! For **lossless** output all of cwebp's numeric effort knobs (`-m` / `-z` /
4//! `-q`) collapse onto the three-level [`Effort`], chosen so each flag's *default*
5//! (`-m 4` / `-z 6` / `-q 75`) lands on Balanced; when several are given, `-m`
6//! wins over `-z` wins over `-q`. For **lossy** output `-q` is the real quality
7//! (not effort), so only `-m` selects the effort [`Effort`], using the same
8//! three-tier `-m` buckets.
9
10use webpkit::Effort;
11
12/// Resolve the lossless effort flags to an [`Effort`] (Balanced when none given).
13#[must_use]
14pub fn resolve(method: Option<i64>, level: Option<i64>, quality: Option<f64>) -> Effort {
15    match (method, level, quality) {
16        (Some(m), _, _) => from_m(m),
17        (_, Some(z), _) => from_z(z),
18        (_, _, Some(q)) => from_q(q),
19        _ => Effort::Balanced,
20    }
21}
22
23/// Resolve the lossy effort [`Effort`] from `-m` alone (Balanced by default),
24/// using the same three-tier `-m` buckets as the lossless path.
25#[must_use]
26pub const fn lossy_method(method: Option<i64>) -> Effort {
27    match method {
28        Some(m) if m <= 2 => Effort::Fast,
29        Some(m) if m <= 5 => Effort::Balanced,
30        Some(_) => Effort::Best,
31        None => Effort::Balanced,
32    }
33}
34
35/// Clamp a cwebp `-q` float to the encoder's integer quality (`0..=100`).
36///
37/// `-q` values outside the range saturate, matching cwebp. The nearest integer is
38/// found by scanning `0..=100` rather than casting the float, which keeps the
39/// conversion free of a lossy `f64 as u8` cast.
40#[must_use]
41pub fn lossy_quality(quality: f64) -> u8 {
42    let target = quality.clamp(0.0, 100.0).round();
43    (0..=100u8).find(|&n| f64::from(n) >= target).unwrap_or(100)
44}
45
46const fn from_m(m: i64) -> Effort {
47    if m <= 2 {
48        Effort::Fast
49    } else if m <= 5 {
50        Effort::Balanced
51    } else {
52        Effort::Best
53    }
54}
55
56const fn from_z(z: i64) -> Effort {
57    if z <= 2 {
58        Effort::Fast
59    } else if z <= 6 {
60        Effort::Balanced
61    } else {
62        Effort::Best
63    }
64}
65
66fn from_q(q: f64) -> Effort {
67    if q < 34.0 {
68        Effort::Fast
69    } else if q < 90.0 {
70        Effort::Balanced
71    } else {
72        Effort::Best
73    }
74}
75
76#[cfg(test)]
77mod tests {
78    use webpkit::Effort;
79
80    use super::{lossy_method, lossy_quality, resolve};
81
82    #[test]
83    fn defaults_to_balanced() {
84        assert_eq!(resolve(None, None, None), Effort::Balanced);
85    }
86
87    #[test]
88    fn lossy_method_buckets_on_dash_m_only() {
89        assert_eq!(lossy_method(None), Effort::Balanced);
90        assert_eq!(lossy_method(Some(0)), Effort::Fast);
91        assert_eq!(lossy_method(Some(2)), Effort::Fast);
92        assert_eq!(lossy_method(Some(4)), Effort::Balanced);
93        assert_eq!(lossy_method(Some(5)), Effort::Balanced);
94        assert_eq!(lossy_method(Some(6)), Effort::Best);
95    }
96
97    #[test]
98    fn lossy_quality_rounds_and_saturates() {
99        assert_eq!(lossy_quality(75.0), 75);
100        assert_eq!(lossy_quality(0.0), 0);
101        assert_eq!(lossy_quality(100.0), 100);
102        assert_eq!(lossy_quality(101.0), 100);
103        assert_eq!(lossy_quality(-5.0), 0);
104        assert_eq!(lossy_quality(79.4), 79);
105        assert_eq!(lossy_quality(79.6), 80);
106    }
107
108    #[test]
109    fn method_flag_buckets() {
110        assert_eq!(resolve(Some(0), None, None), Effort::Fast);
111        assert_eq!(resolve(Some(4), None, None), Effort::Balanced);
112        assert_eq!(resolve(Some(6), None, None), Effort::Best);
113    }
114
115    #[test]
116    fn level_and_quality_buckets() {
117        assert_eq!(resolve(None, Some(1), None), Effort::Fast);
118        assert_eq!(resolve(None, Some(9), None), Effort::Best);
119        assert_eq!(resolve(None, None, Some(10.0)), Effort::Fast);
120        assert_eq!(resolve(None, None, Some(100.0)), Effort::Best);
121    }
122
123    #[test]
124    fn method_wins_over_level_and_quality() {
125        assert_eq!(resolve(Some(0), Some(9), Some(100.0)), Effort::Fast);
126        assert_eq!(resolve(None, Some(0), Some(100.0)), Effort::Fast);
127    }
128}