use super::audibility_deadband_config::AudibilityDeadbandConfig;
use super::auto_optimizer_config::AutoOptimizerConfig;
use super::cea2034_correction_config::Cea2034CorrectionConfig;
use super::channel_matching_config::ChannelMatchingConfig;
use super::decomposed_correction_serde_config::DecomposedCorrectionSerdeConfig;
use super::decomposed_correction_serde_config::decomposed_correction_is_default;
use super::default::default_algorithm;
use super::default::default_asymmetric_loss;
use super::default::default_atolerance;
use super::default::default_elimination_threshold;
use super::default::default_local_algo;
use super::default::default_loss_type;
use super::default::default_max_db;
use super::default::default_max_freq;
use super::default::default_max_iter;
use super::default::default_max_q;
use super::default::default_min_db;
use super::default::default_min_filter_improvement;
use super::default::default_min_freq;
use super::default::default_min_q;
use super::default::default_num_filters;
use super::default::default_peq_model;
use super::default::default_population;
use super::default::default_psychoacoustic;
use super::default::default_refine;
use super::default::default_smooth_n;
use super::default::default_strategy;
use super::default::default_tolerance;
use super::early_late_correction_config::EarlyLateCorrectionConfig;
use super::excursion_protection_config::ExcursionProtectionConfig;
use super::group_delay_optimization_config::GroupDelayOptimizationConfig;
use super::high_frequency_correction_config::HighFrequencyCorrectionConfig;
use super::mixed_mode_config::MixedModeConfig;
use super::multi_measurement_config::MultiMeasurementConfig;
use super::multi_seat_config::MultiSeatConfig;
use super::perceptual_policy_config::PerceptualPolicyConfig;
use super::phase_alignment_config::PhaseAlignmentConfig;
use super::policy::policy_asymmetric_loss;
use super::policy::policy_audibility_deadband;
use super::policy::policy_decomposed_correction;
use super::policy::policy_early_late_correction;
use super::policy::policy_high_frequency_guard;
use super::policy::policy_multi_measurement;
use super::policy::policy_psychoacoustic_smoothing;
use super::policy::policy_smoothness_penalty;
use super::policy::policy_target_response;
use super::schroeder_split_config::SchroederSplitConfig;
use super::sub_optimizer_config::SubOptimizerConfig;
use super::target_response_config::TargetResponseConfig;
use super::types::FirConfig;
use super::types::MixedPhaseSerdeConfig;
use super::types::PerceptualPolicyPreset;
use super::types::ProcessingMode;
use super::types::SmoothnessPenaltyConfigSerde;
use super::types::{HeightChannelAlignmentConfig, InterChannelTimbreMatchingConfig};
use super::validation_bundle_config::ValidationBundleConfig;
use crate::{AsymmetricLossConfig, EpaConfig, PsychoacousticSmoothingConfig};
use schemars::JsonSchema;
use serde::{Deserialize, Deserializer, Serialize, de};
fn reject_removed_vog_alias<'de, D>(_: D) -> Result<Option<()>, D::Error>
where
D: Deserializer<'de>,
{
Err(de::Error::custom(
"optimizer.vog was removed; use optimizer.inter_channel_timbre_matching",
))
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct OptimizerConfig {
#[serde(default, alias = "mode")]
pub processing_mode: ProcessingMode,
#[serde(skip_serializing_if = "Option::is_none")]
pub fir: Option<FirConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mixed_config: Option<MixedModeConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mixed_phase: Option<MixedPhaseSerdeConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub phase_correction: Option<MixedPhaseSerdeConfig>,
#[serde(default = "default_loss_type")]
pub loss_type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub epa_config: Option<EpaConfig>,
#[serde(default = "default_algorithm")]
pub algorithm: String,
#[serde(default = "default_strategy")]
pub strategy: String,
#[serde(default = "default_num_filters")]
pub num_filters: usize,
#[serde(default = "default_min_filter_improvement")]
pub min_filter_improvement: f64,
#[serde(default = "default_elimination_threshold")]
pub elimination_threshold: f64,
#[serde(default = "default_min_q")]
pub min_q: f64,
#[serde(default = "default_max_q")]
pub max_q: f64,
#[serde(default = "default_min_db")]
pub min_db: f64,
#[serde(default = "default_max_db")]
pub max_db: f64,
#[serde(default = "default_min_freq")]
pub min_freq: f64,
#[serde(default = "default_max_freq")]
pub max_freq: f64,
#[serde(default = "default_max_iter")]
pub max_iter: usize,
#[serde(default = "default_population")]
pub population: usize,
#[serde(default = "default_peq_model")]
pub peq_model: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub seed: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parallel_threads: Option<usize>,
#[serde(default = "default_refine")]
pub refine: bool,
#[serde(default = "default_local_algo")]
pub local_algo: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bo_initial_samples: Option<usize>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bo_batch_size: Option<usize>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bo_posterior_std_threshold: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bo_acquisition: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bo_ehvi: Option<bool>,
#[serde(default = "default_psychoacoustic")]
pub psychoacoustic: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub psychoacoustic_smoothing: Option<PsychoacousticSmoothingConfig>,
#[serde(default = "default_smooth_n")]
pub smooth_n: usize,
#[serde(default = "default_asymmetric_loss")]
pub asymmetric_loss: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub asymmetric_loss_config: Option<AsymmetricLossConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub perceptual_policy: Option<PerceptualPolicyConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub audibility_deadband: Option<AudibilityDeadbandConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub high_frequency_correction: Option<HighFrequencyCorrectionConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub early_late_correction: Option<EarlyLateCorrectionConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub validation_bundle: Option<ValidationBundleConfig>,
#[serde(default = "default_tolerance")]
pub tolerance: f64,
#[serde(default = "default_atolerance")]
pub atolerance: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allow_delay: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target_response: Option<TargetResponseConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub excursion_protection: Option<ExcursionProtectionConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub schroeder_split: Option<SchroederSplitConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub auto_optimizer: Option<AutoOptimizerConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub smoothness_penalty: Option<SmoothnessPenaltyConfigSerde>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub phase_alignment: Option<PhaseAlignmentConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub group_delay: Option<GroupDelayOptimizationConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub multi_seat: Option<MultiSeatConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inter_channel_timbre_matching: Option<InterChannelTimbreMatchingConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub height_channel_alignment: Option<HeightChannelAlignmentConfig>,
#[doc(hidden)]
#[serde(
default,
rename = "vog",
skip_serializing,
deserialize_with = "reject_removed_vog_alias"
)]
#[schemars(skip)]
pub removed_vog_alias: Option<()>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub multi_measurement: Option<MultiMeasurementConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub decomposed_correction: Option<DecomposedCorrectionSerdeConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cea2034_correction: Option<Cea2034CorrectionConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sub_config: Option<SubOptimizerConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub channel_matching: Option<ChannelMatchingConfig>,
#[serde(skip)]
pub ssir_wav_path: Option<std::path::PathBuf>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_boost_envelope: Option<Vec<(f64, f64)>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_cut_envelope: Option<Vec<(f64, f64)>>,
#[serde(skip)]
pub from_measurement_slope_override: Option<f64>,
}
impl Default for OptimizerConfig {
fn default() -> Self {
Self {
loss_type: default_loss_type(),
algorithm: default_algorithm(),
strategy: default_strategy(),
num_filters: default_num_filters(),
min_filter_improvement: default_min_filter_improvement(),
elimination_threshold: default_elimination_threshold(),
min_q: default_min_q(),
max_q: default_max_q(),
min_db: default_min_db(),
max_db: default_max_db(),
min_freq: default_min_freq(),
max_freq: default_max_freq(),
max_iter: default_max_iter(),
population: default_population(),
peq_model: default_peq_model(),
processing_mode: ProcessingMode::LowLatency,
fir: None,
mixed_config: None,
mixed_phase: None,
phase_correction: None,
seed: None,
parallel_threads: None,
refine: default_refine(),
local_algo: default_local_algo(),
bo_initial_samples: None,
bo_batch_size: None,
bo_posterior_std_threshold: None,
bo_acquisition: None,
bo_ehvi: None,
psychoacoustic: default_psychoacoustic(),
psychoacoustic_smoothing: None,
smooth_n: default_smooth_n(),
asymmetric_loss: default_asymmetric_loss(),
asymmetric_loss_config: None,
perceptual_policy: None,
audibility_deadband: None,
high_frequency_correction: None,
early_late_correction: None,
validation_bundle: None,
tolerance: default_tolerance(),
atolerance: default_atolerance(),
allow_delay: None,
target_response: None,
excursion_protection: None,
schroeder_split: None,
auto_optimizer: None,
smoothness_penalty: None,
phase_alignment: None,
group_delay: None,
multi_seat: None,
inter_channel_timbre_matching: None,
height_channel_alignment: None,
removed_vog_alias: None,
multi_measurement: None,
decomposed_correction: None,
cea2034_correction: None,
sub_config: None,
channel_matching: None,
ssir_wav_path: None,
max_boost_envelope: None,
min_cut_envelope: None,
epa_config: None,
from_measurement_slope_override: None,
}
}
}
impl OptimizerConfig {
pub fn psychoacoustic_smoothing_config(&self) -> PsychoacousticSmoothingConfig {
self.psychoacoustic_smoothing.unwrap_or_default()
}
pub fn asymmetric_loss_config(&self) -> AsymmetricLossConfig {
self.asymmetric_loss_config.unwrap_or_default()
}
pub fn audibility_deadband_config(&self) -> Option<AudibilityDeadbandConfig> {
let mut cfg = self.audibility_deadband?;
if let Some(hf) = self.high_frequency_correction
&& hf.enabled
&& self.max_freq > hf.start_hz
{
cfg.treble_db = cfg.treble_db.max(cfg.mid_db + hf.extra_deadband_db);
}
cfg.enabled.then_some(cfg)
}
pub fn early_late_correction_config(&self) -> Option<EarlyLateCorrectionConfig> {
self.early_late_correction.filter(|cfg| cfg.enabled)
}
pub fn validation_bundle_config(&self) -> Option<ValidationBundleConfig> {
self.validation_bundle.filter(|cfg| cfg.enabled)
}
pub fn apply_perceptual_policy_defaults(&mut self) {
let Some(policy) = self.perceptual_policy else {
return;
};
if !policy.apply_defaults {
return;
}
let preset = policy.preset;
let override_existing = policy.override_existing;
let smoothing_was_missing = self.psychoacoustic_smoothing.is_none();
if override_existing || self.loss_type == default_loss_type() {
self.loss_type = match preset {
PerceptualPolicyPreset::Reference => "flat",
PerceptualPolicyPreset::Music
| PerceptualPolicyPreset::Cinema
| PerceptualPolicyPreset::Night
| PerceptualPolicyPreset::Speech => "epa",
}
.to_string();
}
if override_existing || self.target_response.is_none() {
self.target_response = Some(policy_target_response(preset));
}
if override_existing || self.multi_measurement.is_none() {
self.multi_measurement = Some(policy_multi_measurement(preset));
}
if override_existing
|| self
.decomposed_correction
.as_ref()
.map(decomposed_correction_is_default)
.unwrap_or(true)
{
self.decomposed_correction = Some(policy_decomposed_correction(preset));
}
if override_existing || self.psychoacoustic_smoothing.is_none() {
self.psychoacoustic_smoothing = Some(policy_psychoacoustic_smoothing(preset));
}
if override_existing || self.asymmetric_loss_config.is_none() {
self.asymmetric_loss_config = Some(policy_asymmetric_loss(preset));
}
if override_existing || self.smoothness_penalty.is_none() {
self.smoothness_penalty = Some(policy_smoothness_penalty(preset));
}
if override_existing || self.audibility_deadband.is_none() {
self.audibility_deadband = Some(policy_audibility_deadband(preset));
}
if override_existing || self.high_frequency_correction.is_none() {
self.high_frequency_correction = Some(policy_high_frequency_guard(preset));
}
if override_existing || self.early_late_correction.is_none() {
self.early_late_correction = Some(policy_early_late_correction(preset));
}
if override_existing || self.validation_bundle.is_none() {
self.validation_bundle = Some(ValidationBundleConfig::default());
}
if smoothing_was_missing {
self.apply_high_frequency_smoothing_guard();
}
self.apply_high_frequency_correction_defaults(override_existing);
}
pub fn apply_high_frequency_correction_defaults(&mut self, override_existing: bool) {
let Some(hf) = self.high_frequency_correction else {
return;
};
if !hf.enabled || self.max_freq <= hf.start_hz {
return;
}
if (override_existing || (self.max_q - default_max_q()).abs() < 1e-9)
&& self.max_q > hf.max_q
{
self.max_q = hf.max_q.max(self.min_q);
}
if override_existing || self.psychoacoustic_smoothing.is_none() {
self.apply_high_frequency_smoothing_guard();
}
}
pub(super) fn apply_high_frequency_smoothing_guard(&mut self) {
let Some(hf) = self.high_frequency_correction else {
return;
};
if !hf.enabled || self.max_freq <= hf.start_hz {
return;
}
let mut smoothing = self.psychoacoustic_smoothing_config();
smoothing.high_freq_n = smoothing.high_freq_n.min(hf.smoothing_n.max(1));
smoothing.high_freq = smoothing.high_freq.min(hf.start_hz);
if smoothing.high_freq <= smoothing.low_freq {
smoothing.low_freq = smoothing.high_freq * 0.5;
}
self.psychoacoustic_smoothing = Some(smoothing);
}
pub fn allow_delay(&self) -> bool {
self.allow_delay.unwrap_or_else(|| {
self.processing_mode != ProcessingMode::LowLatency
|| self
.phase_alignment
.as_ref()
.is_some_and(|config| config.enabled)
})
}
pub fn max_boost_at_freq(&self, freq_hz: f64) -> f64 {
let envelope = match &self.max_boost_envelope {
Some(env) if !env.is_empty() => env,
_ => return self.max_db,
};
if freq_hz <= envelope[0].0 {
return envelope[0].1;
}
let last = envelope.len() - 1;
if freq_hz >= envelope[last].0 {
return envelope[last].1;
}
for i in 0..last {
let (f0, db0) = envelope[i];
let (f1, db1) = envelope[i + 1];
if freq_hz >= f0 && freq_hz <= f1 {
let t = (freq_hz.ln() - f0.ln()) / (f1.ln() - f0.ln());
return db0 + t * (db1 - db0);
}
}
self.max_db
}
pub fn gain_envelope_errors(&self) -> Vec<String> {
[
("max_boost_envelope", self.max_boost_envelope.as_deref()),
("min_cut_envelope", self.min_cut_envelope.as_deref()),
]
.into_iter()
.filter_map(|(name, envelope)| gain_envelope_error(name, envelope))
.collect()
}
}
fn gain_envelope_error(name: &str, envelope: Option<&[(f64, f64)]>) -> Option<String> {
let envelope = envelope?;
for &(frequency, gain) in envelope {
if !frequency.is_finite() || frequency <= 0.0 {
return Some(format!(
"{name} frequencies must be finite and positive, got {frequency}"
));
}
if !gain.is_finite() {
return Some(format!("{name} gains must be finite, got {gain}"));
}
}
if envelope.windows(2).any(|points| points[0].0 >= points[1].0) {
return Some(format!(
"{name} frequencies must be strictly increasing without duplicates"
));
}
None
}
#[cfg(test)]
mod legacy_alias_tests {
use super::OptimizerConfig;
#[test]
fn removed_vog_alias_is_rejected() {
let error = serde_json::from_value::<OptimizerConfig>(serde_json::json!({
"vog": {
"enabled": true,
"reference_channel": "left",
"min_improvement_db": 0.05
}
}))
.unwrap_err();
assert!(error.to_string().contains("optimizer.vog was removed"));
}
#[test]
fn unrelated_legacy_fields_remain_tolerated() {
let config = serde_json::from_value::<OptimizerConfig>(serde_json::json!({
"mode": "iir"
}))
.unwrap();
assert_eq!(
config.processing_mode,
OptimizerConfig::default().processing_mode
);
}
}