dsp-thomann/src/dsp408/default.rs

use std::collections::HashMap;
use strum::IntoEnumIterator;

use crate::dsp408::types::ConnectionStatus;
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: true },

        presets: default_preset_bank(),

        current_config: default_config(),

        connection: ConnectionStatus::Disconnected,
    }
}

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", false),
        ),
        (InputChannel::InB, default_input_channel_state("In B", true)),
        (
            InputChannel::InC,
            default_input_channel_state("In C", false),
        ),
        (
            InputChannel::InD,
            default_input_channel_state("In D", false),
        ),
    ]
    .into_iter()
    .collect()
}

fn default_input_channel_state(name: &str, a: bool) -> InputChannelState {
    if a {
        return 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![InputChannel::InA],
            // linked_channels: Vec::new(),
            mute: false,
        };
    }

    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,
    }
}