Skip to main content

autoeq_core/
peq_model.rs

1use clap::ValueEnum;
2use std::fmt;
3
4/// PEQ model types that define the structure and constraints of the equalizer.
5#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
6pub enum PeqModel {
7    #[value(name = "pk")]
8    Pk,
9    #[value(name = "hp-pk")]
10    HpPk,
11    #[value(name = "hp-pk-lp")]
12    HpPkLp,
13    #[value(name = "ls-pk")]
14    LsPk,
15    #[value(name = "ls-pk-hs")]
16    LsPkHs,
17    #[value(name = "free-pk-free")]
18    FreePkFree,
19    #[value(name = "free")]
20    Free,
21}
22
23impl fmt::Display for PeqModel {
24    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
25        f.write_str(match self {
26            Self::Pk => "pk",
27            Self::HpPk => "hp-pk",
28            Self::HpPkLp => "hp-pk-lp",
29            Self::LsPk => "ls-pk",
30            Self::LsPkHs => "ls-pk-hs",
31            Self::FreePkFree => "free-pk-free",
32            Self::Free => "free",
33        })
34    }
35}
36
37impl PeqModel {
38    pub fn all() -> Vec<Self> {
39        vec![
40            Self::Pk,
41            Self::HpPk,
42            Self::LsPk,
43            Self::HpPkLp,
44            Self::LsPkHs,
45            Self::FreePkFree,
46            Self::Free,
47        ]
48    }
49
50    pub fn description(&self) -> &'static str {
51        match self {
52            Self::Pk => "All filters are peak/bell filters",
53            Self::HpPk => "First filter is highpass, rest are peak filters",
54            Self::HpPkLp => "First filter is highpass, last is lowpass, rest are peak filters",
55            Self::LsPk => "First filter is low shelve, rest are peak filters",
56            Self::LsPkHs => {
57                "First filter is low shelve, last is high shelve, rest are peak filters"
58            }
59            Self::FreePkFree => "First and last filters can be any type, middle filters are peak",
60            Self::Free => "All filters can be any type (peak, highpass, lowpass, shelf)",
61        }
62    }
63}
64
65impl std::str::FromStr for PeqModel {
66    type Err = String;
67
68    fn from_str(s: &str) -> Result<Self, Self::Err> {
69        match s {
70            "pk" => Ok(Self::Pk),
71            "hp-pk" => Ok(Self::HpPk),
72            "hp-pk-lp" => Ok(Self::HpPkLp),
73            "ls-pk" => Ok(Self::LsPk),
74            "ls-pk-hs" => Ok(Self::LsPkHs),
75            "free-pk-free" => Ok(Self::FreePkFree),
76            "free" => Ok(Self::Free),
77            _ => Err(format!("Unknown PEQ model: {s}")),
78        }
79    }
80}