1use crate::{InputError, Layout, ProcessMode, SampleFormat, Support};
4
5pub const MAX_AUDIO_BUSES: usize = 64;
7pub const MAX_AUDIO_CHANNELS: usize = 512;
9pub const MAX_ALIGNMENT_BYTES: usize = 256 * 1024 * 1024;
16
17#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
19#[non_exhaustive]
20pub enum AudioDirection {
21 Input,
23 Output,
25}
26
27#[derive(Clone, Copy, Debug, PartialEq, Eq)]
29#[non_exhaustive]
30pub enum AudioBusRole {
31 Main,
33 Auxiliary,
35}
36
37#[derive(Clone, Debug, PartialEq, Eq)]
40#[non_exhaustive]
41pub struct AudioBusInfo {
42 pub id: u64,
44 pub index: u32,
46 pub name: String,
48 pub direction: AudioDirection,
50 pub role: AudioBusRole,
52 pub layout: Option<Layout>,
54 pub channels: u32,
56 pub active: Option<bool>,
58 pub f32: Support,
60 pub f64: Support,
62}
63
64impl AudioBusInfo {
65 #[must_use]
67 pub fn new(
68 id: u64,
69 index: u32,
70 name: impl Into<String>,
71 direction: AudioDirection,
72 role: AudioBusRole,
73 channels: u32,
74 ) -> AudioBusInfo {
75 AudioBusInfo {
76 id,
77 index,
78 name: name.into(),
79 direction,
80 role,
81 layout: None,
82 channels,
83 active: None,
84 f32: Support::Unknown,
85 f64: Support::Unknown,
86 }
87 }
88}
89
90#[derive(Clone, Debug, PartialEq, Eq)]
92#[non_exhaustive]
93pub struct AudioConfiguration {
94 pub id: u64,
96 pub name: String,
98 pub inputs: Vec<AudioBusInfo>,
100 pub outputs: Vec<AudioBusInfo>,
102}
103
104impl AudioConfiguration {
105 #[doc(hidden)]
107 #[must_use]
108 pub fn new(
109 id: u64,
110 name: String,
111 inputs: Vec<AudioBusInfo>,
112 outputs: Vec<AudioBusInfo>,
113 ) -> AudioConfiguration {
114 AudioConfiguration {
115 id,
116 name,
117 inputs,
118 outputs,
119 }
120 }
121}
122
123#[derive(Clone, Copy, Debug, PartialEq, Eq)]
125#[non_exhaustive]
126pub struct AudioBusConfig {
127 pub id: u64,
129 pub layout: Layout,
131 pub active: bool,
133}
134
135impl AudioBusConfig {
136 #[must_use]
138 pub const fn new(id: u64, layout: Layout, active: bool) -> AudioBusConfig {
139 AudioBusConfig { id, layout, active }
140 }
141}
142
143#[derive(Clone, Debug, PartialEq)]
146#[non_exhaustive]
147pub struct AudioConfig {
148 pub sample_rate: f64,
150 pub max_block_size: usize,
152 pub sample_format: SampleFormat,
154 pub mode: ProcessMode,
156 pub configuration: Option<u64>,
158 pub inputs: Vec<AudioBusConfig>,
160 pub outputs: Vec<AudioBusConfig>,
162 pub events: crate::EventConfig,
164}
165
166#[derive(Clone, Copy, Debug, PartialEq, Eq)]
168#[non_exhaustive]
169pub struct BypassState {
170 pub support: Support,
172 pub enabled: Option<bool>,
174}
175
176impl BypassState {
177 #[doc(hidden)]
179 #[must_use]
180 pub fn new(support: Support, enabled: Option<bool>) -> BypassState {
181 BypassState { support, enabled }
182 }
183}
184
185#[derive(Clone, Copy, Debug, PartialEq, Eq)]
187#[non_exhaustive]
188pub enum ChannelAdaptation {
189 Exact,
191 MonoToStereo,
193 StereoToMono,
195}
196
197#[derive(Clone, Copy, Debug, PartialEq, Eq)]
199#[non_exhaustive]
200pub enum AudioSource {
201 External {
203 bus: usize,
205 },
206 Previous {
208 bus: u64,
210 },
211 Silence,
213}
214
215#[derive(Clone, Copy, Debug, PartialEq, Eq)]
217#[non_exhaustive]
218pub struct AudioInputRoute {
219 pub bus: AudioBusConfig,
221 pub source: AudioSource,
223 pub adaptation: ChannelAdaptation,
225}
226
227impl AudioInputRoute {
228 #[must_use]
230 pub const fn new(bus: AudioBusConfig, source: AudioSource) -> AudioInputRoute {
231 AudioInputRoute {
232 bus,
233 source,
234 adaptation: ChannelAdaptation::Exact,
235 }
236 }
237
238 #[must_use]
240 pub const fn with_adaptation(mut self, adaptation: ChannelAdaptation) -> AudioInputRoute {
241 self.adaptation = adaptation;
242 self
243 }
244}
245
246#[derive(Clone, Debug, PartialEq, Eq)]
248#[non_exhaustive]
249pub struct SlotAudioConfig {
250 pub configuration: Option<u64>,
252 pub inputs: Vec<AudioInputRoute>,
254 pub outputs: Vec<AudioBusConfig>,
256 pub events: crate::SlotEventConfig,
258}
259
260impl SlotAudioConfig {
261 #[must_use]
264 pub fn new(inputs: Vec<AudioInputRoute>, outputs: Vec<AudioBusConfig>) -> SlotAudioConfig {
265 SlotAudioConfig {
266 configuration: None,
267 inputs,
268 outputs,
269 events: crate::SlotEventConfig::default(),
270 }
271 }
272
273 #[must_use]
275 pub fn with_configuration(mut self, configuration: u64) -> SlotAudioConfig {
276 self.configuration = Some(configuration);
277 self
278 }
279
280 #[must_use]
282 pub fn with_events(mut self, events: crate::SlotEventConfig) -> SlotAudioConfig {
283 self.events = events;
284 self
285 }
286}
287
288#[derive(Clone, Debug, PartialEq)]
293#[non_exhaustive]
294pub struct RoutedChainConfig {
295 pub sample_rate: f64,
297 pub max_block_size: usize,
299 pub sample_format: SampleFormat,
301 pub mode: ProcessMode,
303 pub inputs: Vec<Layout>,
305 pub event_inputs: usize,
307 pub slots: Vec<SlotAudioConfig>,
309}
310
311impl AudioConfig {
312 #[must_use]
315 pub fn new(
316 sample_rate: f64,
317 max_block_size: usize,
318 sample_format: SampleFormat,
319 inputs: Vec<AudioBusConfig>,
320 outputs: Vec<AudioBusConfig>,
321 ) -> AudioConfig {
322 AudioConfig {
323 sample_rate,
324 max_block_size,
325 sample_format,
326 mode: ProcessMode::Offline,
327 configuration: None,
328 inputs,
329 outputs,
330 events: crate::EventConfig::default(),
331 }
332 }
333
334 #[must_use]
336 pub fn with_mode(mut self, mode: ProcessMode) -> AudioConfig {
337 self.mode = mode;
338 self
339 }
340
341 #[must_use]
343 pub fn with_configuration(mut self, configuration: u64) -> AudioConfig {
344 self.configuration = Some(configuration);
345 self
346 }
347
348 #[must_use]
350 pub fn with_events(mut self, events: crate::EventConfig) -> AudioConfig {
351 self.events = events;
352 self
353 }
354
355 pub fn validate(&self) -> Result<(), InputError> {
357 crate::config::validate_processing(self.sample_rate, self.max_block_size)?;
358 validate_buses(&self.inputs)?;
359 validate_buses(&self.outputs)
360 }
361
362 pub fn input_channels(&self) -> usize {
364 active_channels(&self.inputs)
365 }
366
367 pub fn output_channels(&self) -> usize {
369 active_channels(&self.outputs)
370 }
371}
372
373impl RoutedChainConfig {
374 #[must_use]
377 pub fn new(
378 sample_rate: f64,
379 max_block_size: usize,
380 sample_format: SampleFormat,
381 inputs: Vec<Layout>,
382 slots: Vec<SlotAudioConfig>,
383 ) -> RoutedChainConfig {
384 RoutedChainConfig {
385 sample_rate,
386 max_block_size,
387 sample_format,
388 mode: ProcessMode::Offline,
389 inputs,
390 event_inputs: 0,
391 slots,
392 }
393 }
394
395 #[must_use]
397 pub fn with_mode(mut self, mode: ProcessMode) -> RoutedChainConfig {
398 self.mode = mode;
399 self
400 }
401
402 #[must_use]
404 pub fn with_event_inputs(mut self, event_inputs: usize) -> RoutedChainConfig {
405 self.event_inputs = event_inputs;
406 self
407 }
408
409 pub fn validate(&self, slots: usize) -> Result<(), InputError> {
412 if slots == 0 {
413 return Err(InputError::EmptyChain);
414 }
415 if self.slots.len() != slots {
416 return Err(InputError::AudioSlotCount);
417 }
418 crate::config::validate_processing(self.sample_rate, self.max_block_size)?;
419 if self.inputs.len() > MAX_AUDIO_BUSES {
420 return Err(InputError::AudioBusCount);
421 }
422 if self.input_channels() > MAX_AUDIO_CHANNELS {
423 return Err(InputError::AudioChannelCount);
424 }
425 if self.event_inputs > crate::MAX_EVENT_PORTS {
426 return Err(InputError::EventPortCount);
427 }
428 for (slot, config) in self.slots.iter().enumerate() {
429 let previous = slot
430 .checked_sub(1)
431 .map(|previous| &self.slots[previous].events);
432 config.events.validate(slot, self.event_inputs, previous)?;
433 if config.inputs.len() > MAX_AUDIO_BUSES {
434 return Err(InputError::AudioBusCount);
435 }
436 let inputs: Vec<AudioBusConfig> = config.inputs.iter().map(|route| route.bus).collect();
437 validate_buses(&inputs)?;
438 validate_buses(&config.outputs)?;
439 for route in &config.inputs {
440 if !route.bus.active {
442 continue;
443 }
444 let source = match route.source {
445 AudioSource::External { bus } => self.inputs.get(bus).copied(),
446 AudioSource::Previous { bus } => slot
447 .checked_sub(1)
448 .and_then(|previous| {
449 self.slots[previous]
450 .outputs
451 .iter()
452 .find(|output| output.id == bus && output.active)
453 })
454 .map(|output| output.layout),
455 AudioSource::Silence => Some(route.bus.layout),
457 }
458 .ok_or(InputError::AudioRoute {
459 slot,
460 bus: route.bus.id,
461 })?;
462 route.adaptation.validate(source, route.bus.layout)?;
463 }
464 }
465 Ok(())
466 }
467
468 pub fn input_channels(&self) -> usize {
470 self.inputs.iter().map(|layout| layout.channels()).sum()
471 }
472
473 pub fn output_channels(&self) -> usize {
475 self.slots
476 .last()
477 .map_or(0, |slot| active_channels(&slot.outputs))
478 }
479
480 pub fn event_outputs(&self) -> usize {
482 self.slots
483 .last()
484 .map_or(0, |slot| slot.events.outputs.len())
485 }
486
487 #[doc(hidden)]
490 pub fn slot_config(&self, slot: usize) -> Result<AudioConfig, InputError> {
491 let config = self.slots.get(slot).ok_or(InputError::Slot)?;
492 Ok(AudioConfig {
493 sample_rate: self.sample_rate,
494 max_block_size: self.max_block_size,
495 sample_format: self.sample_format,
496 mode: self.mode,
497 configuration: config.configuration,
498 inputs: config.inputs.iter().map(|route| route.bus).collect(),
499 outputs: config.outputs.clone(),
500 events: config.events.native(),
501 })
502 }
503}
504
505impl ChannelAdaptation {
506 pub fn validate(self, source: Layout, target: Layout) -> Result<(), InputError> {
508 let valid = match self {
509 Self::Exact => source == target,
510 Self::MonoToStereo => source == Layout::Mono && target == Layout::Stereo,
511 Self::StereoToMono => source == Layout::Stereo && target == Layout::Mono,
512 };
513 if !valid {
514 return Err(InputError::ChannelAdaptation { source, target });
515 }
516 Ok(())
517 }
518}
519
520fn active_channels(buses: &[AudioBusConfig]) -> usize {
521 buses
522 .iter()
523 .filter(|bus| bus.active)
524 .map(|bus| bus.layout.channels())
525 .sum()
526}
527
528fn validate_buses(buses: &[AudioBusConfig]) -> Result<(), InputError> {
529 if buses.len() > MAX_AUDIO_BUSES {
530 return Err(InputError::AudioBusCount);
531 }
532 for (index, bus) in buses.iter().enumerate() {
533 if buses[..index].iter().any(|previous| previous.id == bus.id) {
534 return Err(InputError::DuplicateAudioBus { id: bus.id });
535 }
536 if bus.active && bus.layout == Layout::None {
537 return Err(InputError::AudioBusLayout { id: bus.id });
538 }
539 }
540 if active_channels(buses) > MAX_AUDIO_CHANNELS {
541 return Err(InputError::AudioChannelCount);
542 }
543 Ok(())
544}
545
546#[cfg(test)]
547mod tests;