roomeq-model 0.5.5

RoomEQ configuration, pipeline, and DSP-chain contracts
Documentation
use super::ctc_hrtf_config::CtcHrtfConfig;
use super::ctc_measurement_config::CtcMeasurementConfig;
use super::ctc_regularization_config::CtcRegularizationConfig;
use super::ctc_window_config::CtcWindowConfig;
use super::default::default_ctc_fir_taps;
use super::default::default_ctc_harmonic_window_ms;
use super::default::default_ctc_include_room_eq_dsp;
use super::default::default_ctc_matrix_source;
use super::default::default_ctc_max_harmonic;
use super::default::default_ctc_minimax_iterations;
use super::default::default_ctc_robustness;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CtcConfig {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default = "default_ctc_matrix_source")]
    pub matrix_source: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub measurements: Option<CtcMeasurementConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hrtf: Option<CtcHrtfConfig>,
    #[serde(default)]
    pub window: CtcWindowConfig,
    #[serde(default)]
    pub regularization: CtcRegularizationConfig,
    #[serde(default = "default_ctc_robustness")]
    pub robustness: String,
    /// Include the exported per-channel RoomEQ gain/EQ/delay response in the
    /// acoustic plant before solving the CTC matrix. This matches the runtime
    /// order where the global XTC matrix feeds the per-channel correction
    /// chains.
    #[serde(default = "default_ctc_include_room_eq_dsp")]
    pub include_room_eq_dsp: bool,
    #[serde(default = "default_ctc_fir_taps")]
    pub fir_taps: usize,
    /// Optional emitted sweep WAV used for raw sweep deconvolution.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reference_sweep: Option<PathBuf>,
    /// Sweep duration in seconds, used to suppress log-sweep harmonic residues.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sweep_duration_s: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sweep_start_hz: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sweep_end_hz: Option<f64>,
    #[serde(default = "default_ctc_max_harmonic")]
    pub harmonic_suppression_harmonics: usize,
    #[serde(default = "default_ctc_harmonic_window_ms")]
    pub harmonic_suppression_window_ms: f64,
    #[serde(default = "default_ctc_minimax_iterations")]
    pub minimax_iterations: usize,
}

impl Default for CtcConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            matrix_source: default_ctc_matrix_source(),
            measurements: None,
            hrtf: None,
            window: CtcWindowConfig::default(),
            regularization: CtcRegularizationConfig::default(),
            robustness: default_ctc_robustness(),
            include_room_eq_dsp: default_ctc_include_room_eq_dsp(),
            fir_taps: default_ctc_fir_taps(),
            reference_sweep: None,
            sweep_duration_s: None,
            sweep_start_hz: None,
            sweep_end_hz: None,
            harmonic_suppression_harmonics: default_ctc_max_harmonic(),
            harmonic_suppression_window_ms: default_ctc_harmonic_window_ms(),
            minimax_iterations: default_ctc_minimax_iterations(),
        }
    }
}

impl CtcConfig {
    pub fn resolve_paths(&mut self, base_dir: &std::path::Path) {
        if let Some(measurements) = &mut self.measurements {
            measurements.resolve_paths(base_dir);
        }
        if let Some(hrtf) = &mut self.hrtf {
            hrtf.resolve_paths(base_dir);
        }
        if let Some(reference_sweep) = &mut self.reference_sweep
            && reference_sweep.is_relative()
        {
            *reference_sweep = base_dir.join(&*reference_sweep);
        }
    }
}