mod activity;
pub mod clock;
mod doorbell;
mod errors;
#[cfg(any(test, fuzzing))]
pub mod fuzz;
mod memory;
pub mod realtime;
mod samples;
#[cfg(test)]
mod tests;
pub mod transfer;
use std::io;
use std::sync::atomic::{AtomicU64, Ordering};
use serde::{Deserialize, Serialize};
use serde_with::serde_as;
use crate::{
AutomationEvent, Event, EventData, Events, ExpressionKind, MAX_AUDIO_CHANNELS,
MAX_BLOCK_EVENTS, MAX_BLOCK_SYSEX_BYTES, Note, NoteExpression, SampleFormat,
};
pub use activity::{Activity, Caller};
use errors::{BLOCK, CONFIGURATION, EVENTS, GENERATION, invalid};
use memory::{Handle, Memory};
pub const MAX_SHARED_BYTES: usize = 256 << 20;
const AUTOMATION_BYTES: usize = 32;
const EVENT_BYTES: usize = 32;
const MIDI_KIND: u64 = 0;
const SYSEX_KIND: u64 = 1;
const NOTE_ON_KIND: u64 = 2;
const NOTE_OFF_KIND: u64 = 3;
const EXPRESSION_KIND: u64 = 4;
#[serde_as]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SlotConfig {
#[serde_as(as = "super::wire::SampleFormatDef")]
pub sample_format: SampleFormat,
pub max_frames: usize,
pub input_channels: usize,
pub output_channels: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Descriptor {
pub generation: u64,
pub config: SlotConfig,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Submission {
pub generation: u64,
pub sequence: u64,
pub frames: usize,
pub automation: usize,
pub events: usize,
}
#[derive(Clone, Copy)]
struct EventRegion {
slots: usize,
sysex: usize,
}
struct Layout {
input: usize,
output: usize,
automation: usize,
input_events: EventRegion,
output_events: EventRegion,
bytes: usize,
}
impl SlotConfig {
pub fn input_storage(self) -> io::Result<super::AudioSamples> {
self.storage(self.input_channels)
}
pub fn output_storage(self) -> io::Result<super::AudioSamples> {
self.storage(self.output_channels)
}
fn storage(self, channels: usize) -> io::Result<super::AudioSamples> {
self.layout()?;
fn reserve<S>(channels: usize, frames: usize) -> io::Result<Vec<Vec<S>>> {
(0..channels)
.map(|_| {
let mut samples = Vec::new();
samples
.try_reserve_exact(frames)
.map_err(|_| invalid(errors::STORAGE))?;
Ok(samples)
})
.collect()
}
Ok(match self.sample_format {
SampleFormat::F32 => super::AudioSamples::F32(reserve(channels, self.max_frames)?),
SampleFormat::F64 => super::AudioSamples::F64(reserve(channels, self.max_frames)?),
})
}
fn layout(self) -> io::Result<Layout> {
if self.max_frames == 0
|| self.max_frames > i32::MAX as usize
|| self.input_channels > MAX_AUDIO_CHANNELS
|| self.output_channels > MAX_AUDIO_CHANNELS
{
return Err(invalid(CONFIGURATION));
}
let width = match self.sample_format {
SampleFormat::F32 => 4,
SampleFormat::F64 => 8,
};
let pcm = |channels: usize| -> io::Result<usize> {
self.max_frames
.checked_mul(channels)
.and_then(|n| n.checked_mul(width))
.and_then(|n| n.checked_add(7))
.map(|n| n & !7)
.ok_or_else(|| invalid(CONFIGURATION))
};
let input = 0;
let output = pcm(self.input_channels)?;
let automation = output
.checked_add(pcm(self.output_channels)?)
.ok_or_else(|| invalid(CONFIGURATION))?;
let events = |start: usize| -> io::Result<(EventRegion, usize)> {
let sysex = start
.checked_add(MAX_BLOCK_EVENTS * EVENT_BYTES)
.ok_or_else(|| invalid(CONFIGURATION))?;
let end = sysex
.checked_add(MAX_BLOCK_SYSEX_BYTES)
.ok_or_else(|| invalid(CONFIGURATION))?;
Ok((
EventRegion {
slots: start,
sysex,
},
end,
))
};
let (input_events, end) = events(
automation
.checked_add(MAX_BLOCK_EVENTS * AUTOMATION_BYTES)
.ok_or_else(|| invalid(CONFIGURATION))?,
)?;
let (output_events, bytes) = events(end)?;
if bytes > MAX_SHARED_BYTES {
return Err(invalid(CONFIGURATION));
}
Ok(Layout {
input,
output,
automation,
input_events,
output_events,
bytes,
})
}
}
pub struct SharedAudio {
memory: Memory,
descriptor: Descriptor,
layout: Layout,
}
impl SharedAudio {
pub fn new(descriptor: Descriptor) -> io::Result<Self> {
let layout = descriptor.config.layout()?;
Self::with_memory(Memory::new(layout.bytes)?, descriptor)
}
unsafe fn open(handle: Handle, descriptor: Descriptor) -> io::Result<Self> {
let layout = descriptor.config.layout()?;
Self::with_memory(unsafe { Memory::open(handle, layout.bytes) }?, descriptor)
}
fn with_memory(memory: Memory, descriptor: Descriptor) -> io::Result<Self> {
if descriptor.generation == 0 {
return Err(invalid(CONFIGURATION));
}
Ok(Self {
memory,
descriptor,
layout: descriptor.config.layout()?,
})
}
pub fn descriptor(&self) -> Descriptor {
self.descriptor
}
fn word(&self, offset: usize) -> &AtomicU64 {
assert!(offset.is_multiple_of(8) && offset <= self.layout.bytes - 8);
unsafe { &*self.memory.as_ptr().add(offset).cast::<AtomicU64>() }
}
fn load(&self, offset: usize) -> u64 {
self.word(offset).load(Ordering::Relaxed)
}
fn store(&self, offset: usize, value: u64) {
self.word(offset).store(value, Ordering::Relaxed);
}
fn check_submission(&self, submission: Submission) -> io::Result<()> {
if submission.generation != self.descriptor.generation {
return Err(invalid(GENERATION));
}
if submission.frames > self.descriptor.config.max_frames
|| crate::event::validate_event_count(submission.automation, submission.events).is_err()
{
return Err(invalid(BLOCK));
}
Ok(())
}
fn write_automation(&self, automation: &[AutomationEvent]) {
for (index, event) in automation.iter().enumerate() {
let offset = self.layout.automation + index * AUTOMATION_BYTES;
self.store(offset, event.slot as u64);
self.store(offset + 8, event.change.id);
self.store(offset + 16, event.change.offset as u64);
self.store(offset + 24, event.change.value.to_bits());
}
}
fn write_events(&self, region: EventRegion, events: &Events) {
let mut sysex = 0;
for (index, event) in events.iter().enumerate() {
let offset = region.slots + index * EVENT_BYTES;
let note = |kind: u64, channel: u8, key: u8, expression: u64| {
kind | u64::from(channel) << 8 | u64::from(key) << 16 | expression << 24
};
let id = |id: Option<u32>| id.map_or(0, |id| u64::from(id) + 1);
let (header, id, payload) = match event.data {
EventData::Midi([status, first, second]) => (
MIDI_KIND,
0,
u64::from(u32::from_le_bytes([status, first, second, 0])),
),
EventData::SysEx(bytes) => {
let destination = self.memory.as_ptr().wrapping_add(region.sysex + sysex);
unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), destination, bytes.len())
};
let range = sysex as u64 | (bytes.len() as u64) << 32;
sysex += bytes.len();
(SYSEX_KIND, 0, range)
}
EventData::NoteOn(on) => (
note(NOTE_ON_KIND, on.channel, on.key, 0),
id(on.id),
on.velocity.to_bits(),
),
EventData::NoteOff(off) => (
note(NOTE_OFF_KIND, off.channel, off.key, 0),
id(off.id),
off.velocity.to_bits(),
),
EventData::Expression(expression) => (
note(
EXPRESSION_KIND,
expression.channel,
expression.key,
expression_code(expression.kind),
),
id(expression.id),
expression.value.to_bits(),
),
};
self.store(offset, event.offset as u64);
self.store(offset + 8, u64::from(event.port as u32) | header << 32);
self.store(offset + 16, id);
self.store(offset + 24, payload);
}
}
fn read_automation(
&self,
count: usize,
automation: &mut Vec<AutomationEvent>,
) -> io::Result<()> {
if automation.capacity() < count {
return Err(invalid(BLOCK));
}
automation.clear();
for index in 0..count {
let offset = self.layout.automation + index * AUTOMATION_BYTES;
automation.push(AutomationEvent {
slot: usize::try_from(self.load(offset)).map_err(|_| invalid(EVENTS))?,
change: crate::ParameterChange {
id: self.load(offset + 8),
offset: usize::try_from(self.load(offset + 16)).map_err(|_| invalid(EVENTS))?,
value: f64::from_bits(self.load(offset + 24)),
},
});
}
Ok(())
}
fn read_events(
&self,
region: EventRegion,
count: usize,
events: &mut Events,
mut skipped: Option<&mut usize>,
) -> io::Result<()> {
if count > MAX_BLOCK_EVENTS {
return Err(invalid(BLOCK));
}
events.clear();
let mut sysex_bytes = 0;
for index in 0..count {
let offset = region.slots + index * EVENT_BYTES;
let port = self.load(offset + 8);
let header = port >> 32;
let (channel, key) = ((header >> 8) as u8, (header >> 16) as u8);
let id = match self.load(offset + 16) {
0 => None,
id => Some(u32::try_from(id - 1).map_err(|_| invalid(EVENTS))?),
};
let payload = self.load(offset + 24);
let time = usize::try_from(self.load(offset)).map_err(|_| invalid(EVENTS))?;
let port = (port & u64::from(u32::MAX)) as usize;
let note = || Note {
id,
channel,
key,
velocity: f64::from_bits(payload),
};
let data = match header & 0xFF {
MIDI_KIND => {
let bytes = (payload as u32).to_le_bytes();
EventData::Midi([bytes[0], bytes[1], bytes[2]])
}
SYSEX_KIND => {
let start = (payload & u64::from(u32::MAX)) as usize;
let length = (payload >> 32) as usize;
sysex_bytes += length;
if start
.checked_add(length)
.is_none_or(|end| end > MAX_BLOCK_SYSEX_BYTES)
|| sysex_bytes > MAX_BLOCK_SYSEX_BYTES
{
return Err(invalid(EVENTS));
}
let source = self.memory.as_ptr().wrapping_add(region.sysex + start);
let copy = |bytes: &mut [u8]| unsafe {
std::ptr::copy_nonoverlapping(source, bytes.as_mut_ptr(), length)
};
let pushed = events.push_sysex_within_capacity(time, port, length, copy);
match skipped.as_deref_mut() {
Some(skipped) => *skipped += usize::from(!pushed),
None if !pushed => return Err(invalid(BLOCK)),
None => {}
}
continue;
}
NOTE_ON_KIND => EventData::NoteOn(note()),
NOTE_OFF_KIND => EventData::NoteOff(note()),
EXPRESSION_KIND => EventData::Expression(NoteExpression {
id,
channel,
key,
kind: expression_kind(header >> 24 & 0xFF).ok_or_else(|| invalid(EVENTS))?,
value: f64::from_bits(payload),
}),
_ => return Err(invalid(EVENTS)),
};
let event = Event {
offset: time,
port,
data,
};
let pushed = events.push_within_capacity(event);
match skipped.as_deref_mut() {
Some(skipped) => *skipped += usize::from(!pushed),
None if !pushed => return Err(invalid(BLOCK)),
None => {}
}
}
Ok(())
}
}
fn expression_code(kind: ExpressionKind) -> u64 {
match kind {
ExpressionKind::Volume => 0,
ExpressionKind::Pan => 1,
ExpressionKind::Tuning => 2,
ExpressionKind::Vibrato => 3,
ExpressionKind::Expression => 4,
ExpressionKind::Brightness => 5,
ExpressionKind::Pressure => 6,
}
}
fn expression_kind(code: u64) -> Option<ExpressionKind> {
ExpressionKind::ALL
.into_iter()
.find(|&kind| expression_code(kind) == code)
}