use crate::{InputError, Layout, ProcessMode, SampleFormat, Support};
pub const MAX_AUDIO_BUSES: usize = 64;
pub const MAX_AUDIO_CHANNELS: usize = 512;
pub const MAX_ALIGNMENT_BYTES: usize = 256 * 1024 * 1024;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum AudioDirection {
Input,
Output,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum AudioBusRole {
Main,
Auxiliary,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct AudioBusInfo {
pub id: u64,
pub index: u32,
pub name: String,
pub direction: AudioDirection,
pub role: AudioBusRole,
pub layout: Option<Layout>,
pub channels: u32,
pub active: Option<bool>,
pub f32: Support,
pub f64: Support,
}
impl AudioBusInfo {
#[must_use]
pub fn new(
id: u64,
index: u32,
name: impl Into<String>,
direction: AudioDirection,
role: AudioBusRole,
channels: u32,
) -> AudioBusInfo {
AudioBusInfo {
id,
index,
name: name.into(),
direction,
role,
layout: None,
channels,
active: None,
f32: Support::Unknown,
f64: Support::Unknown,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct AudioConfiguration {
pub id: u64,
pub name: String,
pub inputs: Vec<AudioBusInfo>,
pub outputs: Vec<AudioBusInfo>,
}
impl AudioConfiguration {
#[doc(hidden)]
#[must_use]
pub fn new(
id: u64,
name: String,
inputs: Vec<AudioBusInfo>,
outputs: Vec<AudioBusInfo>,
) -> AudioConfiguration {
AudioConfiguration {
id,
name,
inputs,
outputs,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct AudioBusConfig {
pub id: u64,
pub layout: Layout,
pub active: bool,
}
impl AudioBusConfig {
#[must_use]
pub const fn new(id: u64, layout: Layout, active: bool) -> AudioBusConfig {
AudioBusConfig { id, layout, active }
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct AudioConfig {
pub sample_rate: f64,
pub max_block_size: usize,
pub sample_format: SampleFormat,
pub mode: ProcessMode,
pub configuration: Option<u64>,
pub inputs: Vec<AudioBusConfig>,
pub outputs: Vec<AudioBusConfig>,
pub events: crate::EventConfig,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct BypassState {
pub support: Support,
pub enabled: Option<bool>,
}
impl BypassState {
#[doc(hidden)]
#[must_use]
pub fn new(support: Support, enabled: Option<bool>) -> BypassState {
BypassState { support, enabled }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum ChannelAdaptation {
Exact,
MonoToStereo,
StereoToMono,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum AudioSource {
External {
bus: usize,
},
Previous {
bus: u64,
},
Silence,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct AudioInputRoute {
pub bus: AudioBusConfig,
pub source: AudioSource,
pub adaptation: ChannelAdaptation,
}
impl AudioInputRoute {
#[must_use]
pub const fn new(bus: AudioBusConfig, source: AudioSource) -> AudioInputRoute {
AudioInputRoute {
bus,
source,
adaptation: ChannelAdaptation::Exact,
}
}
#[must_use]
pub const fn with_adaptation(mut self, adaptation: ChannelAdaptation) -> AudioInputRoute {
self.adaptation = adaptation;
self
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct SlotAudioConfig {
pub configuration: Option<u64>,
pub inputs: Vec<AudioInputRoute>,
pub outputs: Vec<AudioBusConfig>,
pub events: crate::SlotEventConfig,
}
impl SlotAudioConfig {
#[must_use]
pub fn new(inputs: Vec<AudioInputRoute>, outputs: Vec<AudioBusConfig>) -> SlotAudioConfig {
SlotAudioConfig {
configuration: None,
inputs,
outputs,
events: crate::SlotEventConfig::default(),
}
}
#[must_use]
pub fn with_configuration(mut self, configuration: u64) -> SlotAudioConfig {
self.configuration = Some(configuration);
self
}
#[must_use]
pub fn with_events(mut self, events: crate::SlotEventConfig) -> SlotAudioConfig {
self.events = events;
self
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct RoutedChainConfig {
pub sample_rate: f64,
pub max_block_size: usize,
pub sample_format: SampleFormat,
pub mode: ProcessMode,
pub inputs: Vec<Layout>,
pub event_inputs: usize,
pub slots: Vec<SlotAudioConfig>,
}
impl AudioConfig {
#[must_use]
pub fn new(
sample_rate: f64,
max_block_size: usize,
sample_format: SampleFormat,
inputs: Vec<AudioBusConfig>,
outputs: Vec<AudioBusConfig>,
) -> AudioConfig {
AudioConfig {
sample_rate,
max_block_size,
sample_format,
mode: ProcessMode::Offline,
configuration: None,
inputs,
outputs,
events: crate::EventConfig::default(),
}
}
#[must_use]
pub fn with_mode(mut self, mode: ProcessMode) -> AudioConfig {
self.mode = mode;
self
}
#[must_use]
pub fn with_configuration(mut self, configuration: u64) -> AudioConfig {
self.configuration = Some(configuration);
self
}
#[must_use]
pub fn with_events(mut self, events: crate::EventConfig) -> AudioConfig {
self.events = events;
self
}
pub fn validate(&self) -> Result<(), InputError> {
crate::config::validate_processing(self.sample_rate, self.max_block_size)?;
validate_buses(&self.inputs)?;
validate_buses(&self.outputs)
}
pub fn input_channels(&self) -> usize {
active_channels(&self.inputs)
}
pub fn output_channels(&self) -> usize {
active_channels(&self.outputs)
}
}
impl RoutedChainConfig {
#[must_use]
pub fn new(
sample_rate: f64,
max_block_size: usize,
sample_format: SampleFormat,
inputs: Vec<Layout>,
slots: Vec<SlotAudioConfig>,
) -> RoutedChainConfig {
RoutedChainConfig {
sample_rate,
max_block_size,
sample_format,
mode: ProcessMode::Offline,
inputs,
event_inputs: 0,
slots,
}
}
#[must_use]
pub fn with_mode(mut self, mode: ProcessMode) -> RoutedChainConfig {
self.mode = mode;
self
}
#[must_use]
pub fn with_event_inputs(mut self, event_inputs: usize) -> RoutedChainConfig {
self.event_inputs = event_inputs;
self
}
pub fn validate(&self, slots: usize) -> Result<(), InputError> {
if slots == 0 {
return Err(InputError::EmptyChain);
}
if self.slots.len() != slots {
return Err(InputError::AudioSlotCount);
}
crate::config::validate_processing(self.sample_rate, self.max_block_size)?;
if self.inputs.len() > MAX_AUDIO_BUSES {
return Err(InputError::AudioBusCount);
}
if self.input_channels() > MAX_AUDIO_CHANNELS {
return Err(InputError::AudioChannelCount);
}
if self.event_inputs > crate::MAX_EVENT_PORTS {
return Err(InputError::EventPortCount);
}
for (slot, config) in self.slots.iter().enumerate() {
let previous = slot
.checked_sub(1)
.map(|previous| &self.slots[previous].events);
config.events.validate(slot, self.event_inputs, previous)?;
if config.inputs.len() > MAX_AUDIO_BUSES {
return Err(InputError::AudioBusCount);
}
let inputs: Vec<AudioBusConfig> = config.inputs.iter().map(|route| route.bus).collect();
validate_buses(&inputs)?;
validate_buses(&config.outputs)?;
for route in &config.inputs {
if !route.bus.active {
continue;
}
let source = match route.source {
AudioSource::External { bus } => self.inputs.get(bus).copied(),
AudioSource::Previous { bus } => slot
.checked_sub(1)
.and_then(|previous| {
self.slots[previous]
.outputs
.iter()
.find(|output| output.id == bus && output.active)
})
.map(|output| output.layout),
AudioSource::Silence => Some(route.bus.layout),
}
.ok_or(InputError::AudioRoute {
slot,
bus: route.bus.id,
})?;
route.adaptation.validate(source, route.bus.layout)?;
}
}
Ok(())
}
pub fn input_channels(&self) -> usize {
self.inputs.iter().map(|layout| layout.channels()).sum()
}
pub fn output_channels(&self) -> usize {
self.slots
.last()
.map_or(0, |slot| active_channels(&slot.outputs))
}
pub fn event_outputs(&self) -> usize {
self.slots
.last()
.map_or(0, |slot| slot.events.outputs.len())
}
#[doc(hidden)]
pub fn slot_config(&self, slot: usize) -> Result<AudioConfig, InputError> {
let config = self.slots.get(slot).ok_or(InputError::Slot)?;
Ok(AudioConfig {
sample_rate: self.sample_rate,
max_block_size: self.max_block_size,
sample_format: self.sample_format,
mode: self.mode,
configuration: config.configuration,
inputs: config.inputs.iter().map(|route| route.bus).collect(),
outputs: config.outputs.clone(),
events: config.events.native(),
})
}
}
impl ChannelAdaptation {
pub fn validate(self, source: Layout, target: Layout) -> Result<(), InputError> {
let valid = match self {
Self::Exact => source == target,
Self::MonoToStereo => source == Layout::Mono && target == Layout::Stereo,
Self::StereoToMono => source == Layout::Stereo && target == Layout::Mono,
};
if !valid {
return Err(InputError::ChannelAdaptation { source, target });
}
Ok(())
}
}
fn active_channels(buses: &[AudioBusConfig]) -> usize {
buses
.iter()
.filter(|bus| bus.active)
.map(|bus| bus.layout.channels())
.sum()
}
fn validate_buses(buses: &[AudioBusConfig]) -> Result<(), InputError> {
if buses.len() > MAX_AUDIO_BUSES {
return Err(InputError::AudioBusCount);
}
for (index, bus) in buses.iter().enumerate() {
if buses[..index].iter().any(|previous| previous.id == bus.id) {
return Err(InputError::DuplicateAudioBus { id: bus.id });
}
if bus.active && bus.layout == Layout::None {
return Err(InputError::AudioBusLayout { id: bus.id });
}
}
if active_channels(buses) > MAX_AUDIO_CHANNELS {
return Err(InputError::AudioChannelCount);
}
Ok(())
}
#[cfg(test)]
mod tests;