feat: add demo mode + rust own default state

src/dsp408/default.rs

@@ -0,0 +1,272 @@
+use std::collections::HashMap;
+use strum::IntoEnumIterator;
+
+use super::types::{
+    Compressor, Crossover, CrossoverFilter, CrossoverFilters, DSPConfigState, DSPState, DelayUnit,
+    DeviceFlags, DiscreteFrequency, Gate, GraphicEQ, InputChannel, InputChannelState, InputMeters,
+    InputSource, InputType, Limiter, MatrixRoutes, Meter, OutputChannel, OutputChannelState,
+    OutputMeters, PEQ, PEQBand, PEQChain, PEQFilter, PresetBank, Ratio,
+};
+
+const FREQUENCY_MIN: f32 = 19.7;
+const FREQUENCY_MAX: f32 = 20160.0;
+
+const PRESET_COUNT: usize = 20;
+
+pub fn default_dsp_state() -> DSPState {
+    DSPState {
+        name: "Default".to_string(),
+
+        flags: DeviceFlags { is_locked: false },
+
+        presets: default_preset_bank(),
+
+        current_config: default_config(),
+    }
+}
+
+pub fn default_input_meters() -> InputMeters {
+    InputMeters {
+        meters: InputChannel::iter().map(|c| (c, default_meter())).collect(),
+    }
+}
+
+pub fn default_output_meters() -> OutputMeters {
+    OutputMeters {
+        meters: OutputChannel::iter()
+            .map(|c| (c, default_meter()))
+            .collect(),
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Presets
+// -----------------------------------------------------------------------------
+
+fn default_preset_bank() -> PresetBank {
+    PresetBank {
+        current_index: 0,
+        names: vec!["Default".to_string(); PRESET_COUNT],
+        modified: vec![false; PRESET_COUNT],
+    }
+}
+
+// -----------------------------------------------------------------------------
+// DSP config
+// -----------------------------------------------------------------------------
+
+fn default_config() -> DSPConfigState {
+    DSPConfigState {
+        input_source: InputSource {
+            r#type: InputType::Analog,
+            frequency: DiscreteFrequency::F20000,
+        },
+
+        delay_unit: DelayUnit::Millisecond,
+
+        input_states: default_input_states(),
+        output_states: default_output_states(),
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Input channels
+// -----------------------------------------------------------------------------
+
+fn default_input_states() -> HashMap<InputChannel, InputChannelState> {
+    [
+        (InputChannel::InA, default_input_channel_state("In A")),
+        (InputChannel::InB, default_input_channel_state("In B")),
+        (InputChannel::InC, default_input_channel_state("In C")),
+        (InputChannel::InD, default_input_channel_state("In D")),
+    ]
+    .into_iter()
+    .collect()
+}
+
+fn default_input_channel_state(name: &str) -> InputChannelState {
+    InputChannelState {
+        name: name.to_string(),
+
+        gain: 0.0,
+        phase_inverted: false,
+        delay: 0.0,
+
+        gate: default_gate(),
+        geq: default_graphic_eq(),
+        peq_chain: default_peq_chain(),
+        crossover: default_crossover_filters(),
+
+        linked_channels: Vec::new(),
+
+        mute: false,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Output channels
+// -----------------------------------------------------------------------------
+
+fn default_output_states() -> HashMap<OutputChannel, OutputChannelState> {
+    [
+        (OutputChannel::Out1, default_output_channel_state("Out 1")),
+        (OutputChannel::Out2, default_output_channel_state("Out 2")),
+        (OutputChannel::Out3, default_output_channel_state("Out 3")),
+        (OutputChannel::Out4, default_output_channel_state("Out 4")),
+        (OutputChannel::Out5, default_output_channel_state("Out 5")),
+        (OutputChannel::Out6, default_output_channel_state("Out 6")),
+        (OutputChannel::Out7, default_output_channel_state("Out 7")),
+        (OutputChannel::Out8, default_output_channel_state("Out 8")),
+    ]
+    .into_iter()
+    .collect()
+}
+
+fn default_output_channel_state(name: &str) -> OutputChannelState {
+    OutputChannelState {
+        name: name.to_string(),
+
+        matrix_routes: default_matrix_routes(),
+
+        crossover: default_crossover_filters(),
+        peq_chain: default_peq_chain(),
+
+        compressor: default_compressor(),
+        limiter: default_limiter(),
+
+        gain: 0.0,
+        phase_inverted: false,
+        delay: 0.0,
+
+        linked_channels: Vec::new(),
+
+        mute: false,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Gate
+// -----------------------------------------------------------------------------
+
+fn default_gate() -> Gate {
+    Gate {
+        attack: 10,
+        release: 10,
+        hold: 10,
+        threshold: 0.0,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Graphic EQ
+// -----------------------------------------------------------------------------
+
+fn default_graphic_eq() -> GraphicEQ {
+    let gains = DiscreteFrequency::iter()
+        .map(|frequency| (frequency, 0.0))
+        .collect();
+
+    GraphicEQ {
+        gains,
+        bypass: false,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// PEQ
+// -----------------------------------------------------------------------------
+
+fn default_peq() -> PEQ {
+    PEQ {
+        gain: 0.0,
+        frequency: 1000.0,
+        q: 1.0,
+        filter_type: PEQFilter::Peak,
+        bypass: false,
+    }
+}
+
+fn default_peq_chain() -> PEQChain {
+    let bands = PEQBand::iter().map(|band| (band, default_peq())).collect();
+
+    PEQChain {
+        bands,
+        bypass: false,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Crossover
+// -----------------------------------------------------------------------------
+
+fn default_crossover(frequency: f32) -> Crossover {
+    Crossover {
+        frequency,
+        slope: CrossoverFilter::Bypass,
+    }
+}
+
+fn default_crossover_filters() -> CrossoverFilters {
+    CrossoverFilters {
+        high_pass: default_crossover(FREQUENCY_MIN),
+        low_pass: default_crossover(FREQUENCY_MAX),
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Matrix
+// -----------------------------------------------------------------------------
+
+fn default_matrix_routes() -> MatrixRoutes {
+    let gains = [
+        (InputChannel::InA, 0.0),
+        (InputChannel::InB, 0.0),
+        (InputChannel::InC, 0.0),
+        (InputChannel::InD, 0.0),
+    ]
+    .into_iter()
+    .collect();
+
+    MatrixRoutes {
+        connected: vec![InputChannel::InA],
+        gains,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Compressor
+// -----------------------------------------------------------------------------
+
+fn default_compressor() -> Compressor {
+    Compressor {
+        threshold: -90.0,
+        ratio: Ratio::Ratio1_1,
+        attack: 1,
+        release: 10,
+        knee: 0,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Limiter
+// -----------------------------------------------------------------------------
+
+fn default_limiter() -> Limiter {
+    Limiter {
+        threshold: -90.0,
+        attack: 1,
+        release: 10,
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Meters
+// -----------------------------------------------------------------------------
+
+fn default_meter() -> Meter {
+    Meter {
+        rms: -60.0,
+        peak: -60.0,
+        clip: false,
+    }
+}