for AuInitContext
{
}
}
-pub(super) struct AuProcessContext ,
}
-impl for AuProcessContext {
+impl for AuProcessContext<'_, P> {
fn plugin_api(&self) -> PluginApi {
PluginApi::Au
}
@@ -72,10 +75,16 @@ impl for AuProcessContext {
}
fn next_event(&mut self) -> Option ) {}
+ fn send_event(&mut self, event: PluginNoteEvent ) {
+ if self.output_events.len() < self.output_events.capacity() {
+ self.output_events.push_back(event);
+ } else {
+ nih_debug_assert_failure!("The AU MIDI output queue is full, dropping event");
+ }
+ }
fn set_latency_samples(&self, samples: u32) {
self.sink.latency_samples.store(samples, Ordering::Relaxed);
@@ -136,8 +145,11 @@ impl {
.find(|(p, _)| *p == param)
.map(|(_, id)| id)
{
- let instance = self.inner.instance_bits.load(std::sync::atomic::Ordering::Acquire)
- as usize as au::AudioUnit;
+ let instance = self
+ .inner
+ .instance_bits
+ .load(std::sync::atomic::Ordering::Acquire) as usize
+ as au::AudioUnit;
let au_param = AUParameter {
mAudioUnit: instance,
mParameterID: param_id,
@@ -145,7 +157,9 @@ impl {
mElement: 0,
};
// SAFETY: AUParameterListenerNotify is safe from any thread.
- unsafe { AUParameterListenerNotify(std::ptr::null_mut(), std::ptr::null_mut(), &au_param) };
+ unsafe {
+ AUParameterListenerNotify(std::ptr::null_mut(), std::ptr::null_mut(), &au_param)
+ };
}
}
@@ -159,9 +173,7 @@ impl {
unsafe {
crate::wrapper::state::serialize_object:: (
params_arc.clone(),
- param_map
- .iter()
- .map(|(id_str, ptr, _group)| (id_str, *ptr)),
+ param_map.iter().map(|(id_str, ptr, _group)| (id_str, *ptr)),
)
}
}
@@ -176,12 +188,7 @@ impl {
.map(|(_, ptr, _)| *ptr)
};
unsafe {
- crate::wrapper::state::deserialize_object:: (
- &mut state,
- params_arc,
- getter,
- None,
- );
+ crate::wrapper::state::deserialize_object:: (&mut state, params_arc, getter, None);
}
}
}
diff --git a/src/wrapper/au/midi.rs b/src/wrapper/au/midi.rs
new file mode 100644
index 000000000..eac25b608
--- /dev/null
+++ b/src/wrapper/au/midi.rs
@@ -0,0 +1,1019 @@
+//! AUv2 MIDI input/output plumbing.
+//!
+//! `au-sys` 0.1.1 does not expose the MusicDevice selectors or the legacy
+//! MIDI-output callback structs, so the small C ABI surface needed by the AU
+//! wrapper is mirrored here from the macOS SDK headers.
+
+use std::borrow::Borrow;
+use std::collections::VecDeque;
+use std::ffi::c_void;
+use std::mem;
+use std::sync::atomic::{AtomicPtr, AtomicU32, AtomicU64, AtomicUsize, Ordering};
+use std::sync::Mutex;
+
+use au_sys as au;
+use crossbeam::queue::ArrayQueue;
+
+use crate::midi::{MidiResult, NoteEvent};
+use crate::plugin::Plugin;
+use crate::prelude::{MidiConfig, PluginNoteEvent};
+
+pub(super) const MUSIC_DEVICE_MIDI_EVENT_SELECT: au::SInt16 = 0x0101;
+pub(super) const MUSIC_DEVICE_SYS_EX_SELECT: au::SInt16 = 0x0102;
+pub(super) const MUSIC_DEVICE_START_NOTE_SELECT: au::SInt16 = 0x0105;
+pub(super) const MUSIC_DEVICE_STOP_NOTE_SELECT: au::SInt16 = 0x0106;
+pub(super) const MUSIC_DEVICE_PROPERTY_SUPPORTS_START_STOP_NOTE: au::AudioUnitPropertyID = 1014;
+
+const MUSIC_DEVICE_SAMPLE_FRAME_MASK: u32 = 0x00ff_ffff;
+const MIDI_EVENT_QUEUE_CAPACITY: usize = 1024;
+const MIDI_RENDER_EVENT_CAPACITY: usize = MIDI_EVENT_QUEUE_CAPACITY * 2;
+const ACTIVE_NOTE_CAPACITY: usize = 1024;
+const STOPPING_NOTE_BIT: u64 = 1 << 63;
+const MIDI_PACKET_LIST_BYTES: usize = 65_536;
+const MIDI_PACKET_CHUNK_BYTES: usize = 60_000;
+
+pub(super) type MusicDeviceMidiEventProc = unsafe extern "C" fn(
+ *mut c_void,
+ au::UInt32,
+ au::UInt32,
+ au::UInt32,
+ au::UInt32,
+) -> au::OSStatus;
+pub(super) type MusicDeviceSysExProc =
+ unsafe extern "C" fn(*mut c_void, *const u8, au::UInt32) -> au::OSStatus;
+pub(super) type MusicDeviceStartNoteProc = unsafe extern "C" fn(
+ *mut c_void,
+ au::UInt32,
+ au::UInt32,
+ *mut au::UInt32,
+ au::UInt32,
+ *const MusicDeviceNoteParams,
+) -> au::OSStatus;
+pub(super) type MusicDeviceStopNoteProc =
+ unsafe extern "C" fn(*mut c_void, au::UInt32, au::UInt32, au::UInt32) -> au::OSStatus;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub(super) struct NoteParamsControlValue {
+ pub id: au::AudioUnitParameterID,
+ pub value: au::AudioUnitParameterValue,
+}
+
+/// Variable-length in C. The wrapper only consumes the required pitch and
+/// velocity prefix, so one trailing control is enough to mirror its ABI.
+#[repr(C)]
+pub(super) struct MusicDeviceNoteParams {
+ pub arg_count: au::UInt32,
+ pub pitch: au::Float32,
+ pub velocity: au::Float32,
+ pub controls: [NoteParamsControlValue; 1],
+}
+
+pub(super) type AuMidiOutputCallback = unsafe extern "C" fn(
+ *mut c_void,
+ *const au::AudioTimeStamp,
+ au::UInt32,
+ *const c_void,
+) -> au::OSStatus;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub(super) struct AuMidiOutputCallbackStruct {
+ pub callback: Option ,
+ second: Option {
+ pub fn new() -> Self {
+ Self {
+ queue: ArrayQueue::new(MIDI_EVENT_QUEUE_CAPACITY),
+ sequence: AtomicU64::new(0),
+ next_note_id: AtomicU32::new(1),
+ active_notes: (0..ACTIVE_NOTE_CAPACITY)
+ .map(|_| AtomicU64::new(0))
+ .collect(),
+ }
+ }
+
+ fn push(&self, first: PluginNoteEvent , second: Option (&event) => self.push(event, None),
+ // Hosts should not need to special-case a plugin's MIDI dialect.
+ // Unsupported messages are accepted and ignored, matching the
+ // CLAP/VST3 wrappers.
+ _ => au::noErr,
+ }
+ }
+
+ pub unsafe fn push_sysex(&self, data: *const u8, length: au::UInt32) -> au::OSStatus {
+ if P::MIDI_INPUT < MidiConfig::Basic {
+ return au::noErr;
+ }
+ if data.is_null() || length < 2 {
+ return au::kAudioUnitErr_InvalidParameter;
+ }
+
+ let bytes = unsafe { std::slice::from_raw_parts(data, length as usize) };
+ if bytes.first() != Some(&0xf0) || bytes.last() != Some(&0xf7) {
+ return au::kAudioUnitErr_InvalidParameter;
+ }
+
+ match NoteEvent::from_midi(0, bytes) {
+ Ok(event @ NoteEvent::MidiSysEx { .. }) => self.push(event, None),
+ _ => au::noErr,
+ }
+ }
+
+ pub unsafe fn start_note(
+ &self,
+ group: au::UInt32,
+ out_note_id: *mut au::UInt32,
+ offset: au::UInt32,
+ params: *const MusicDeviceNoteParams,
+ ) -> au::OSStatus {
+ if P::MIDI_INPUT < MidiConfig::Basic {
+ return au::kAudioUnitErr_CannotDoInCurrentContext;
+ }
+ if group >= 16 || out_note_id.is_null() || params.is_null() {
+ return au::kAudioUnitErr_InvalidParameter;
+ }
+
+ let params = unsafe { &*params };
+ if params.arg_count < 2
+ || !params.pitch.is_finite()
+ || !(0.0..128.0).contains(¶ms.pitch)
+ || !params.velocity.is_finite()
+ || !(0.0..=127.0).contains(¶ms.velocity)
+ {
+ return au::kAudioUnitErr_InvalidParameter;
+ }
+
+ let rounded_pitch = params.pitch.round().clamp(0.0, 127.0);
+ let note = rounded_pitch as u8;
+ let (note_id, slot, packed) = match self.reserve_active_note(group as u8, note) {
+ Some(active) => active,
+ None => return au::kAudioUnitErr_CannotDoInCurrentContext,
+ };
+ let timing = offset & MUSIC_DEVICE_SAMPLE_FRAME_MASK;
+ let voice_id = Some(note_id as i32);
+ let note_on = NoteEvent::NoteOn {
+ timing,
+ voice_id,
+ channel: group as u8,
+ note,
+ velocity: params.velocity / 127.0,
+ };
+ let tuning = params.pitch - rounded_pitch;
+ let tuning_event = (tuning.abs() > f32::EPSILON).then_some(NoteEvent::PolyTuning {
+ timing,
+ voice_id,
+ channel: group as u8,
+ note,
+ tuning,
+ });
+
+ let status = self.push(note_on, tuning_event);
+ if status != au::noErr {
+ let _ = self.active_notes[slot].compare_exchange(
+ packed,
+ 0,
+ Ordering::AcqRel,
+ Ordering::Acquire,
+ );
+ return status;
+ }
+
+ unsafe { *out_note_id = note_id };
+ au::noErr
+ }
+
+ pub fn stop_note(
+ &self,
+ group: au::UInt32,
+ note_id: au::UInt32,
+ offset: au::UInt32,
+ ) -> au::OSStatus {
+ if P::MIDI_INPUT < MidiConfig::Basic {
+ return au::kAudioUnitErr_CannotDoInCurrentContext;
+ }
+ if group >= 16 || note_id == 0 || note_id > i32::MAX as u32 {
+ return au::kAudioUnitErr_InvalidParameter;
+ }
+
+ for slot in self.active_notes.iter() {
+ let packed = slot.load(Ordering::Acquire);
+ if packed & STOPPING_NOTE_BIT != 0
+ || unpack_note_id(packed) != note_id
+ || unpack_channel(packed) != group as u8
+ {
+ continue;
+ }
+ let claimed = packed | STOPPING_NOTE_BIT;
+ if slot
+ .compare_exchange(packed, claimed, Ordering::AcqRel, Ordering::Acquire)
+ .is_err()
+ {
+ continue;
+ }
+
+ let status = self.push(
+ NoteEvent::NoteOff {
+ timing: offset & MUSIC_DEVICE_SAMPLE_FRAME_MASK,
+ voice_id: Some(note_id as i32),
+ channel: group as u8,
+ note: unpack_note(packed),
+ velocity: 0.0,
+ },
+ None,
+ );
+ if status == au::noErr {
+ slot.store(0, Ordering::Release);
+ } else {
+ let _ = slot.compare_exchange(claimed, packed, Ordering::AcqRel, Ordering::Acquire);
+ }
+ return status;
+ }
+
+ au::kAudioUnitErr_InvalidParameter
+ }
+
+ fn reserve_active_note(&self, channel: u8, note: u8) -> Option<(u32, usize, u64)> {
+ for _ in 0..ACTIVE_NOTE_CAPACITY {
+ let note_id = self
+ .next_note_id
+ .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| {
+ Some(if current >= i32::MAX as u32 {
+ 1
+ } else {
+ current + 1
+ })
+ })
+ .ok()?;
+ if self
+ .active_notes
+ .iter()
+ .any(|slot| unpack_note_id(slot.load(Ordering::Acquire)) == note_id)
+ {
+ continue;
+ }
+
+ let packed = pack_active_note(note_id, channel, note);
+ for (idx, slot) in self.active_notes.iter().enumerate() {
+ if slot
+ .compare_exchange(0, packed, Ordering::AcqRel, Ordering::Acquire)
+ .is_ok()
+ {
+ return Some((note_id, idx, packed));
+ }
+ }
+ return None;
+ }
+ None
+ }
+
+ pub fn drain_into(&self, state: &mut MidiRenderState , number_frames: u32) {
+ state.input_batches.clear();
+ state.input_events.clear();
+ state.output_events.clear();
+
+ // Do not consume events that arrive after this render started. They are
+ // intended for the next block and remain queued.
+ let queued_at_start = self.queue.len().min(MIDI_EVENT_QUEUE_CAPACITY);
+ for _ in 0..queued_at_start {
+ if let Some(batch) = self.queue.pop() {
+ state.input_batches.push(batch);
+ }
+ }
+ state
+ .input_batches
+ .sort_unstable_by_key(|batch| (batch.first.timing(), batch.sequence));
+
+ let last_frame = number_frames.saturating_sub(1);
+ for mut batch in state.input_batches.drain(..) {
+ batch.first.clamp_timing(last_frame);
+ state.input_events.push_back(batch.first);
+ if let Some(mut second) = batch.second {
+ second.clamp_timing(last_frame);
+ state.input_events.push_back(second);
+ }
+ }
+ }
+
+ pub fn clear(&self) {
+ while self.queue.pop().is_some() {}
+ for slot in self.active_notes.iter() {
+ slot.store(0, Ordering::Release);
+ }
+ }
+}
+
+fn input_event_allowed ) -> bool {
+ match event {
+ NoteEvent::NoteOn { .. }
+ | NoteEvent::NoteOff { .. }
+ | NoteEvent::PolyPressure { .. }
+ | NoteEvent::MidiSysEx { .. } => P::MIDI_INPUT >= MidiConfig::Basic,
+ NoteEvent::MidiChannelPressure { .. }
+ | NoteEvent::MidiPitchBend { .. }
+ | NoteEvent::MidiCC { .. }
+ | NoteEvent::MidiProgramChange { .. } => P::MIDI_INPUT >= MidiConfig::MidiCCs,
+ _ => false,
+ }
+}
+
+fn output_event_allowed ) -> bool {
+ match event {
+ NoteEvent::NoteOn { .. }
+ | NoteEvent::NoteOff { .. }
+ | NoteEvent::PolyPressure { .. }
+ | NoteEvent::MidiSysEx { .. } => P::MIDI_OUTPUT >= MidiConfig::Basic,
+ NoteEvent::MidiChannelPressure { .. }
+ | NoteEvent::MidiPitchBend { .. }
+ | NoteEvent::MidiCC { .. }
+ | NoteEvent::MidiProgramChange { .. } => P::MIDI_OUTPUT >= MidiConfig::MidiCCs,
+ _ => false,
+ }
+}
+
+fn pack_active_note(note_id: u32, channel: u8, note: u8) -> u64 {
+ ((note_id as u64) << 32) | ((channel as u64) << 8) | note as u64
+}
+
+fn unpack_note_id(packed: u64) -> u32 {
+ ((packed & !STOPPING_NOTE_BIT) >> 32) as u32
+}
+
+fn unpack_channel(packed: u64) -> u8 {
+ ((packed >> 8) & 0xff) as u8
+}
+
+fn unpack_note(packed: u64) -> u8 {
+ (packed & 0xff) as u8
+}
+
+pub(super) struct MidiRenderState {
+ pub fn new() -> Self {
+ Self {
+ input_batches: Vec::with_capacity(MIDI_EVENT_QUEUE_CAPACITY),
+ input_events: VecDeque::with_capacity(MIDI_RENDER_EVENT_CAPACITY),
+ output_events: VecDeque::with_capacity(MIDI_EVENT_QUEUE_CAPACITY),
+ packet_storage: vec![0; MIDI_PACKET_LIST_BYTES / mem::size_of:: (&event) {
+ nih_debug_assert_failure!(
+ "Invalid AU output event for the current MIDI_OUTPUT setting"
+ );
+ continue;
+ }
+ event.clamp_timing(number_frames.saturating_sub(1));
+ let timing = event.timing() as u64;
+ match event.as_midi() {
+ Some(MidiResult::Basic(bytes)) => {
+ let length = match bytes[0] & 0xf0 {
+ 0xc0 | 0xd0 => 2,
+ _ => 3,
+ };
+ if let Err(status) = unsafe { builder.push_message(timing, &bytes[..length]) } {
+ return status;
+ }
+ }
+ Some(MidiResult::SysEx(buffer, length)) => {
+ let bytes = buffer.borrow();
+ if let Err(status) = unsafe { builder.push_message(timing, &bytes[..length]) } {
+ return status;
+ }
+ }
+ None => {
+ nih_debug_assert_failure!("AU cannot encode this note expression as MIDI 1.0");
+ }
+ }
+ }
+
+ match unsafe { builder.flush() } {
+ Ok(()) => au::noErr,
+ Err(status) => status,
+ }
+ }
+}
+
+struct MidiPacketListBuilder<'a> {
+ callback: AuMidiOutputCallbackStruct,
+ time_stamp: *const au::AudioTimeStamp,
+ storage: &'a mut [u64],
+ current_packet: *mut c_void,
+ has_packets: bool,
+}
+
+impl<'a> MidiPacketListBuilder<'a> {
+ unsafe fn new(
+ callback: AuMidiOutputCallbackStruct,
+ time_stamp: *const au::AudioTimeStamp,
+ storage: &'a mut [u64],
+ ) -> Self {
+ let current_packet = unsafe { midi_packet_list_init(storage.as_mut_ptr() as *mut c_void) };
+ Self {
+ callback,
+ time_stamp,
+ storage,
+ current_packet,
+ has_packets: false,
+ }
+ }
+
+ unsafe fn reset(&mut self) {
+ self.current_packet =
+ unsafe { midi_packet_list_init(self.storage.as_mut_ptr() as *mut c_void) };
+ self.has_packets = false;
+ }
+
+ unsafe fn push_message(&mut self, timing: u64, data: &[u8]) -> Result<(), au::OSStatus> {
+ let mut offset = 0;
+ while offset < data.len() {
+ let end = (offset + MIDI_PACKET_CHUNK_BYTES).min(data.len());
+ let chunk = &data[offset..end];
+ let mut added = unsafe {
+ midi_packet_list_add(
+ self.storage.as_mut_ptr() as *mut c_void,
+ MIDI_PACKET_LIST_BYTES,
+ self.current_packet,
+ timing,
+ chunk.len(),
+ chunk.as_ptr(),
+ )
+ };
+ if added.is_null() && self.has_packets {
+ unsafe { self.flush()? };
+ added = unsafe {
+ midi_packet_list_add(
+ self.storage.as_mut_ptr() as *mut c_void,
+ MIDI_PACKET_LIST_BYTES,
+ self.current_packet,
+ timing,
+ chunk.len(),
+ chunk.as_ptr(),
+ )
+ };
+ }
+ if added.is_null() {
+ return Err(au::kAudioUnitErr_CannotDoInCurrentContext);
+ }
+ self.current_packet = added;
+ self.has_packets = true;
+ offset = end;
+ if offset < data.len() {
+ unsafe { self.flush()? };
+ }
+ }
+ Ok(())
+ }
+
+ unsafe fn flush(&mut self) -> Result<(), au::OSStatus> {
+ if !self.has_packets {
+ return Ok(());
+ }
+ let callback = self
+ .callback
+ .callback
+ .expect("callback checked by constructor caller");
+ let status = unsafe {
+ callback(
+ self.callback.user_data,
+ self.time_stamp,
+ 0,
+ self.storage.as_ptr() as *const c_void,
+ )
+ };
+ if status != au::noErr {
+ return Err(status);
+ }
+ unsafe { self.reset() };
+ Ok(())
+ }
+}
+
+#[link(name = "CoreMIDI", kind = "framework")]
+extern "C" {
+ #[link_name = "MIDIPacketListInit"]
+ fn midi_packet_list_init(packet_list: *mut c_void) -> *mut c_void;
+ #[link_name = "MIDIPacketListAdd"]
+ fn midi_packet_list_add(
+ packet_list: *mut c_void,
+ list_size: usize,
+ current_packet: *mut c_void,
+ time: u64,
+ data_length: usize,
+ data: *const u8,
+ ) -> *mut c_void;
+}
+
+#[cfg(test)]
+mod tests {
+ use std::sync::Arc;
+
+ use super::*;
+ use crate::prelude::*;
+
+ #[derive(Debug, Clone, Copy, PartialEq)]
+ struct TestSysEx([u8; 4]);
+
+ impl SysExMessage for TestSysEx {
+ type Buffer = [u8; 4];
+
+ fn from_buffer(buffer: &[u8]) -> Option ,
+
+ /// Host callback installed through `kAudioUnitProperty_MIDIOutputCallback`.
+ /// Loads from render are lock-free; the control-thread writer waits for the
+ /// brief pointer-copy section before reclaiming a retired record.
+ midi_output_callback: midi::MidiOutputCallbackSlot,
+
/// Per-aux-input-port render callbacks (elements 1, 2, … of Input scope).
/// Length equals `P::AUDIO_IO_LAYOUTS` max `aux_input_ports.len()`.
/// Each `Mutex` is independent so the audio thread can snapshot without
@@ -243,7 +268,7 @@ pub struct Wrapper ,
}
-impl RenderState {
+impl {
fn new() -> Self {
Self {
input_scratch: Vec::new(),
@@ -306,6 +334,7 @@ impl RenderState {
aux_input_scratch: Vec::new(),
aux_bl_storages: Vec::new(),
aux_buffers: Vec::new(),
+ midi: midi::MidiRenderState::new(),
}
}
@@ -348,7 +377,8 @@ impl RenderState {
for &port_ch in aux_ports {
let n_ch = port_ch.get() as usize;
// Per-channel scratch frames.
- self.aux_input_scratch.push(vec![vec![0.0_f32; max_frames]; n_ch]);
+ self.aux_input_scratch
+ .push(vec![vec![0.0_f32; max_frames]; n_ch]);
// BufferList backing storage.
let words = bl_byte_size(n_ch).div_ceil(mem::size_of:: {
execute_background: Arc::new(|_| {}),
execute_gui: Arc::new(|_| {}),
};
- let editor = plugin.editor(async_executor).map(|e| Arc::new(Mutex::new(e)));
+ let editor = plugin
+ .editor(async_executor)
+ .map(|e| Arc::new(Mutex::new(e)));
// `gui_context_inner` is created here with instance = null; the
// real AudioUnit handle is filled in by `open()`. Because
@@ -492,6 +526,8 @@ impl {
max_frames_per_slice: AtomicU32::new(1024),
n_channels: AtomicU32::new(2),
latency_seconds_bits: AtomicU64::new(pack_f64(0.0)),
+ tail_seconds_bits: AtomicU64::new(pack_f64(0.0)),
+ last_render_error: AtomicI32::new(au::noErr),
initialized: AtomicBool::new(false),
bypass: AtomicBool::new(false),
bypass_param_idx,
@@ -502,6 +538,8 @@ impl {
sink: ContextSink::new(),
input_callback: Mutex::new(None),
input_connection: Mutex::new(None),
+ midi_input: midi::MidiInputState::new(),
+ midi_output_callback: midi::MidiOutputCallbackSlot::new(),
aux_input_callbacks: {
let n_aux = P::AUDIO_IO_LAYOUTS
.iter()
@@ -550,6 +588,26 @@ impl {
.store(pack_f64(l), Ordering::Release);
}
#[inline]
+ fn tail_seconds(&self) -> f64 {
+ unpack_f64(self.tail_seconds_bits.load(Ordering::Acquire))
+ }
+ #[inline]
+ fn set_tail_seconds(&self, seconds: f64) {
+ let previous = self
+ .tail_seconds_bits
+ .swap(pack_f64(seconds), Ordering::AcqRel);
+ if previous != pack_f64(seconds) {
+ self.mark_pending(NOTIFY_TAIL_TIME);
+ }
+ }
+ #[inline]
+ fn set_last_render_error(&self, status: au::OSStatus) {
+ let previous = self.last_render_error.swap(status, Ordering::AcqRel);
+ if status != au::noErr && previous != status {
+ self.mark_pending(NOTIFY_LAST_RENDER_ERROR);
+ }
+ }
+ #[inline]
fn n_channels(&self) -> u32 {
self.n_channels.load(Ordering::Acquire)
}
@@ -602,11 +660,20 @@ impl {
fire(au::kAudioUnitProperty_Latency, au::kAudioUnitScope_Global);
}
if pending & NOTIFY_STREAM_FORMAT != 0 {
- fire(au::kAudioUnitProperty_StreamFormat, au::kAudioUnitScope_Output);
- fire(au::kAudioUnitProperty_StreamFormat, au::kAudioUnitScope_Input);
+ fire(
+ au::kAudioUnitProperty_StreamFormat,
+ au::kAudioUnitScope_Output,
+ );
+ fire(
+ au::kAudioUnitProperty_StreamFormat,
+ au::kAudioUnitScope_Input,
+ );
}
if pending & NOTIFY_BYPASS_EFFECT != 0 {
- fire(au::kAudioUnitProperty_BypassEffect, au::kAudioUnitScope_Global);
+ fire(
+ au::kAudioUnitProperty_BypassEffect,
+ au::kAudioUnitScope_Global,
+ );
}
if pending & NOTIFY_MAX_FRAMES_PER_SLICE != 0 {
fire(
@@ -614,6 +681,15 @@ impl {
au::kAudioUnitScope_Global,
);
}
+ if pending & NOTIFY_TAIL_TIME != 0 {
+ fire(au::kAudioUnitProperty_TailTime, au::kAudioUnitScope_Global);
+ }
+ if pending & NOTIFY_LAST_RENDER_ERROR != 0 {
+ fire(
+ au::kAudioUnitProperty_LastRenderError,
+ au::kAudioUnitScope_Global,
+ );
+ }
}
/// SAFETY: caller must guarantee no other reference (mut or shared) to
@@ -631,7 +707,7 @@ impl {
/// `RenderState` for in-place mutation by the audio thread.
#[inline]
#[allow(clippy::mut_from_ref)]
- unsafe fn render_state_mut(&self) -> &mut RenderState {
+ unsafe fn render_state_mut(&self) -> &mut RenderState {
unsafe { &mut *self.render_state.get() }
}
@@ -653,6 +729,12 @@ impl {
unsafe extern "C" fn close(self_ptr: *mut c_void) -> au::OSStatus {
// Drop editor handle before the wrapper is destroyed.
let this = unsafe { Self::from_ptr(self_ptr) };
+ if this.initialized.swap(false, Ordering::AcqRel) {
+ // Hosts are allowed to dispose an initialized AudioUnit without a
+ // preceding Uninitialize call. Keep Plugin's lifecycle balanced.
+ unsafe { this.plugin_mut() }.deactivate();
+ }
+ this.midi_input.clear();
let instance = this.instance.swap(0, Ordering::AcqRel) as usize as *mut c_void;
cocoaui::close_audio_unit_view(instance);
this.editor_handle.clear();
@@ -671,9 +753,7 @@ impl {
std::mem::transmute:: {
Self::remove_property_listener_with_user_data,
)
},
+ midi::MUSIC_DEVICE_MIDI_EVENT_SELECT if P::MIDI_INPUT >= MidiConfig::Basic => unsafe {
+ std::mem::transmute:: {
let this = unsafe { Self::from_ptr(self_ptr) };
let n_ch = this.n_channels().max(1);
- let chans = NonZeroU32::new(n_ch);
- // Pick the best-matching layout for the current channel count. Prefer a
- // layout whose main_input_channels matches; fall back to const_default.
- let selected_layout = P::AUDIO_IO_LAYOUTS
- .iter()
- .find(|l| l.main_input_channels == chans && l.main_output_channels == chans)
- .copied()
- .unwrap_or(AudioIOLayout {
- main_input_channels: chans,
- main_output_channels: chans,
- ..AudioIOLayout::const_default()
- });
+ let chans = NonZeroU32::new(n_ch).expect("n_ch is clamped to at least one");
+ let selected_layout = match layout_for_output:: (chans) {
+ Some(layout) => *layout,
+ None => return au::kAudioUnitErr_FormatNotSupported,
+ };
let max_frames = this.max_frames_per_slice();
let sr = this.sample_rate();
let buffer_config = BufferConfig {
@@ -758,7 +849,15 @@ impl {
// Provision the audio-thread render state so the hot path is
// allocation-free. SAFETY: render is serialised vs. Initialize.
let render_state = unsafe { this.render_state_mut() };
- render_state.provision(n_ch as usize, max_frames as usize, selected_layout.aux_input_ports);
+ render_state.provision(
+ n_ch as usize,
+ max_frames as usize,
+ selected_layout.aux_input_ports,
+ );
+ render_state.midi.clear();
+ this.midi_input.clear();
+ this.set_tail_seconds(0.0);
+ this.set_last_render_error(au::noErr);
let latency = this.sink.latency_samples.load(Ordering::Relaxed);
if latency > 0 && sr > 0.0 {
@@ -785,6 +884,8 @@ impl {
// SAFETY: AU forbids Uninitialize concurrent with Render.
unsafe { this.plugin_mut() }.deactivate();
}
+ this.midi_input.clear();
+ unsafe { this.render_state_mut() }.midi.clear();
au::noErr
}
@@ -796,9 +897,61 @@ impl {
let this = unsafe { Self::from_ptr(self_ptr) };
// SAFETY: AU calls Reset on the main thread, serialised against render.
unsafe { this.plugin_mut() }.reset();
+ this.midi_input.clear();
+ unsafe { this.render_state_mut() }.midi.clear();
+ this.set_tail_seconds(0.0);
au::noErr
}
+ unsafe extern "C" fn music_device_midi_event(
+ self_ptr: *mut c_void,
+ status: au::UInt32,
+ data_1: au::UInt32,
+ data_2: au::UInt32,
+ offset: au::UInt32,
+ ) -> au::OSStatus {
+ unsafe { Self::from_ptr(self_ptr) }
+ .midi_input
+ .push_midi_event(status, data_1, data_2, offset)
+ }
+
+ unsafe extern "C" fn music_device_sys_ex(
+ self_ptr: *mut c_void,
+ data: *const u8,
+ length: au::UInt32,
+ ) -> au::OSStatus {
+ unsafe { Self::from_ptr(self_ptr) }
+ .midi_input
+ .push_sysex(data, length)
+ }
+
+ unsafe extern "C" fn music_device_start_note(
+ self_ptr: *mut c_void,
+ _instrument: au::UInt32,
+ group: au::UInt32,
+ out_note_id: *mut au::UInt32,
+ offset: au::UInt32,
+ params: *const midi::MusicDeviceNoteParams,
+ ) -> au::OSStatus {
+ unsafe { Self::from_ptr(self_ptr) }.midi_input.start_note(
+ group,
+ out_note_id,
+ offset,
+ params,
+ )
+ }
+
+ unsafe extern "C" fn music_device_stop_note(
+ self_ptr: *mut c_void,
+ group: au::UInt32,
+ note_id: au::UInt32,
+ offset: au::UInt32,
+ ) -> au::OSStatus {
+ unsafe { Self::from_ptr(self_ptr) }
+ .midi_input
+ .stop_note(group, note_id, offset)
+ }
+
fn get_class_info(&self) -> *mut c_void {
let state = unsafe {
state::serialize_object:: (
@@ -898,7 +1051,7 @@ impl {
self_ptr: *mut c_void,
id: au::AudioUnitPropertyID,
scope: au::AudioUnitScope,
- _element: au::AudioUnitElement,
+ element: au::AudioUnitElement,
out_data_size: *mut au::UInt32,
out_writable: *mut au::Boolean,
) -> au::OSStatus {
@@ -918,15 +1071,18 @@ impl {
match id {
au::kAudioUnitProperty_SampleRate
- if scope == au::kAudioUnitScope_Input
- || scope == au::kAudioUnitScope_Output =>
+ if scope == au::kAudioUnitScope_Input || scope == au::kAudioUnitScope_Output =>
{
respond(std::mem::size_of:: (this.n_channels(), scope, element).is_some() =>
+ {
+ respond(
+ std::mem::size_of:: {
au::kAudioUnitProperty_TailTime if scope == au::kAudioUnitScope_Global => {
respond(std::mem::size_of:: {
false,
)
}
- au::kAudioUnitProperty_ParameterInfo if scope == au::kAudioUnitScope_Global => {
+ au::kAudioUnitProperty_ParameterInfo if scope == au::kAudioUnitScope_Global => respond(
+ std::mem::size_of:: (this.n_channels())
+ .is_some_and(|layout| layout.main_input_channels.is_some()) =>
{
- respond(std::mem::size_of:: {
au::kAudioUnitProperty_LastRenderError if scope == au::kAudioUnitScope_Global => {
respond(std::mem::size_of:: (this.n_channels(), scope, element).is_some() =>
+ {
respond(
std::mem::size_of:: {
au::kAudioUnitProperty_HostCallbacks if scope == au::kAudioUnitScope_Global => {
respond(std::mem::size_of:: {
return au::kAudioUnitErr_InvalidParameter;
}
- match id {
- au::kAudioUnitProperty_SampleRate => {
- if (unsafe { *io_data_size } as usize) < std::mem::size_of:: {
au::noErr
}
au::kAudioUnitProperty_ElementCount => {
- // Input scope: element 0 = main, elements 1+ = aux inputs.
+ require_output!(au::UInt32);
+ // Input scope: optional main input followed by aux inputs.
// Output scope: always 1 (aux outputs not yet implemented).
let n_ch = this.n_channels().max(1);
let chans = NonZeroU32::new(n_ch);
- let n_aux_inputs = P::AUDIO_IO_LAYOUTS
- .iter()
- .find(|l| l.main_input_channels == chans && l.main_output_channels == chans)
- .map(|l| l.aux_input_ports.len())
- .unwrap_or(0);
+ let layout = chans.and_then(layout_for_output:: );
let count: au::UInt32 = match scope {
- au::kAudioUnitScope_Input => 1 + n_aux_inputs as u32,
+ au::kAudioUnitScope_Input => layout
+ .map(|layout| {
+ u32::from(layout.main_input_channels.is_some())
+ + layout.aux_input_ports.len() as u32
+ })
+ .unwrap_or(0),
au::kAudioUnitScope_Output => 1,
au::kAudioUnitScope_Global => 1,
_ => 0,
@@ -1053,6 +1240,7 @@ impl {
au::noErr
}
au::kAudioUnitProperty_Latency if scope == au::kAudioUnitScope_Global => {
+ require_output!(au::Float64);
unsafe {
*(out_data as *mut au::Float64) = this.latency_seconds();
*io_data_size = std::mem::size_of:: {
au::noErr
}
au::kAudioUnitProperty_TailTime if scope == au::kAudioUnitScope_Global => {
+ require_output!(au::Float64);
unsafe {
- *(out_data as *mut au::Float64) = 0.0;
+ *(out_data as *mut au::Float64) = this.tail_seconds();
*io_data_size = std::mem::size_of:: {
au::noErr
}
au::kAudioUnitProperty_StreamFormat => {
- if (unsafe { *io_data_size } as usize)
- < std::mem::size_of:: (this.n_channels(), scope, element) {
+ Some(channels) => channels,
+ None => return au::kAudioUnitErr_InvalidElement,
+ };
let asbd = au::AudioStreamBasicDescription {
mSampleRate: this.sample_rate(),
mFormatID: au::kAudioFormatLinearPCM,
@@ -1088,14 +1278,13 @@ impl {
mBytesPerPacket: 4,
mFramesPerPacket: 1,
mBytesPerFrame: 4,
- mChannelsPerFrame: this.n_channels(),
+ mChannelsPerFrame: channels,
mBitsPerChannel: 32,
mReserved: 0,
};
unsafe {
*(out_data as *mut au::AudioStreamBasicDescription) = asbd;
- *io_data_size =
- std::mem::size_of:: {
}
au::noErr
}
- au::kAudioUnitProperty_SupportedNumChannels
- if scope == au::kAudioUnitScope_Global =>
- {
- if (unsafe { *io_data_size } as usize) < std::mem::size_of:: {
au::noErr
}
au::kAudioUnitProperty_LastRenderError if scope == au::kAudioUnitScope_Global => {
+ require_output!(au::OSStatus);
unsafe {
- *(out_data as *mut au::OSStatus) = au::noErr;
+ *(out_data as *mut au::OSStatus) =
+ this.last_render_error.load(Ordering::Acquire);
*io_data_size = std::mem::size_of:: {
au::noErr
}
au::kAudioUnitProperty_ClassInfo if scope == au::kAudioUnitScope_Global => {
- if (unsafe { *io_data_size } as usize) < std::mem::size_of::<*mut c_void>() {
- return au::kAudioUnitErr_InvalidPropertyValue;
- }
+ require_output!(*mut c_void);
let dict = this.get_class_info();
unsafe {
*(out_data as *mut *mut c_void) = dict;
@@ -1206,7 +1389,8 @@ impl {
if this.editor.is_none() {
return au::kAudioUnitErr_InvalidProperty;
}
- if (unsafe { *io_data_size } as usize) < std::mem::size_of:: {
}
au::noErr
}
+ au::kAudioUnitProperty_MIDIOutputCallbackInfo
+ if scope == au::kAudioUnitScope_Global && P::MIDI_OUTPUT >= MidiConfig::Basic =>
+ {
+ require_output!(*mut c_void);
+ let names: CFArray {
if asbd.mChannelsPerFrame == 0 {
return au::kAudioUnitErr_InvalidPropertyValue;
}
+ if !(asbd.mSampleRate > 0.0 && asbd.mSampleRate.is_finite()) {
+ return au::kAudioUnitErr_InvalidPropertyValue;
+ }
// Reject non-PCM / non-float / interleaved — we only ever
// advertise non-interleaved 32-bit float in get_property.
if asbd.mFormatID != au::kAudioFormatLinearPCM
@@ -1317,16 +1528,33 @@ impl {
if asbd.mBitsPerChannel != 32 {
return au::kAudioUnitErr_FormatNotSupported;
}
- // Match the requested channel count against P::AUDIO_IO_LAYOUTS.
- // For an effect (in_ch == out_ch) we look for a layout where
- // both main_input and main_output match.
let req_ch = asbd.mChannelsPerFrame;
- if !layout_supports:: (req_ch) {
- return au::kAudioUnitErr_FormatNotSupported;
+ match scope {
+ au::kAudioUnitScope_Output if element == 0 => {
+ let req = NonZeroU32::new(req_ch).expect("channel count checked above");
+ if layout_for_output:: (req).is_none() {
+ return au::kAudioUnitErr_FormatNotSupported;
+ }
+ this.n_channels.store(req_ch, Ordering::Release);
+ }
+ au::kAudioUnitScope_Input => {
+ let expected = match bus_channel_count:: (
+ this.n_channels(),
+ au::kAudioUnitScope_Input,
+ element,
+ ) {
+ Some(expected) => expected,
+ None => return au::kAudioUnitErr_InvalidElement,
+ };
+ if expected != req_ch {
+ return au::kAudioUnitErr_FormatNotSupported;
+ }
+ }
+ au::kAudioUnitScope_Output => return au::kAudioUnitErr_InvalidElement,
+ _ => return au::kAudioUnitErr_InvalidScope,
}
this.set_sample_rate(asbd.mSampleRate);
- this.n_channels.store(req_ch, Ordering::Release);
this.mark_pending(NOTIFY_STREAM_FORMAT);
au::noErr
}
@@ -1375,6 +1603,12 @@ impl {
if element != 0 {
return au::kAudioUnitErr_InvalidElement;
}
+ let has_main_input = current_layout:: (this.n_channels())
+ .map(|layout| layout.main_input_channels.is_some())
+ .unwrap_or(false);
+ if !has_main_input {
+ return au::kAudioUnitErr_InvalidElement;
+ }
let conn = unsafe { *(in_data as *const AudioUnitConnection) };
// `conn.dest_input_number` is deliberately not consulted: AU's
// convention is that the property's element *is* the
@@ -1400,11 +1634,20 @@ impl {
}
au::noErr
}
- au::kAudioUnitProperty_SetRenderCallback => {
+ au::kAudioUnitProperty_SetRenderCallback if scope == au::kAudioUnitScope_Input => {
payload!(au::AURenderCallbackStruct);
let cb = unsafe { *(in_data as *const au::AURenderCallbackStruct) };
- let new_cb = if cb.inputProc.is_some() { Some(cb) } else { None };
- if element == 0 {
+ let new_cb = if cb.inputProc.is_some() {
+ Some(cb)
+ } else {
+ None
+ };
+ let layout = match current_layout:: (this.n_channels()) {
+ Some(layout) => layout,
+ None => return au::kAudioUnitErr_FormatNotSupported,
+ };
+ let aux_base = u32::from(layout.main_input_channels.is_some());
+ if aux_base == 1 && element == 0 {
if let Ok(mut guard) = this.input_callback.lock() {
*guard = new_cb;
}
@@ -1414,12 +1657,19 @@ impl {
*guard = None;
}
} else {
- // elements 1+ are aux inputs
- let aux_idx = (element - 1) as usize;
+ if element < aux_base {
+ return au::kAudioUnitErr_InvalidElement;
+ }
+ let aux_idx = (element - aux_base) as usize;
+ if aux_idx >= layout.aux_input_ports.len() {
+ return au::kAudioUnitErr_InvalidElement;
+ }
if let Some(slot) = this.aux_input_callbacks.get(aux_idx) {
if let Ok(mut guard) = slot.lock() {
*guard = new_cb;
}
+ } else {
+ return au::kAudioUnitErr_InvalidElement;
}
}
au::noErr
@@ -1438,6 +1688,22 @@ impl {
}
au::noErr
}
+ au::kAudioUnitProperty_MIDIOutputCallback
+ if scope == au::kAudioUnitScope_Global && P::MIDI_OUTPUT >= MidiConfig::Basic =>
+ {
+ payload!(midi::AuMidiOutputCallbackStruct);
+ let callback =
+ unsafe { ptr::read(in_data as *const midi::AuMidiOutputCallbackStruct) };
+ if this
+ .midi_output_callback
+ .store(callback.callback.map(|_| callback))
+ .is_ok()
+ {
+ au::noErr
+ } else {
+ au::kAudioUnitErr_CannotDoInCurrentContext
+ }
+ }
_ => au::kAudioUnitErr_InvalidProperty,
}
}
@@ -1563,6 +1829,7 @@ impl {
let this = unsafe { Self::from_ptr(self_ptr) };
if io_data.is_null() {
+ this.set_last_render_error(au::kAudioUnitErr_InvalidParameter);
return au::kAudioUnitErr_InvalidParameter;
}
@@ -1572,6 +1839,22 @@ impl {
}
let n_frames = in_number_frames as usize;
+ if in_number_frames > this.max_frames_per_slice() {
+ unsafe { zero_buffer_list(io_data, in_number_frames) };
+ this.set_last_render_error(au::kAudioUnitErr_TooManyFramesToProcess);
+ return au::kAudioUnitErr_TooManyFramesToProcess;
+ }
+
+ let layout = match current_layout:: (this.n_channels()) {
+ Some(layout) => layout,
+ None => {
+ unsafe { zero_buffer_list(io_data, in_number_frames) };
+ this.set_last_render_error(au::kAudioUnitErr_FormatNotSupported);
+ return au::kAudioUnitErr_FormatNotSupported;
+ }
+ };
+ let has_main_input = layout.main_input_channels.is_some();
+ let aux_element_base = u32::from(has_main_input);
// Snapshot the input callback under the mutex (cheap struct copy).
// Released immediately so main-thread updates don't block render
@@ -1579,19 +1862,22 @@ impl {
// The two wirings are kept mutually exclusive when the host sets them,
// so at most one of these is ever populated; the callback is preferred
// if both somehow are.
- let input_source = this
- .input_callback
- .lock()
- .ok()
- .and_then(|g| *g)
- .map(InputSource::Callback)
- .or_else(|| {
- this.input_connection
+ let input_source = has_main_input
+ .then(|| {
+ this.input_callback
.lock()
.ok()
.and_then(|g| *g)
- .map(InputSource::Connection)
- });
+ .map(InputSource::Callback)
+ .or_else(|| {
+ this.input_connection
+ .lock()
+ .ok()
+ .and_then(|g| *g)
+ .map(InputSource::Connection)
+ })
+ })
+ .flatten();
// SAFETY: render is not re-entered; we are the sole owner of
// RenderState for the duration of this call.
@@ -1615,8 +1901,7 @@ impl {
// The N-tuple of AudioBuffer entries lives at the natural
// C `mBuffers` offset, which the compiler computes
// accounting for any padding after `mNumberBuffers`.
- let header_offset =
- mem::offset_of!(au::AudioBufferList, mBuffers);
+ let header_offset = mem::offset_of!(au::AudioBufferList, mBuffers);
let buffers_ptr = unsafe {
(rs.bl_storage.as_mut_ptr() as *mut u8).add(header_offset)
as *mut au::AudioBuffer
@@ -1626,8 +1911,7 @@ impl {
unsafe {
*buffers_ptr.add(ch) = au::AudioBuffer {
mNumberChannels: 1,
- mDataByteSize: (n_frames * mem::size_of:: {
)
},
};
- if status == au::noErr {
+ if status != au::noErr {
+ unsafe { zero_buffer_list(io_data, in_number_frames) };
+ this.set_last_render_error(status);
+ return status;
+ } else {
pulled_input = true;
// The callback is allowed to *replace* the mData pointers
// with its own buffers instead of filling the ones we
@@ -1689,8 +1977,8 @@ impl {
let src = b.mData as *const f32;
let dst = rs.input_scratch[ch].as_mut_ptr();
if !src.is_null() && src != dst as *const f32 {
- let frames = n_frames
- .min(b.mDataByteSize as usize / mem::size_of:: {
if buf.mData.is_null() || !buffer_fits_frames(buf, n_frames) {
continue;
}
- let dst = unsafe {
- std::slice::from_raw_parts_mut(buf.mData as *mut f32, n_frames)
- };
+ let dst =
+ unsafe { std::slice::from_raw_parts_mut(buf.mData as *mut f32, n_frames) };
let src = &rs.input_scratch[i][..n_frames];
dst.copy_from_slice(src);
}
@@ -1770,10 +2057,7 @@ impl {
slots[i] = &mut [];
continue;
}
- let raw = std::slice::from_raw_parts_mut(
- buf.mData as *mut f32,
- n_frames,
- );
+ let raw = std::slice::from_raw_parts_mut(buf.mData as *mut f32, n_frames);
// The slot type carries `'static` because `RenderState`
// is itself field-stored; the slice we put here lives
// only until we clear it below. This mirrors the
@@ -1794,7 +2078,8 @@ impl {
if let Some(beat_and_tempo) = cb.beatAndTempoProc {
let mut beat = 0.0;
let mut tempo = 0.0;
- if unsafe { beat_and_tempo(cb.hostUserData, &mut beat, &mut tempo) } == au::noErr
+ if unsafe { beat_and_tempo(cb.hostUserData, &mut beat, &mut tempo) }
+ == au::noErr
{
transport.pos_beats = Some(beat);
transport.tempo = Some(tempo);
@@ -1865,6 +2150,7 @@ impl