secs_engine/
calibration.rs

1//! Resolve project calibration settings into the engine constructor surface.
2
3use std::collections::BTreeSet;
4
5use secs_types::{
6    calibration::{CalibrationSettings, SubEntry, mode_params},
7    chain::BandType,
8    target::TargetCurve,
9};
10
11use crate::{
12    EngineError,
13    input::{BundleLayout, DbaRow, EngineConfig, LayoutKind, MeasurementSet, SubManual, SubMode},
14};
15
16#[derive(Debug)]
17pub struct ProjectView<'a> {
18    pub groups: &'a [(String, Vec<String>)],
19    pub project_xo: &'a [(String, f64)],
20    pub target: &'a TargetCurve,
21}
22
23#[derive(Debug)]
24pub struct EngineInputs {
25    pub measurements: MeasurementSet,
26    pub config: EngineConfig,
27    pub notes: Vec<String>,
28}
29
30#[derive(Debug)]
31pub struct CalibrationRequest<'a> {
32    pub view: &'a ProjectView<'a>,
33    pub irs: &'a MeasurementSet,
34    pub settings: &'a CalibrationSettings,
35    pub subs_only: bool,
36}
37
38#[derive(Debug)]
39pub struct Calibration {
40    pub design: crate::Design,
41    /// The normalized measurements and config the design was made from.
42    pub measurements: MeasurementSet,
43    pub config: EngineConfig,
44    /// IRs resampled to 48 kHz by the sample-rate policy.
45    pub resampled: usize,
46}
47
48/// Resolve, normalize and design with the context's cancellable production fitters.
49pub fn calibrate(
50    req: &CalibrationRequest<'_>,
51    ctx: &secs_compute::Context,
52) -> Result<Calibration, EngineError> {
53    let derivatives = if req.settings.peq_analytic_derivatives {
54        crate::PeqDerivatives::Analytic
55    } else {
56        crate::PeqDerivatives::TwoPoint
57    };
58    calibrate_with(
59        req,
60        ctx,
61        &*crate::production_fitters_with(ctx.cancel(), derivatives),
62    )
63}
64
65/// The calibration entry point with caller-supplied fitters (oracle replay).
66pub fn calibrate_with(
67    req: &CalibrationRequest<'_>,
68    ctx: &secs_compute::Context,
69    fitters: &crate::FitterFactory<'_>,
70) -> Result<Calibration, EngineError> {
71    ctx.cancel().check().map_err(|_| EngineError::Cancelled)?;
72    let inputs = engine_inputs(req.view, req.irs, req.settings)?;
73    let (inputs, resampled) = prepare_inputs(inputs, req.settings.sample_rate_policy, ctx)?;
74    let design = crate::design(
75        &crate::DesignRequest {
76            measurements: &inputs.measurements,
77            config: &inputs.config,
78            tuning: &crate::Tuning::default(),
79            subs_only: req.subs_only,
80            adapter_notes: &inputs.notes,
81        },
82        ctx,
83        fitters,
84    )?;
85    Ok(Calibration {
86        design,
87        measurements: inputs.measurements,
88        config: inputs.config,
89        resampled,
90    })
91}
92
93pub(crate) fn prepare_inputs(
94    mut inputs: EngineInputs,
95    policy: secs_types::calibration::SampleRatePolicy,
96    ctx: &secs_compute::Context,
97) -> Result<(EngineInputs, usize), EngineError> {
98    ctx.cancel().check().map_err(|_| EngineError::Cancelled)?;
99    let resampled = inputs
100        .measurements
101        .positions
102        .iter()
103        .flat_map(|(_, roles)| roles)
104        .filter(|(_, measurement)| measurement.sample_rate != crate::grid::SR)
105        .count();
106    inputs.measurements = crate::normalize_measurements(&inputs.measurements, policy, ctx)?;
107    Ok((inputs, resampled))
108}
109
110pub fn engine_inputs(
111    view: &ProjectView<'_>,
112    irs: &MeasurementSet,
113    settings: &CalibrationSettings,
114) -> Result<EngineInputs, EngineError> {
115    let mut skipped = BTreeSet::new();
116    let mut positions = Vec::new();
117    for (position, roles) in &irs.positions {
118        let clean: Vec<_> = roles
119            .iter()
120            .filter_map(|(role, measurement)| {
121                if role.contains(':') {
122                    skipped.insert(role.clone());
123                    None
124                } else {
125                    Some((role.clone(), measurement.clone()))
126                }
127            })
128            .collect();
129        if !clean.is_empty() {
130            positions.push((*position, clean));
131        }
132    }
133    let Some(main_position) = positions.iter().map(|(position, _)| *position).min() else {
134        return Err(EngineError::Input("no measured impulse responses".into()));
135    };
136    let have: BTreeSet<_> = positions
137        .iter()
138        .find(|(position, _)| *position == main_position)
139        .expect("minimum position exists")
140        .1
141        .iter()
142        .map(|(role, _)| role.as_str())
143        .collect();
144
145    let groups: Vec<_> = view
146        .groups
147        .iter()
148        .filter_map(|(group, roles)| {
149            let roles: Vec<_> = roles
150                .iter()
151                .filter(|role| have.contains(role.as_str()))
152                .cloned()
153                .collect();
154            (!roles.is_empty()).then(|| (group.clone(), roles))
155        })
156        .collect();
157    let subs = groups
158        .iter()
159        .find(|(group, _)| group == "sub")
160        .map_or_else(Vec::new, |(_, roles)| roles.clone());
161    let mains: Vec<_> = groups
162        .iter()
163        .filter(|(group, _)| group != "sub")
164        .flat_map(|(_, roles)| roles.iter().cloned())
165        .collect();
166    if mains.is_empty() {
167        return Err(EngineError::Input("no measured main channels".into()));
168    }
169
170    let keep: BTreeSet<_> = mains.iter().chain(&subs).map(String::as_str).collect();
171    for (_, roles) in &mut positions {
172        roles.retain(|(role, _)| keep.contains(role.as_str()));
173    }
174
175    let xo = resolve_xo(&groups, &settings.xo, view.project_xo);
176    let mode = mode_params(settings.mode, settings.ultra_ms);
177    let sub_manual = settings
178        .subs_manual
179        .iter()
180        .filter(|(_, entry)| entry.mode != "auto" || sub_has_filters(entry))
181        .map(|(role, entry)| (role.clone(), manual(entry)))
182        .collect();
183    let bundle_layouts = settings
184        .bundle_layouts
185        .iter()
186        .filter_map(|(bundle, entry)| {
187            let kind = match entry.kind.as_str() {
188                "dba" => LayoutKind::Dba,
189                "multi" => LayoutKind::Multi,
190                _ => return None,
191            };
192            Some((
193                bundle.clone(),
194                BundleLayout {
195                    kind,
196                    rear_trim_ms: entry.rear_trim_ms,
197                },
198            ))
199        })
200        .collect();
201    let notes = if skipped.is_empty() {
202        Vec::new()
203    } else {
204        vec![format!(
205            "바이앰프 대역 측정 제외: {}",
206            skipped.into_iter().collect::<Vec<_>>().join(", ")
207        )]
208    };
209
210    Ok(EngineInputs {
211        measurements: MeasurementSet { positions },
212        config: EngineConfig {
213            mains,
214            subs,
215            groups,
216            target: view.target.clone(),
217            xo,
218            main_position,
219            taps: mode.taps,
220            lift_ms: mode.lift_ms,
221            max_boost_db: 10.0_f64.min(settings.boost_max_db),
222            peq_bands: mode.peq_bands,
223            max_latency_ms: Some(mode.max_latency_ms),
224            rc_range: (settings.rc_lo, settings.rc_hi),
225            room_volume_m3: settings.room_volume_m3,
226            phase_frac: mode.phase_frac,
227            sub_manual,
228            sub_main_delay_ms: settings.sub_main_delay_ms,
229            bundle_layouts,
230            infra_boost_max_db: settings.infra_boost_max_db,
231            xo_peq_on: settings.xo_peq_on,
232            xo_peq_lo_hz: settings.xo_peq_lo,
233            xo_peq_hi_hz: settings.xo_peq_hi,
234        },
235        notes,
236    })
237}
238
239pub(crate) fn resolve_xo(
240    groups: &[(String, Vec<String>)],
241    selected: &[(String, f64)],
242    project: &[(String, f64)],
243) -> Vec<(String, f64)> {
244    groups
245        .iter()
246        .filter(|(group, _)| group != "sub")
247        .map(|(group, _)| {
248            let value = selected
249                .iter()
250                .find(|(name, value)| name == group && *value != 0.0)
251                .or_else(|| {
252                    project
253                        .iter()
254                        .find(|(name, value)| name == group && *value != 0.0)
255                })
256                .map_or(80.0, |(_, value)| *value);
257            (group.clone(), value)
258        })
259        .collect()
260}
261
262fn sub_has_filters(entry: &SubEntry) -> bool {
263    entry.hp_hz != 0.0 || entry.lp_hz != 0.0 || entry.peq.iter().any(|band| band.2 != 0.0)
264}
265
266fn manual(entry: &SubEntry) -> SubManual {
267    SubManual {
268        mode: match entry.mode.as_str() {
269            "fixed" => SubMode::Fixed,
270            "bundle" => SubMode::Bundle,
271            _ => SubMode::Auto,
272        },
273        bundle: entry.bundle.clone(),
274        gain_db: entry.gain_db,
275        delay_ms: entry.delay_ms,
276        polarity: entry.polarity,
277        allpass: entry.allpass.clone(),
278        mimo_support: entry.mimo_support,
279        hp_hz: entry.hp_hz,
280        hp_type: BandType::from_name(&entry.hp_type),
281        lp_hz: entry.lp_hz,
282        lp_type: BandType::from_name(&entry.lp_type),
283        peq: entry.peq.clone(),
284        dba_row: if entry.dba_row == "rear" {
285            DbaRow::Rear
286        } else {
287            DbaRow::Front
288        },
289    }
290}
291
292#[cfg(test)]
293mod direct_tests {
294    use super::*;
295    use crate::input::{Measurement, Samples};
296    use std::sync::Arc;
297
298    fn measurement() -> Measurement {
299        Measurement {
300            samples: Samples::F32(Arc::from([1.0])),
301            sample_rate: 48_000,
302            t0: 0.0,
303        }
304    }
305
306    #[test]
307    fn excludes_biamp_and_non_reference_only_roles() {
308        let groups = vec![
309            ("front".into(), vec!["L".into(), "R".into()]),
310            ("sub".into(), vec!["SW1".into()]),
311        ];
312        let target = TargetCurve::default();
313        for (fixture, positions) in [
314            (
315                include_str!(concat!(
316                    env!("CARGO_MANIFEST_DIR"),
317                    "/../../oracle/goldens/calibration/adapter_biamp.json"
318                )),
319                vec![(
320                    1,
321                    vec![("L".into(), measurement()), ("L:LF".into(), measurement())],
322                )],
323            ),
324            (
325                include_str!(concat!(
326                    env!("CARGO_MANIFEST_DIR"),
327                    "/../../oracle/goldens/calibration/adapter_non_reference_only.json"
328                )),
329                vec![
330                    (1, vec![("L".into(), measurement())]),
331                    (
332                        2,
333                        vec![
334                            ("L".into(), measurement()),
335                            ("R".into(), measurement()),
336                            ("SW1".into(), measurement()),
337                        ],
338                    ),
339                ],
340            ),
341        ] {
342            let expected: serde_json::Value = serde_json::from_str(fixture).unwrap();
343            let expected = &expected["outputs"];
344            let out = engine_inputs(
345                &ProjectView {
346                    groups: &groups,
347                    project_xo: &[],
348                    target: &target,
349                },
350                &MeasurementSet { positions },
351                &CalibrationSettings::default(),
352            )
353            .unwrap();
354            assert_eq!(
355                serde_json::to_value(&out.config.mains).unwrap(),
356                expected["mains"]
357            );
358            assert_eq!(
359                serde_json::to_value(&out.config.subs).unwrap(),
360                expected["subs"]
361            );
362            assert_eq!(
363                serde_json::to_value(&out.config.groups).unwrap(),
364                expected["groups"]
365            );
366            assert_eq!(
367                serde_json::to_value(&out.config.xo).unwrap(),
368                expected["xo"]
369            );
370            assert_eq!(
371                out.config.main_position,
372                expected["main_position"].as_u64().unwrap() as u32
373            );
374            assert_eq!(serde_json::to_value(&out.notes).unwrap(), expected["notes"]);
375            let actual_positions: Vec<_> = out
376                .measurements
377                .positions
378                .iter()
379                .map(|(position, roles)| {
380                    (
381                        *position,
382                        roles.iter().map(|(role, _)| role).collect::<Vec<_>>(),
383                    )
384                })
385                .collect();
386            assert_eq!(
387                serde_json::to_value(actual_positions).unwrap(),
388                expected["positions"]
389            );
390        }
391    }
392}
secs_engine/calibration.rs

secs_engine/
calibration.rs
