use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
pub use crate::Curve;
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct CurveData {
pub freq: Vec<f64>,
pub spl: Vec<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub phase: Option<Vec<f64>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub norm_range: Option<(f64, f64)>,
}
impl From<Curve> for CurveData {
fn from(curve: Curve) -> Self {
CurveData {
freq: curve.freq.to_vec(),
spl: curve.spl.to_vec(),
phase: curve.phase.map(|p| p.to_vec()),
norm_range: None,
}
}
}
impl From<&Curve> for CurveData {
fn from(curve: &Curve) -> Self {
CurveData {
freq: curve.freq.to_vec(),
spl: curve.spl.to_vec(),
phase: curve.phase.as_ref().map(|p| p.to_vec()),
norm_range: None,
}
}
}
impl From<CurveData> for Curve {
fn from(data: CurveData) -> Self {
Curve {
freq: ndarray::Array1::from(data.freq),
spl: ndarray::Array1::from(data.spl),
phase: data.phase.map(ndarray::Array1::from),
..Default::default()
}
}
}
pub use crate::IrWaveform;
pub type DspChainOutput = crate::DspGraph;
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ChannelDspChain {
pub channel: String,
pub plugins: Vec<PluginConfigWrapper>,
#[serde(skip_serializing_if = "Option::is_none")]
pub drivers: Option<Vec<DriverDspChain>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_curve: Option<CurveData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub final_curve: Option<CurveData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eq_response: Option<CurveData>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target_curve: Option<CurveData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_ir: Option<IrWaveform>,
#[serde(skip_serializing_if = "Option::is_none")]
pub post_ir: Option<IrWaveform>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fir_temporal_masking: Option<crate::TemporalIrMaskingMetrics>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub direct_early_late_correction: Option<DirectEarlyLateCorrectionMetrics>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DriverDspChain {
pub name: String,
pub index: usize,
pub plugins: Vec<PluginConfigWrapper>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub initial_curve: Option<CurveData>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct PluginConfigWrapper {
pub plugin_type: String,
pub parameters: serde_json::Value,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct EpaChannelMetrics {
pub pre: crate::EpaScore,
pub post: crate::EpaScore,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct EpaMultichannelMetrics {
pub pre: crate::EpaScore,
pub post: crate::EpaScore,
pub standard: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct DirectEarlyLateCorrectionMetrics {
pub direct_window_ms: f64,
pub early_window_ms: f64,
pub late_window_ms: f64,
pub direct_energy_db: f64,
pub early_energy_db: f64,
pub late_energy_db: f64,
pub direct_plus_early_energy_db: f64,
pub advisory: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct PreferenceLayerReport {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub house_curve: Option<crate::TargetShape>,
pub user_preference: crate::UserPreference,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub role_targets: Option<crate::RoleTargetConfig>,
pub excluded_from_neutral_quality_score: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct PerceptualPolicyReport {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preset: Option<crate::PerceptualPolicyPreset>,
pub loss_type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target_response: Option<crate::TargetResponseConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub neutral_target_response: Option<crate::TargetResponseConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preference_layer: Option<PreferenceLayerReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub audibility_deadband: Option<crate::AudibilityDeadbandConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub high_frequency_correction: Option<crate::HighFrequencyCorrectionConfig>,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum BootstrapUncertaintySource {
SpatialSeatSampling,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct BootstrapUncertaintyReport {
pub source: BootstrapUncertaintySource,
pub assumes_independent_positions: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effective_spatial_sample_size: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub repeat_sweep_noise_std_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub calibration_uncertainty_std_db: Option<f64>,
pub num_resamples: usize,
pub alpha: f64,
pub scalarisation: crate::BootstrapScalarisation,
pub cvar_alpha: f64,
pub used_for_correction_depth_mask: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ValidationBundleReport {
pub artifact: String,
pub target_lufs: f64,
pub abx: bool,
pub mushra: bool,
pub perceptual_regression_summary: bool,
pub advisories: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct PerceptualMetrics {
pub epa_preference_pre: f64,
pub epa_preference_post: f64,
pub epa_preference_delta: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub channel_matching_midrange_rms_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub role_channel_matching_rms_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bass_consistency_rms_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dialog_band_roughness_rms_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub headroom_peak_boost_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub headroom_risk: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timing_confidence: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fir_pre_ringing_audible_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fir_post_ringing_audible_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fir_temporal_masking_penalty: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub direct_plus_early_correction_energy_db: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub early_cue_advisory: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct StatisticalSummary {
pub mean: f64,
pub std: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct SupportingSourceReport {
pub enabled: bool,
pub primary_output: String,
pub support_output: String,
pub delay_ms: f64,
pub fir_length: usize,
pub compensation_band_hz: (f64, f64),
#[serde(default, skip_serializing_if = "Option::is_none")]
pub drr_before_db: Option<StatisticalSummary>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub drr_after_db: Option<StatisticalSummary>,
pub target_constraints_active: bool,
pub precedence_limit_hits: usize,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub advisories: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum StageStatus {
Applied,
Skipped,
Degraded,
Failed,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
pub struct StageOutcome {
pub stage: String,
pub status: StageStatus,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub advisories: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
pub struct RoomOptimizerEvidence {
pub policy_version: String,
pub confidence: crate::OptimizerConfidence,
pub runs_by_channel: BTreeMap<String, Vec<crate::OptimizerRunEvidence>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct OptimizationMetadata {
pub pre_score: f64,
pub post_score: f64,
pub algorithm: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub loss_type: Option<String>,
pub iterations: usize,
pub timestamp: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inter_channel_deviation: Option<crate::InterChannelDeviation>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub epa_per_channel: Option<HashMap<String, EpaChannelMetrics>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub epa_multichannel: Option<EpaMultichannelMetrics>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub group_delay: Option<crate::GroupDelayOptSummary>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mixed_phase_per_channel: Option<HashMap<String, crate::MixedPhaseCorrectionReport>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub perceptual_metrics: Option<PerceptualMetrics>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub home_cinema_layout: Option<crate::HomeCinemaLayoutReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub multi_seat_coverage: Option<crate::MultiSeatCoverageReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub multi_seat_correction: Option<crate::MultiSeatCorrectionReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bass_management: Option<crate::BassManagementReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timing_diagnostics: Option<crate::TimingDiagnosticsReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ctc: Option<crate::CtcReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub perceptual_policy: Option<PerceptualPolicyReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bootstrap_uncertainty: Option<BootstrapUncertaintyReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub validation_bundle: Option<ValidationBundleReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supporting_source: Option<HashMap<String, SupportingSourceReport>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub correction_acceptance: Option<crate::CorrectionAcceptanceReport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub optimizer_evidence: Option<RoomOptimizerEvidence>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub stage_outcomes: Vec<StageOutcome>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effective_config: Option<Box<crate::RoomConfig>>,
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::Array1;
fn sample_curve() -> Curve {
Curve {
freq: Array1::from(vec![100.0, 1000.0, 10000.0]),
spl: Array1::from(vec![80.0, 82.0, 81.0]),
phase: Some(Array1::from(vec![0.0, 45.0, 90.0])),
..Default::default()
}
}
#[test]
fn curve_data_from_curve_owned() {
let curve = sample_curve();
let data = CurveData::from(curve.clone());
assert_eq!(data.freq, vec![100.0, 1000.0, 10000.0]);
assert_eq!(data.spl, vec![80.0, 82.0, 81.0]);
assert_eq!(data.phase, Some(vec![0.0, 45.0, 90.0]));
assert!(data.norm_range.is_none());
}
#[test]
fn curve_data_from_curve_ref() {
let curve = sample_curve();
let data = CurveData::from(&curve);
assert_eq!(data.freq, vec![100.0, 1000.0, 10000.0]);
assert_eq!(data.spl, vec![80.0, 82.0, 81.0]);
assert_eq!(data.phase, Some(vec![0.0, 45.0, 90.0]));
}
#[test]
fn curve_data_roundtrips_to_curve() {
let data = CurveData {
freq: vec![100.0, 1000.0, 10000.0],
spl: vec![80.0, 82.0, 81.0],
phase: Some(vec![0.0, 45.0, 90.0]),
norm_range: Some((1000.0, 2000.0)),
};
let curve: Curve = data.clone().into();
assert_eq!(curve.freq.to_vec(), data.freq);
assert_eq!(curve.spl.to_vec(), data.spl);
assert_eq!(curve.phase.as_ref().map(|p| p.to_vec()), data.phase);
}
#[test]
fn curve_data_json_roundtrip() {
let data = CurveData {
freq: vec![100.0, 1000.0],
spl: vec![80.0, 82.0],
phase: None,
norm_range: None,
};
let json = serde_json::to_string(&data).unwrap();
let back: CurveData = serde_json::from_str(&json).unwrap();
assert_eq!(back.freq, data.freq);
assert_eq!(back.spl, data.spl);
assert_eq!(back.phase, data.phase);
}
}