use super::ObjectiveData;
use crate::AutoeqError;
use crate::Curve;
use crate::HeadphoneLossData;
use crate::SpeakerLossData;
use crate::loss::DriversLossData;
use std::collections::HashMap;
mod drivers;
mod misc;
mod perform;
mod progress_callback_config;
mod types;
pub use drivers::*;
pub use misc::*;
pub use perform::*;
pub use progress_callback_config::*;
pub use types::*;
pub fn setup_objective_data(
params: &crate::OptimParams,
input_curve: &Curve,
target_curve: &Curve,
deviation_curve: &Curve,
spin_data: &Option<HashMap<String, Curve>>,
) -> Result<(ObjectiveData, bool), AutoeqError> {
let use_cea = spin_data.is_some();
let speaker_score_data_opt = if let Some(spin) = spin_data {
Some(SpeakerLossData::try_new(spin)?)
} else {
None
};
let headphone_score_data_opt = if !use_cea {
Some(HeadphoneLossData::new(params.smooth, params.smooth_n))
} else {
None
};
let mut builder = crate::optim::ObjectiveDataBuilder::new(
input_curve.freq.clone(),
target_curve.spl.clone(),
deviation_curve.spl.clone(), params.sample_rate,
params.peq_model,
params.loss,
)
.min_spacing_oct(params.min_spacing_oct)
.spacing_weight(params.spacing_weight)
.max_db(params.max_db)
.min_db(params.min_db)
.freq_range(params.min_freq, params.max_freq)
.smoothing(params.smooth, params.smooth_n)
.smoothness_penalty_opt(params.smoothness_penalty.clone())
.audibility_deadband_opt(params.audibility_deadband);
if let Some(sd) = speaker_score_data_opt {
builder = builder.speaker_score_data(sd);
}
if let Some(hd) = headphone_score_data_opt {
builder = builder.headphone_score_data(hd);
}
if !use_cea {
builder = builder.input_curve(input_curve.clone());
}
let objective_data = builder.build()?;
Ok((objective_data, use_cea))
}
pub fn setup_drivers_objective_data(
params: &crate::OptimParams,
drivers_data: DriversLossData,
) -> ObjectiveData {
crate::optim::ObjectiveDataBuilder::drivers_flat(
drivers_data.freq_grid.clone(),
params.sample_rate,
params.peq_model,
drivers_data,
)
.max_db(params.max_db)
.min_db(params.min_db)
.freq_range(params.min_freq, params.max_freq)
.smoothness_penalty_opt(params.smoothness_penalty.clone())
.audibility_deadband_opt(params.audibility_deadband)
.build()
.expect("invariant: drivers_flat builder has all required data")
}
pub fn setup_drivers_bounds(
params: &crate::OptimParams,
drivers_data: &DriversLossData,
) -> (Vec<f64>, Vec<f64>) {
let n_drivers = drivers_data.drivers.len();
let n_params = n_drivers * 2 + (n_drivers - 1);
let mut lower_bounds = Vec::with_capacity(n_params);
let mut upper_bounds = Vec::with_capacity(n_params);
for _ in 0..n_drivers {
lower_bounds.push(-params.max_db);
upper_bounds.push(params.max_db);
}
for _ in 0..n_drivers {
lower_bounds.push(-20.0);
upper_bounds.push(20.0);
}
for i in 0..(n_drivers - 1) {
let driver_low = &drivers_data.drivers[i];
let driver_high = &drivers_data.drivers[i + 1];
let mean_low = driver_low.mean_freq();
let mean_high = driver_high.mean_freq();
let geometric_center = (mean_low * mean_high).sqrt();
let xover_min = (geometric_center * 0.5).max(params.min_freq).log10();
let xover_max = (geometric_center * 2.0).min(params.max_freq).log10();
let xover_min = xover_min.min(xover_max - 0.1);
lower_bounds.push(xover_min);
upper_bounds.push(xover_max);
}
(lower_bounds, upper_bounds)
}
pub fn setup_drivers_bounds_fixed_freqs(
params: &crate::OptimParams,
drivers_data: &DriversLossData,
) -> (Vec<f64>, Vec<f64>) {
let n_drivers = drivers_data.drivers.len();
let n_params = n_drivers * 2;
let mut lower_bounds = Vec::with_capacity(n_params);
let mut upper_bounds = Vec::with_capacity(n_params);
for _ in 0..n_drivers {
lower_bounds.push(-params.max_db);
upper_bounds.push(params.max_db);
}
for _ in 0..n_drivers {
lower_bounds.push(-20.0);
upper_bounds.push(20.0);
}
(lower_bounds, upper_bounds)
}
pub fn setup_bounds(params: &crate::OptimParams) -> (Vec<f64>, Vec<f64>) {
use crate::PeqModel;
let model = params.peq_model;
let ppf = crate::param_utils::params_per_filter(model);
let num_params = params.num_filters * ppf;
let mut lower_bounds = Vec::with_capacity(num_params);
let mut upper_bounds = Vec::with_capacity(num_params);
let spacing = 1.0; let gain_lower = if params.min_db < 0.0 {
params.min_db
} else {
-3.0 * params.max_db
};
let q_lower = params.min_q.max(0.1);
let range = (params.max_freq.log10() - params.min_freq.log10()) / (params.num_filters as f64);
for i in 0..params.num_filters {
let f_center = params.min_freq.log10() + (i as f64) * range;
let f_low = (f_center - spacing * range).max(params.min_freq.log10());
let f_high = (f_center + spacing * range).min(params.max_freq.log10());
let f_low_adjusted = if i > 0 {
let prev_freq_idx = if ppf == 3 {
(i - 1) * 3
} else {
(i - 1) * 4 + 1
};
f_low.max(lower_bounds[prev_freq_idx])
} else {
f_low
};
let f_high_adjusted = if i > 0 {
let prev_freq_idx = if ppf == 3 {
(i - 1) * 3
} else {
(i - 1) * 4 + 1
};
f_high.max(upper_bounds[prev_freq_idx])
} else {
f_high
};
let f_high_adjusted = f_high_adjusted.max(f_low_adjusted);
match model {
PeqModel::Pk
| PeqModel::HpPk
| PeqModel::HpPkLp
| PeqModel::LsPk
| PeqModel::LsPkHs => {
lower_bounds.extend_from_slice(&[f_low_adjusted, q_lower, gain_lower]);
upper_bounds.extend_from_slice(&[f_high_adjusted, params.max_q, params.max_db]);
}
PeqModel::FreePkFree | PeqModel::Free => {
let (type_low, type_high) = if model == PeqModel::Free
|| (model == PeqModel::FreePkFree && (i == 0 || i == params.num_filters - 1))
{
crate::param_utils::filter_type_bounds()
} else {
(0.0, 0.999) };
lower_bounds.extend_from_slice(&[type_low, f_low_adjusted, q_lower, gain_lower]);
upper_bounds.extend_from_slice(&[
type_high,
f_high_adjusted,
params.max_q,
params.max_db,
]);
}
}
}
match model {
PeqModel::HpPk | PeqModel::HpPkLp => {
lower_bounds[0] = 20.0_f64.max(params.min_freq).log10();
upper_bounds[0] = 120.0_f64.min(params.min_freq + 20.0).log10();
lower_bounds[1] = 1.0_f64.max(q_lower).min(params.max_q);
upper_bounds[1] = 1.5_f64.max(lower_bounds[1]).min(params.max_q);
lower_bounds[2] = 0.0;
upper_bounds[2] = 0.0;
}
PeqModel::LsPk | PeqModel::LsPkHs => {
lower_bounds[0] = 20.0_f64.max(params.min_freq).log10();
upper_bounds[0] = 120.0_f64.min(params.min_freq + 20.0).log10();
let shelf_q = 1.0_f64.clamp(params.min_q, params.max_q);
lower_bounds[1] = shelf_q;
upper_bounds[1] = shelf_q;
lower_bounds[2] = -params.max_db;
upper_bounds[2] = params.max_db;
}
_ => {}
}
if params.num_filters > 1 {
if matches!(model, PeqModel::HpPkLp) {
let last_idx = (params.num_filters - 1) * ppf;
if ppf == 3 {
lower_bounds[last_idx] = (params.max_freq - 2000.0).max(5000.0).log10();
upper_bounds[last_idx] = params.max_freq.log10();
lower_bounds[last_idx + 1] = 1.0_f64.max(q_lower).min(params.max_q);
upper_bounds[last_idx + 1] =
1.5_f64.max(lower_bounds[last_idx + 1]).min(params.max_q);
lower_bounds[last_idx + 2] = 0.0;
upper_bounds[last_idx + 2] = 0.0;
}
}
if matches!(model, PeqModel::LsPkHs) {
let last_idx = (params.num_filters - 1) * ppf;
if ppf == 3 {
lower_bounds[last_idx] = (params.max_freq - 2000.0).max(5000.0).log10();
upper_bounds[last_idx] = params.max_freq.log10();
let shelf_q = 1.0_f64.clamp(params.min_q, params.max_q);
lower_bounds[last_idx + 1] = shelf_q;
upper_bounds[last_idx + 1] = shelf_q;
lower_bounds[last_idx + 2] = -params.max_db;
upper_bounds[last_idx + 2] = params.max_db;
}
}
}
let min_log_freq = params.min_freq.log10();
let max_log_freq = params.max_freq.log10();
for i in 0..params.num_filters {
let freq_idx = if ppf == 3 { i * ppf } else { i * ppf + 1 };
lower_bounds[freq_idx] = lower_bounds[freq_idx].clamp(min_log_freq, max_log_freq);
upper_bounds[freq_idx] = upper_bounds[freq_idx].clamp(min_log_freq, max_log_freq);
if lower_bounds[freq_idx] > upper_bounds[freq_idx] {
upper_bounds[freq_idx] = lower_bounds[freq_idx];
}
}
if !params.quiet {
log::info!("\n📏 Parameter Bounds (Model: {}):", model);
log::info!("+----+-------------------+---------------+-----------------+--------+");
log::info!("| # | Freq Range (Hz) | Q Range | Gain Range (dB) | Type |");
log::info!("+----+-------------------+---------------+-----------------+--------+");
for i in 0..params.num_filters {
let offset = i * ppf;
let (freq_idx, q_idx, gain_idx) = if ppf == 3 {
(offset, offset + 1, offset + 2)
} else {
(offset + 1, offset + 2, offset + 3)
};
let freq_low_hz = 10f64.powf(lower_bounds[freq_idx]);
let freq_high_hz = 10f64.powf(upper_bounds[freq_idx]);
let q_low = lower_bounds[q_idx];
let q_high = upper_bounds[q_idx];
let gain_low = lower_bounds[gain_idx];
let gain_high = upper_bounds[gain_idx];
let filter_type = match model {
PeqModel::Pk => "PK",
PeqModel::HpPk if i == 0 => "HP",
PeqModel::HpPk => "PK",
PeqModel::HpPkLp if i == 0 => "HP",
PeqModel::HpPkLp if i == params.num_filters - 1 => "LP",
PeqModel::HpPkLp => "PK",
PeqModel::LsPk if i == 0 => "LS",
PeqModel::LsPk => "PK",
PeqModel::LsPkHs if i == 0 => "LS",
PeqModel::LsPkHs if i == params.num_filters - 1 => "HS",
PeqModel::LsPkHs => "PK",
PeqModel::FreePkFree if i == 0 || i == params.num_filters - 1 => "??",
PeqModel::FreePkFree => "PK",
PeqModel::Free => "??",
};
log::info!(
"| {:2} | {:7.1} - {:7.1} | {:5.2} - {:5.2} | {:+6.2} - {:+6.2} | {:6} |",
i + 1,
freq_low_hz,
freq_high_hz,
q_low,
q_high,
gain_low,
gain_high,
filter_type
);
}
log::info!("+----+-------------------+---------------+-----------------+--------+\n");
}
(lower_bounds, upper_bounds)
}
pub fn setup_multisub_objective_data(
params: &crate::OptimParams,
drivers_data: DriversLossData,
) -> ObjectiveData {
crate::optim::ObjectiveDataBuilder::multi_sub_flat(
drivers_data.freq_grid.clone(),
params.sample_rate,
params.peq_model,
drivers_data,
)
.max_db(params.max_db)
.min_db(params.min_db)
.freq_range(params.min_freq, params.max_freq)
.smoothness_penalty_opt(params.smoothness_penalty.clone())
.audibility_deadband_opt(params.audibility_deadband)
.build()
.expect("invariant: multi-sub-flat builder has all required data")
}
pub fn setup_multisub_bounds(
params: &crate::OptimParams,
n_drivers: usize,
) -> (Vec<f64>, Vec<f64>) {
let n_params = n_drivers * 2; let mut lower_bounds = Vec::with_capacity(n_params);
let mut upper_bounds = Vec::with_capacity(n_params);
for _ in 0..n_drivers {
lower_bounds.push(-params.max_db);
upper_bounds.push(params.max_db);
}
for _ in 0..n_drivers {
lower_bounds.push(0.0);
upper_bounds.push(20.0);
}
(lower_bounds, upper_bounds)
}