plughost-core 0.2.6

Shared types and offline render rules for plughost
Documentation
use super::*;
use crate::{EventInputRoute, EventSource, SlotEventConfig};

fn bus(id: u64, layout: Layout) -> AudioBusConfig {
    AudioBusConfig {
        id,
        layout,
        active: true,
    }
}

fn config() -> RoutedChainConfig {
    RoutedChainConfig {
        event_inputs: 0,
        sample_rate: 48_000.0,
        max_block_size: 512,
        sample_format: SampleFormat::F64,
        mode: ProcessMode::Offline,
        inputs: vec![Layout::Stereo, Layout::Mono],
        slots: vec![
            SlotAudioConfig {
                events: Default::default(),
                configuration: Some(3),
                inputs: vec![
                    AudioInputRoute {
                        bus: bus(8, Layout::Stereo),
                        source: AudioSource::External { bus: 0 },
                        adaptation: ChannelAdaptation::Exact,
                    },
                    AudioInputRoute {
                        bus: bus(9, Layout::Mono),
                        source: AudioSource::External { bus: 1 },
                        adaptation: ChannelAdaptation::Exact,
                    },
                ],
                outputs: vec![bus(10, Layout::Stereo), bus(11, Layout::Mono)],
            },
            SlotAudioConfig {
                events: Default::default(),
                configuration: None,
                inputs: vec![
                    AudioInputRoute {
                        bus: bus(0, Layout::Stereo),
                        source: AudioSource::Previous { bus: 11 },
                        adaptation: ChannelAdaptation::MonoToStereo,
                    },
                    AudioInputRoute {
                        bus: bus(1, Layout::Mono),
                        source: AudioSource::External { bus: 1 },
                        adaptation: ChannelAdaptation::Exact,
                    },
                ],
                outputs: vec![bus(20, Layout::Stereo), bus(21, Layout::Mono)],
            },
        ],
    }
}

#[test]
fn routed_chain_checks_sources_and_keeps_native_configuration_and_precision() {
    let config = config();
    assert_eq!(config.validate(2), Ok(()));
    assert_eq!(config.input_channels(), 3);
    assert_eq!(config.output_channels(), 3);
    let native = config.slot_config(0).unwrap();
    assert_eq!(native.configuration, Some(3));
    assert_eq!(native.sample_format, SampleFormat::F64);
    assert_eq!(native.input_channels(), 3);
    assert_eq!(native.output_channels(), 3);
    assert_eq!(native.validate(), Ok(()));
    assert_eq!(config.slot_config(2), Err(InputError::Slot));
}

#[test]
fn invalid_routes_are_rejected_without_inventing_sources_or_adaptations() {
    let valid = config();
    let mut invalid = valid.clone();
    invalid.slots[0].inputs[0].source = AudioSource::Previous { bus: 10 };
    assert!(matches!(
        invalid.validate(2),
        Err(InputError::AudioRoute { slot: 0, bus: 8 })
    ));
    invalid = valid.clone();
    invalid.slots[1].inputs[0].source = AudioSource::Previous { bus: 99 };
    assert!(matches!(
        invalid.validate(2),
        Err(InputError::AudioRoute { slot: 1, bus: 0 })
    ));
    invalid = valid.clone();
    invalid.slots[0].outputs[1].active = false;
    assert!(matches!(
        invalid.validate(2),
        Err(InputError::AudioRoute { .. })
    ));
    invalid = valid.clone();
    invalid.slots[0].inputs[0].source = AudioSource::External { bus: 2 };
    assert!(matches!(
        invalid.validate(2),
        Err(InputError::AudioRoute { .. })
    ));
    invalid = valid.clone();
    invalid.slots[1].inputs[0].adaptation = ChannelAdaptation::Exact;
    assert!(matches!(
        invalid.validate(2),
        Err(InputError::ChannelAdaptation { .. })
    ));
    assert_eq!(valid.validate(1), Err(InputError::AudioSlotCount));
}

fn event_config() -> RoutedChainConfig {
    let mut config = config();
    config.event_inputs = 2;
    config.slots[0].events = SlotEventConfig {
        inputs: vec![EventInputRoute {
            port: 41,
            source: EventSource::External { port: 0 },
        }],
        outputs: vec![51, 52],
    };
    config.slots[1].events = SlotEventConfig {
        inputs: vec![EventInputRoute {
            port: 61,
            source: EventSource::Previous { port: 51 },
        }],
        outputs: vec![71],
    };
    config
}

#[test]
fn event_routes_reject_missing_sources_duplicate_routes_and_duplicate_outputs() {
    let valid = event_config();
    assert_eq!(valid.validate(2), Ok(()));
    for (slot, source) in [
        (0, EventSource::Previous { port: 51 }),
        (0, EventSource::External { port: 2 }),
        (1, EventSource::Previous { port: 99 }),
    ] {
        let mut invalid = valid.clone();
        invalid.slots[slot].events.inputs[0].source = source;
        assert_eq!(
            invalid.validate(2),
            Err(InputError::EventRoute {
                slot,
                port: if slot == 0 { 41 } else { 61 },
            })
        );
    }
    let mut duplicate = valid.clone();
    duplicate.slots[1]
        .events
        .inputs
        .push(valid.slots[1].events.inputs[0]);
    assert_eq!(
        duplicate.validate(2),
        Err(InputError::EventRoute { slot: 1, port: 61 })
    );
    duplicate = valid;
    duplicate.slots[0].events.outputs.push(51);
    assert_eq!(
        duplicate.validate(2),
        Err(InputError::DuplicateEventPort { id: 51 })
    );
}

#[test]
fn sixteen_event_ports_and_merged_routes_fit_but_seventeen_do_not() {
    let mut valid = event_config();
    valid.event_inputs = 16;
    valid.slots[0].events.inputs = (0..16)
        .map(|port| EventInputRoute {
            port: 41,
            source: EventSource::External { port },
        })
        .collect();
    valid.slots[0].events.outputs = (51..67).collect();
    assert_eq!(valid.validate(2), Ok(()));
    assert_eq!(valid.slot_config(0).unwrap().events.inputs, [41]);
    for field in [0, 1, 2] {
        let mut invalid = valid.clone();
        match field {
            0 => invalid.event_inputs = 17,
            1 => invalid.slots[0].events.inputs.push(EventInputRoute {
                port: 42,
                source: EventSource::External { port: 0 },
            }),
            _ => invalid.slots[0].events.outputs.push(67),
        }
        assert_eq!(invalid.validate(2), Err(InputError::EventPortCount));
    }
}

#[test]
fn silent_and_disabled_buses_do_not_require_a_connected_source() {
    let mut config = config();
    let route = &mut config.slots[0].inputs[0];
    route.source = AudioSource::Silence;
    assert_eq!(config.validate(2), Ok(()));
    let route = &mut config.slots[0].inputs[0];
    route.source = AudioSource::Previous { bus: u64::MAX };
    route.bus.active = false;
    assert_eq!(config.validate(2), Ok(()));
    assert_eq!(config.slot_config(0).unwrap().input_channels(), 1);
}

#[test]
fn bus_validation_rejects_duplicate_ids_and_inactive_only_layouts_before_preparation() {
    let mut native = config().slot_config(0).unwrap();
    native.inputs.push(native.inputs[0]);
    assert_eq!(
        native.validate(),
        Err(InputError::DuplicateAudioBus { id: 8 })
    );
    native.inputs.pop();
    native.inputs[0].layout = Layout::None;
    assert_eq!(native.validate(), Err(InputError::AudioBusLayout { id: 8 }));
    native.inputs[0].active = false;
    assert_eq!(native.validate(), Ok(()));
    native.max_block_size = 0;
    assert_eq!(native.validate(), Err(InputError::BlockSize));
}

#[test]
fn audio_bus_limits_are_applied_before_route_expansion() {
    let mut outputs = config();
    outputs.slots[0].outputs = (0..=MAX_AUDIO_BUSES)
        .map(|id| bus(id as u64, Layout::Surround71))
        .collect();
    assert_eq!(outputs.validate(2), Err(InputError::AudioBusCount));
    let mut inputs = config();
    inputs.inputs = vec![Layout::Stereo; MAX_AUDIO_BUSES + 1];
    assert_eq!(inputs.validate(2), Err(InputError::AudioBusCount));
}