use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
#[serde(default)]
pub struct PsychoacousticSmoothingConfig {
pub low_freq_n: usize,
pub high_freq_n: usize,
pub low_freq: f64,
pub high_freq: f64,
}
impl Default for PsychoacousticSmoothingConfig {
fn default() -> Self {
Self {
low_freq_n: 48,
high_freq_n: 6,
low_freq: 100.0,
high_freq: 1_000.0,
}
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
#[serde(default)]
pub struct AsymmetricLossConfig {
pub peak_weight: f64,
pub dip_weight: f64,
pub bass_peak_weight: f64,
pub bass_dip_weight: f64,
pub transition_freq: f64,
}
impl Default for AsymmetricLossConfig {
fn default() -> Self {
Self {
peak_weight: 2.0,
dip_weight: 1.0,
bass_peak_weight: 5.0,
bass_dip_weight: 1.0,
transition_freq: 300.0,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[serde(default)]
pub struct FrequencyBandWeights {
pub bass_min: f64,
pub bass_max: f64,
pub mid_min: f64,
pub mid_max: f64,
pub treble_min: f64,
pub treble_max: f64,
pub bass_weight: f64,
pub mid_weight: f64,
pub treble_weight: f64,
}
impl Default for FrequencyBandWeights {
fn default() -> Self {
Self {
bass_min: 20.0,
bass_max: 200.0,
mid_min: 200.0,
mid_max: 4_000.0,
treble_min: 4_000.0,
treble_max: 20_000.0,
bass_weight: 2.0,
mid_weight: 1.0,
treble_weight: 0.8,
}
}
}
#[cfg(test)]
mod frequency_band_weights_tests {
use super::*;
#[test]
fn partial_frequency_band_weights_inherit_defaults() {
let parsed: FrequencyBandWeights = serde_json::from_str(r#"{"bass_weight": 3.5}"#).unwrap();
assert_eq!(parsed.bass_weight, 3.5);
assert_eq!(
parsed.mid_weight,
FrequencyBandWeights::default().mid_weight
);
assert_eq!(
parsed.treble_max,
FrequencyBandWeights::default().treble_max
);
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum TemporalMaskingProfile {
Transient,
#[default]
Mixed,
Sustained,
}
fn default_temporal_masking_enabled() -> bool {
true
}
fn default_temporal_masking_weight() -> f64 {
0.15
}
fn default_ir_temporal_masking_enabled() -> bool {
true
}
fn default_ir_temporal_masking_weight() -> f64 {
0.05
}
fn default_pre_mask_ms() -> f64 {
3.0
}
fn default_post_mask_ms() -> f64 {
120.0
}
fn default_pre_ringing_weight() -> f64 {
2.0
}
fn default_post_ringing_weight() -> f64 {
1.0
}
fn default_ir_audibility_threshold_db() -> f64 {
-45.0
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct TemporalMaskingConfig {
#[serde(default = "default_temporal_masking_enabled")]
pub enabled: bool,
#[serde(default = "default_temporal_masking_weight")]
pub weight: f64,
#[serde(default)]
pub profile: TemporalMaskingProfile,
#[serde(default = "default_ir_temporal_masking_enabled")]
pub ir_enabled: bool,
#[serde(default = "default_ir_temporal_masking_weight")]
pub ir_weight: f64,
#[serde(default = "default_pre_mask_ms")]
pub pre_mask_ms: f64,
#[serde(default = "default_post_mask_ms")]
pub post_mask_ms: f64,
#[serde(default = "default_pre_ringing_weight")]
pub pre_ringing_weight: f64,
#[serde(default = "default_post_ringing_weight")]
pub post_ringing_weight: f64,
#[serde(default = "default_ir_audibility_threshold_db")]
pub ir_audibility_threshold_db: f64,
}
impl Default for TemporalMaskingConfig {
fn default() -> Self {
Self {
enabled: default_temporal_masking_enabled(),
weight: default_temporal_masking_weight(),
profile: TemporalMaskingProfile::Mixed,
ir_enabled: default_ir_temporal_masking_enabled(),
ir_weight: default_ir_temporal_masking_weight(),
pre_mask_ms: default_pre_mask_ms(),
post_mask_ms: default_post_mask_ms(),
pre_ringing_weight: default_pre_ringing_weight(),
post_ringing_weight: default_post_ringing_weight(),
ir_audibility_threshold_db: default_ir_audibility_threshold_db(),
}
}
}
fn default_flatness_erb_weight() -> f64 {
1.0
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[serde(default)]
pub struct EpaConfig {
pub listening_level_phon: f64,
pub target_sharpness: f64,
pub max_roughness: f64,
pub evaluation_weight: f64,
pub potency_weight: f64,
pub activity_weight: f64,
#[serde(default)]
pub flatness_band_weights: FrequencyBandWeights,
#[serde(default = "default_flatness_erb_weight")]
pub flatness_erb_weight: f64,
#[serde(default)]
pub flatness_band_weight: f64,
#[serde(default)]
pub temporal_masking: TemporalMaskingConfig,
}
impl Default for EpaConfig {
fn default() -> Self {
Self {
listening_level_phon: 75.0,
target_sharpness: 1.2,
max_roughness: 0.5,
evaluation_weight: 0.6,
potency_weight: 0.2,
activity_weight: 0.2,
flatness_band_weights: FrequencyBandWeights::default(),
flatness_erb_weight: 1.0,
flatness_band_weight: 0.0,
temporal_masking: TemporalMaskingConfig::default(),
}
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq, Eq, Default)]
#[serde(rename_all = "snake_case")]
pub enum MultiMeasurementStrategy {
#[default]
Average,
WeightedSum,
Minimax,
VariancePenalized,
SpatialRobustness,
MinimaxUncertainty,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub enum CrossoverType {
Butterworth2,
#[serde(alias = "BW24", alias = "Butterworth24")]
Butterworth4,
LinkwitzRiley2,
#[default]
#[serde(alias = "LR24")]
LinkwitzRiley4,
#[serde(alias = "LR48")]
LinkwitzRiley8,
#[serde(alias = "LinearPhase")]
LinearPhase,
None,
}
impl std::str::FromStr for CrossoverType {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value.to_lowercase().as_str() {
"butterworth2" | "bw2" | "butterworth12" | "bw12" => Ok(Self::Butterworth2),
"butterworth4" | "bw4" | "butterworth24" | "bw24" => Ok(Self::Butterworth4),
"lr2" | "lr12" | "linkwitzriley2" | "linkwitzriley12" => Ok(Self::LinkwitzRiley2),
"lr4" | "lr24" | "linkwitzriley4" | "linkwitzriley24" => Ok(Self::LinkwitzRiley4),
"lr8" | "lr48" | "linkwitzriley8" | "linkwitzriley48" => Ok(Self::LinkwitzRiley8),
"linearphase" | "linear_phase" | "linear-phase" | "linearphasefir" | "fir"
| "lpfir" => Ok(Self::LinearPhase),
"none" => Ok(Self::None),
_ => Err(format!("Unknown crossover type: {value}")),
}
}
}