use crate::{AudioDirection, InputError, Support};
pub const MAX_EVENT_PORTS: usize = 16;
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct EventPortInfo {
pub id: u64,
pub index: u32,
pub name: String,
pub direction: AudioDirection,
pub midi: Support,
pub sysex: Support,
pub note_expression: Support,
pub mpe: Support,
}
impl EventPortInfo {
#[must_use]
pub fn new(id: u64, index: u32, name: impl Into<String>, direction: AudioDirection) -> Self {
EventPortInfo {
id,
index,
name: name.into(),
direction,
midi: Support::Unknown,
sysex: Support::Unknown,
note_expression: Support::Unknown,
mpe: Support::Unknown,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum EventSource {
External {
port: usize,
},
Previous {
port: u64,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct EventInputRoute {
pub port: u64,
pub source: EventSource,
}
impl EventInputRoute {
#[must_use]
pub const fn new(port: u64, source: EventSource) -> EventInputRoute {
EventInputRoute { port, source }
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct SlotEventConfig {
pub inputs: Vec<EventInputRoute>,
pub outputs: Vec<u64>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct EventConfig {
pub inputs: Vec<u64>,
pub outputs: Vec<u64>,
}
impl EventConfig {
#[must_use]
pub fn new(inputs: Vec<u64>, outputs: Vec<u64>) -> EventConfig {
EventConfig { inputs, outputs }
}
}
impl SlotEventConfig {
#[must_use]
pub fn new(inputs: Vec<EventInputRoute>, outputs: Vec<u64>) -> SlotEventConfig {
SlotEventConfig { inputs, outputs }
}
#[doc(hidden)]
pub fn native(&self) -> EventConfig {
let mut inputs: Vec<u64> = Vec::new();
for route in &self.inputs {
if !inputs.contains(&route.port) {
inputs.push(route.port);
}
}
EventConfig {
inputs,
outputs: self.outputs.clone(),
}
}
pub(crate) fn validate(
&self,
slot: usize,
event_inputs: usize,
previous: Option<&SlotEventConfig>,
) -> Result<(), InputError> {
if self.inputs.len() > MAX_EVENT_PORTS || self.outputs.len() > MAX_EVENT_PORTS {
return Err(InputError::EventPortCount);
}
for (index, port) in self.outputs.iter().enumerate() {
if self.outputs[..index].contains(port) {
return Err(InputError::DuplicateEventPort { id: *port });
}
}
for (index, route) in self.inputs.iter().enumerate() {
let available = match route.source {
EventSource::External { port } => port < event_inputs,
EventSource::Previous { port } => {
previous.is_some_and(|previous| previous.outputs.contains(&port))
}
};
if !available || self.inputs[..index].contains(route) {
return Err(InputError::EventRoute {
slot,
port: route.port,
});
}
}
Ok(())
}
}