diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index 8e7c497..c788b8b 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -50,9 +50,6 @@ jobs: - name: Install system packages if: contains(matrix.os, 'ubuntu') run: | - sudo apt-get update - sudo apt-get install -y software-properties-common - sudo add-apt-repository -y ppa:rncbc/libs-noble sudo apt-get update sudo apt-get install -y \ pkg-config \ diff --git a/Cargo.lock b/Cargo.lock index 5c6c6ab..e659db8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -346,7 +346,7 @@ dependencies = [ [[package]] name = "maolan-engine" -version = "0.4.21" +version = "0.4.22" dependencies = [ "alsa", "arc-swap", diff --git a/Cargo.toml b/Cargo.toml index af3d801..a0090d3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "maolan-engine" -version = "0.4.21" +version = "0.4.22" edition = "2024" description = "Audio engine for the Maolan DAW with audio/MIDI tracks, routing, export, and out-of-process CLAP/VST3/LV2 plugin support" license = "BSD-2-Clause" diff --git a/src/audio/io.rs b/src/audio/io.rs index 43d82a9..5265b19 100644 --- a/src/audio/io.rs +++ b/src/audio/io.rs @@ -35,6 +35,13 @@ impl AudioIO { Arc::new(live) } + pub fn visit_connections(&self, mut visit: impl FnMut(&Arc)) { + let connections = self.connections.load(); + for connection in connections.iter().filter_map(Weak::upgrade) { + visit(&connection); + } + } + pub fn store_connections(&self, connections: Vec>) { let len = connections.len(); self.connections diff --git a/src/engine/inline.rs b/src/engine/inline.rs index c160b95..fc5d53a 100644 --- a/src/engine/inline.rs +++ b/src/engine/inline.rs @@ -139,7 +139,7 @@ impl Engine { /// thru-routing / MIDI-learn / step-record (already delivered to track /// ports by the cycle thread, so they are not buffered again). pub(crate) async fn drain_inline_outcome(&mut self) { - let Some(outcome) = self.inline_render.take_outcome() else { + let Some(mut outcome) = self.inline_render.take_outcome() else { return; }; if outcome.stale { @@ -160,19 +160,21 @@ impl Engine { self.advance_render_clock(outcome.skipped_frames as usize); self.inline_render.invalidate_anchor(); } - if let Some(plan) = outcome.plan { - for result in outcome.results { + if let Some(plan) = outcome.plan.take() { + for result in &mut outcome.results { if let Some(Op::Task { task, .. }) = plan.nodes.get(result.node as usize) { + let track = Self::task_track(task); let track_name = Self::task_track_name(task); + let output_linear = track.lock().output_meter_linear(); self.meters .track_meter_linear_by_track - .insert(track_name, result.output_linear); + .insert(track_name, output_linear); } if result.latency_changed { self.publish_state_snapshot(); self.plan_builder.mark_dirty(); } - for action in result.parameter_updates { + for action in result.parameter_updates.drain(..) { self.notify_clients(Ok(action)).await; } } @@ -181,9 +183,10 @@ impl Engine { self.apply_hw_out_meter_from_plan(&plan).await; } if !outcome.midi_in_events.is_empty() { - self.handle_hw_midi_in_events(outcome.midi_in_events, false) + self.handle_hw_midi_in_events(&mut outcome.midi_in_events, false) .await; } + self.inline_render.recycle_outcome(outcome); } /// Hardware MIDI-in event handling shared by the `HWMidiEvents` message @@ -192,10 +195,10 @@ impl Engine { /// forward (already delivered to ports; only thru/learn/step-record here). pub(crate) async fn handle_hw_midi_in_events( &mut self, - events: Vec, + events: &mut Vec, buffer_for_ports: bool, ) { - for hw_event in events { + for hw_event in events.drain(..) { let thru_targets: Vec = self .hw_midi .midi_hw_thru_routes diff --git a/src/engine/recording.rs b/src/engine/recording.rs index a59853b..1f23405 100644 --- a/src/engine/recording.rs +++ b/src/engine/recording.rs @@ -277,7 +277,7 @@ impl Engine { continue; } let abs_sample = start as u64 + (frame - from) as u64; - entry.events.push((abs_sample, event.data.clone())); + entry.events.push((abs_sample, event.data.to_vec())); } } diff --git a/src/engine/runtime.rs b/src/engine/runtime.rs index 2b01d61..cef5506 100644 --- a/src/engine/runtime.rs +++ b/src/engine/runtime.rs @@ -6,6 +6,7 @@ use crate::workers::sndio_worker::HwWorker; use crate::{ history::UndoEntry, message::{Action, Message, ProcessTask}, + state::TrackHandle, }; use std::{ sync::atomic::Ordering, @@ -182,16 +183,18 @@ impl Engine { } } - pub(crate) fn task_track_name(task: &ProcessTask) -> String { + pub(crate) fn task_track(task: &ProcessTask) -> &TrackHandle { match task { - ProcessTask::Track(t) | ProcessTask::FolderInput(t) | ProcessTask::FolderOutput(t) => { - t.lock().name.clone() - } + ProcessTask::Track(t) | ProcessTask::FolderInput(t) | ProcessTask::FolderOutput(t) => t, #[cfg(feature = "plugins")] - ProcessTask::Plugin { track, .. } => track.lock().name.clone(), + ProcessTask::Plugin { track, .. } => track, } } + pub(crate) fn task_track_name(task: &ProcessTask) -> String { + Self::task_track(task).lock().name.clone() + } + /// Pushes the current transport state into the task's track before the /// task is dispatched. /// @@ -357,7 +360,6 @@ impl Engine { worker_id: usize, epoch: u64, node: u32, - output_linear: Vec, parameter_updates: Vec, latency_changed: bool, ) { @@ -378,6 +380,7 @@ impl Engine { } let plan = self.executor.plan().clone(); if let Some(crate::render_plan::Op::Task { task, .. }) = plan.nodes.get(node as usize) { + let output_linear = Self::task_track(task).lock().output_meter_linear(); let track_name = Self::task_track_name(task); self.meters .track_meter_linear_by_track @@ -415,7 +418,6 @@ impl Engine { result.worker_id, result.epoch, result.node, - result.output_linear, result.parameter_updates, result.latency_changed, ) @@ -961,19 +963,11 @@ impl Engine { worker_id, epoch, node, - output_linear, parameter_updates, latency_changed, } => { - self.on_node_done( - worker_id, - epoch, - node, - output_linear, - parameter_updates, - latency_changed, - ) - .await; + self.on_node_done(worker_id, epoch, node, parameter_updates, latency_changed) + .await; } Message::Channel(s) => { self.clients.push(s); @@ -1007,7 +1001,7 @@ impl Engine { self.handle_hw_finished().await; self.drain_iodelay_report().await; } - Message::HWMidiEvents(events) => { + Message::HWMidiEvents(mut events) => { // Events from the hw worker's between-cycle drains; they // are buffered for the track-port push (which the pool // path runs in `handle_hw_finished` and the inline path @@ -1015,7 +1009,7 @@ impl Engine { // cycle thread arrive via `drain_inline_outcome` already // delivered to the ports and call this with // `buffer_for_ports = false`. - self.handle_hw_midi_in_events(events, true).await; + self.handle_hw_midi_in_events(&mut events, true).await; } Message::StartAudioPreview { samples, diff --git a/src/hw/coreaudio/midi.rs b/src/hw/coreaudio/midi.rs index f0c4699..d8ba7e8 100644 --- a/src/hw/coreaudio/midi.rs +++ b/src/hw/coreaudio/midi.rs @@ -744,7 +744,7 @@ unsafe fn collect_packets(context: &InputCallbackContext, packet_list: *const Mi if let Ok(mut events) = context.queue.lock() { events.push(HwMidiEvent { device: context.device.clone(), - event: MidiEvent::new(0, data.to_vec()), + event: MidiEvent::from_slice(0, data), }); } } diff --git a/src/hw/jack.rs b/src/hw/jack.rs index a81be10..33df743 100644 --- a/src/hw/jack.rs +++ b/src/hw/jack.rs @@ -68,6 +68,7 @@ struct Process { /// RT side of the MIDI-out ring: this callback is the sole consumer, the /// engine thread produces after each completed cycle. midi_out_consumer: rtrb::Consumer, + midi_out_scratch: Vec, /// In-events dropped because the engine did not drain fast enough. midi_in_dropped: Arc, output_gain_linear: Arc, @@ -188,7 +189,7 @@ impl Process { fn collect_midi_input(&mut self, ps: &ProcessScope) { for port in &self.midi_in_ports { for raw in port.iter(ps) { - let event = MidiEvent::new(raw.time, raw.bytes.to_vec()); + let event = MidiEvent::from_slice(raw.time, raw.bytes); if self.midi_in_producer.push(event).is_err() { self.midi_in_dropped.fetch_add(1, Ordering::Relaxed); } @@ -201,16 +202,16 @@ impl Process { while self.midi_out_consumer.pop().is_ok() {} return; } - let mut events = Vec::new(); + self.midi_out_scratch.clear(); while let Ok(event) = self.midi_out_consumer.pop() { - events.push(event); + self.midi_out_scratch.push(event); } - if events.is_empty() { + if self.midi_out_scratch.is_empty() { return; } for out_port in &mut self.midi_out_ports { let mut writer = out_port.writer(ps); - for event in &events { + for event in &self.midi_out_scratch { let raw = RawMidi { time: event.frame, bytes: &event.data, @@ -384,6 +385,7 @@ impl JackRuntime { plan_slot, midi_in_producer, midi_out_consumer, + midi_out_scratch: Vec::new(), midi_in_dropped: midi_in_dropped.clone(), output_gain_linear: output_gain_linear.clone(), output_balance: output_balance.clone(), diff --git a/src/hw/midi_hub.rs b/src/hw/midi_hub.rs index 796bc4c..0a1c375 100644 --- a/src/hw/midi_hub.rs +++ b/src/hw/midi_hub.rs @@ -1,5 +1,5 @@ use crate::message::HwMidiEvent; -use crate::midi::io::MidiEvent; +use crate::midi::io::{MidiData, MidiEvent}; use nix::libc; use std::{ fs::File, @@ -591,24 +591,24 @@ struct MidiParser { } impl MidiParser { - fn feed(&mut self, byte: u8) -> Option> { + fn feed(&mut self, byte: u8) -> Option { if byte & 0x80 != 0 { if self.in_sysex { if byte == 0xF7 { self.sysex.push(byte); self.in_sysex = false; - return Some(std::mem::take(&mut self.sysex)); + return Some(MidiData::Heap(std::mem::take(&mut self.sysex))); } if byte >= 0xF8 { - return Some(vec![byte]); + return Some(MidiData::from_slice(&[byte])); } self.in_sysex = false; self.sysex.clear(); } if byte >= 0xF8 { - return Some(vec![byte]); + return Some(MidiData::from_slice(&[byte])); } if byte == 0xF0 { self.in_sysex = true; @@ -623,7 +623,7 @@ impl MidiParser { self.len = 0; self.needed = status_data_len(byte); if self.needed == 0 { - return Some(vec![byte]); + return Some(MidiData::from_slice(&[byte])); } return None; } @@ -642,15 +642,15 @@ impl MidiParser { return None; } - let mut message = Vec::with_capacity(1 + self.needed); - message.push(status); - message.extend_from_slice(&self.data[..self.needed]); + let mut message = [0; 3]; + message[0] = status; + message[1..1 + self.needed].copy_from_slice(&self.data[..self.needed]); self.len = 0; if status >= 0xF0 { self.status = None; self.needed = 0; } - Some(message) + Some(MidiData::from_slice(&message[..1 + self.needed])) } } diff --git a/src/hw/oss/audio_core.rs b/src/hw/oss/audio_core.rs index c2967b4..b4ba558 100644 --- a/src/hw/oss/audio_core.rs +++ b/src/hw/oss/audio_core.rs @@ -635,6 +635,7 @@ mod tests { format: super::super::AFMT_U8, chsamples: 4, buffer: vec![0; 4], + raw_buffer: vec![], f32_buffer: vec![], buffer_info: BufferInfo { fragments: 2, diff --git a/src/hw/oss/mod.rs b/src/hw/oss/mod.rs index 0f506f0..d3c5b4e 100644 --- a/src/hw/oss/mod.rs +++ b/src/hw/oss/mod.rs @@ -63,6 +63,7 @@ pub struct Audio { pub format: u32, pub chsamples: usize, buffer: Vec, + raw_buffer: Vec, f32_buffer: Vec, pub buffer_info: BufferInfo, frame_size_bytes: usize, @@ -425,6 +426,7 @@ impl Audio { format, chsamples, buffer: vec![0_i32; chsamples * (channels as usize)], + raw_buffer: vec![0_u8; buffer_bytes], f32_buffer: Vec::new(), buffer_info, frame_size_bytes: frame_size, @@ -824,9 +826,11 @@ impl Audio { } pub fn process(&mut self, stop_requested: &AtomicBool) -> std::io::Result<()> { - if self.input { - let period_bytes = self.chsamples * self.frame_size(); - let mut raw = vec![0_u8; period_bytes]; + let period_bytes = self.chsamples * self.frame_size(); + let mut raw = std::mem::take(&mut self.raw_buffer); + raw.clear(); + raw.resize(period_bytes, 0); + let result = if self.input { self.read_full_period(&mut raw, stop_requested)?; convert_in_to_i32_connected( self.format, @@ -836,10 +840,9 @@ impl Audio { &self.channels, ); self.fill_input_ports(); + Ok(()) } else { self.fill_output_buffer(); - let period_bytes = self.chsamples * self.frame_size(); - let mut raw = vec![0_u8; period_bytes]; convert_out_from_i32_interleaved( self.format, self.channels.len(), @@ -847,10 +850,10 @@ impl Audio { self.buffer.as_mut_slice(), raw.as_mut_slice(), ); - self.write_full_period(&raw, stop_requested)?; - } - - Ok(()) + self.write_full_period(&raw, stop_requested) + }; + self.raw_buffer = raw; + result } /// Write the persistent zero buffer (sized to the mapped ring, filled @@ -868,11 +871,11 @@ impl Audio { if self.zero_block.len() != total { self.zero_block = vec![0_u8; total]; } - let block = std::mem::take(&mut self.zero_block); + let mut block = std::mem::take(&mut self.zero_block); let mut written = 0; while written < total { let len = (64 * 1024).min(total - written); - let chunk = &mut block[written..written + len].to_vec(); + let chunk = &mut block[written..written + len]; let n = self.write_map(Some(chunk), written, len); if n == 0 { break; diff --git a/src/hw/windows/wasapi.rs b/src/hw/windows/wasapi.rs index c22517b..b8895b8 100644 --- a/src/hw/windows/wasapi.rs +++ b/src/hw/windows/wasapi.rs @@ -158,6 +158,8 @@ pub struct HwDriver { output_stream: OutputStream, input_rx: Option>>, output_tx: SyncSender>, + output_recycle_rx: Receiver>, + output_period_pool: Vec>, cycle_tick_rx: Receiver<()>, input_queue: Vec, audio_ins: Vec>, @@ -192,6 +194,8 @@ impl HwDriver { let requested_period_frames = options.period_frames.max(1); let output_queue_periods = options.nperiods.max(4); let (output_tx, output_rx) = mpsc::sync_channel::>(output_queue_periods); + let (output_recycle_tx, output_recycle_rx) = + mpsc::sync_channel::>(output_queue_periods); let (cycle_tick_tx, cycle_tick_rx) = mpsc::sync_channel::<()>(output_queue_periods.saturating_mul(4)); let stop_requested = Arc::new(AtomicBool::new(false)); @@ -202,6 +206,7 @@ impl HwDriver { requested_period_frames, mode, output_rx, + output_recycle_tx, cycle_tick_tx, )?; @@ -247,6 +252,8 @@ impl HwDriver { output_stream, input_rx, output_tx, + output_recycle_rx, + output_period_pool: Vec::new(), cycle_tick_rx, input_queue: Vec::new(), audio_ins, @@ -327,6 +334,9 @@ impl HwDriver { } pub fn run_cycle(&mut self) -> Result<(), String> { + while let Ok(period) = self.output_recycle_rx.try_recv() { + self.output_period_pool.push(period); + } let input_frames = self.period_frames; let input_channels = self.input_channels.max(1); if let Some(rx) = &self.input_rx { @@ -362,7 +372,9 @@ impl HwDriver { let channels = self.output_channels; let gain = self.output_gain_linear; let balance = self.output_balance; - let mut interleaved = vec![0.0_f32; frames.saturating_mul(channels)]; + let mut interleaved = self.output_period_pool.pop().unwrap_or_default(); + interleaved.clear(); + interleaved.resize(frames.saturating_mul(channels), 0.0); if self.playing && let Some(slot) = &self.plan_slot { @@ -462,6 +474,7 @@ fn start_output_stream( period_frames: usize, mode: WasapiMode, output_rx: Receiver>, + output_recycle_tx: SyncSender>, cycle_tick_tx: SyncSender<()>, ) -> Result<(OutputStream, StreamInfo), String> { let shutdown_event = create_event("WASAPI output shutdown", true)?; @@ -478,6 +491,7 @@ fn start_output_stream( mode, OutputThreadChannels { output_rx, + output_recycle_tx, cycle_tick_tx, ready_tx: ready_tx.clone(), shutdown_event, @@ -593,6 +607,7 @@ fn start_input_stream( struct OutputThreadChannels { output_rx: Receiver>, + output_recycle_tx: SyncSender>, cycle_tick_tx: SyncSender<()>, ready_tx: SyncSender>, shutdown_event: HANDLE, @@ -607,6 +622,7 @@ fn run_output_thread( ) -> Result<(), String> { let OutputThreadChannels { output_rx, + output_recycle_tx, cycle_tick_tx, ready_tx, shutdown_event, @@ -654,6 +670,7 @@ fn run_output_thread( &client, &render_client, &output_rx, + &output_recycle_tx, &cycle_tick_tx, &mut pending, )?; @@ -985,6 +1002,7 @@ fn fill_output_available( client: &WasapiClient, render_client: &IAudioRenderClient, output_rx: &Receiver>, + output_recycle_tx: &SyncSender>, cycle_tick_tx: &SyncSender<()>, pending: &mut VecDeque, ) -> Result { @@ -1002,7 +1020,8 @@ fn fill_output_available( while pending.len() < available_frames.saturating_mul(client.channels) { match output_rx.try_recv() { Ok(period) => { - pending.extend(period); + pending.extend(period.iter().copied()); + let _ = output_recycle_tx.try_send(period); if let Err(TrySendError::Disconnected(())) = cycle_tick_tx.try_send(()) { tracing::debug!("WASAPI cycle tick receiver has been dropped"); } @@ -1365,7 +1384,7 @@ impl MidiHub { if let Ok(mut events) = queue.lock() { events.push(HwMidiEvent { device: event_device.clone(), - event: MidiEvent::new(0, data.to_vec()), + event: MidiEvent::from_slice(0, data), }); } }) diff --git a/src/lib.rs b/src/lib.rs index a72267c..d7bc43a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -32,7 +32,6 @@ pub mod meter; pub mod midi; pub mod modulator; mod osc; -#[cfg(unix)] mod pitch_shift; pub mod plan; #[cfg(feature = "plugins")] diff --git a/src/message.rs b/src/message.rs index 56dd396..061e398 100644 --- a/src/message.rs +++ b/src/message.rs @@ -2042,7 +2042,6 @@ pub enum Message { worker_id: usize, epoch: u64, node: u32, - output_linear: Vec, parameter_updates: Vec, latency_changed: bool, }, diff --git a/src/midi/io.rs b/src/midi/io.rs index c7c0638..4eccae5 100644 --- a/src/midi/io.rs +++ b/src/midi/io.rs @@ -3,15 +3,104 @@ use std::cell::UnsafeCell; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Weak}; +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum MidiData { + Inline { len: u8, bytes: [u8; 3] }, + Heap(Vec), +} + +impl MidiData { + pub fn from_slice(data: &[u8]) -> Self { + if data.len() <= 3 { + let mut bytes = [0; 3]; + bytes[..data.len()].copy_from_slice(data); + Self::Inline { + len: data.len() as u8, + bytes, + } + } else { + Self::Heap(data.to_vec()) + } + } + + pub fn to_vec(&self) -> Vec { + self.as_ref().to_vec() + } +} + +impl Default for MidiData { + fn default() -> Self { + Self::Inline { + len: 0, + bytes: [0; 3], + } + } +} + +impl From> for MidiData { + fn from(data: Vec) -> Self { + if data.len() <= 3 { + Self::from_slice(&data) + } else { + Self::Heap(data) + } + } +} + +impl From<&[u8]> for MidiData { + fn from(data: &[u8]) -> Self { + Self::from_slice(data) + } +} + +impl AsRef<[u8]> for MidiData { + fn as_ref(&self) -> &[u8] { + match self { + Self::Inline { len, bytes } => &bytes[..usize::from(*len)], + Self::Heap(data) => data, + } + } +} + +impl std::ops::Deref for MidiData { + type Target = [u8]; + + fn deref(&self) -> &Self::Target { + self.as_ref() + } +} + +impl PartialEq> for MidiData { + fn eq(&self, other: &Vec) -> bool { + self.as_ref() == other + } +} + +impl PartialEq for Vec { + fn eq(&self, other: &MidiData) -> bool { + self == other.as_ref() + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct MidiEvent { pub frame: u32, - pub data: Vec, + pub data: MidiData, } impl MidiEvent { - pub fn new(frame: u32, data: Vec) -> Self { - Self { frame, data } + pub fn new(frame: u32, data: impl Into) -> Self { + Self { + frame, + data: data.into(), + } + } + + pub fn from_slice(frame: u32, data: &[u8]) -> Self { + Self { + frame, + data: MidiData::from_slice(data), + } } } diff --git a/src/pitch_shift.rs b/src/pitch_shift.rs index 3be4136..290b03f 100644 --- a/src/pitch_shift.rs +++ b/src/pitch_shift.rs @@ -11,6 +11,7 @@ pub struct LivePitchShifter { formant_preserved: bool, input: Vec>, output: Vec>, + rendered: Vec>, interleaved: Vec, } @@ -33,6 +34,7 @@ impl LivePitchShifter { formant_preserved, input: vec![vec![0.0; block_size]; channels], output: vec![vec![0.0; block_size]; channels], + rendered: vec![Vec::new(); channels], interleaved: vec![0.0; block_size * channels.min(2)], }) } @@ -61,7 +63,7 @@ impl LivePitchShifter { request_start_frame: usize, frames: usize, mut fill_input: F, - ) -> Vec> + ) -> &[Vec] where F: FnMut(usize, &mut [Vec]) -> f64, { @@ -69,7 +71,11 @@ impl LivePitchShifter { self.reset(request_start_frame); } - let mut rendered = vec![vec![0.0; frames]; self.channels]; + self.rendered.resize_with(self.channels, Vec::new); + for channel in &mut self.rendered { + channel.clear(); + channel.resize(frames, 0.0); + } let mut written = 0usize; while written < frames { for channel in &mut self.input { @@ -79,7 +85,7 @@ impl LivePitchShifter { self.pitch_shift_block(pitch_scale); let copy_len = self.block_size.min(frames - written); - for (dst, src) in rendered.iter_mut().zip(&self.output) { + for (dst, src) in self.rendered.iter_mut().zip(&self.output) { dst[written..written + copy_len].copy_from_slice(&src[..copy_len]); } self.next_input_frame = self.next_input_frame.saturating_add(self.block_size); @@ -87,7 +93,7 @@ impl LivePitchShifter { written += copy_len; } - rendered + &self.rendered } fn pitch_shift_block(&mut self, pitch_scale: f64) { @@ -189,3 +195,29 @@ impl LivePitchShifter { timestretch::render(samples, config).map(|rendered| rendered.samples) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + #[cfg_attr(miri, ignore = "Timestretch DSP interpretation exceeds one minute")] + fn non_identity_pitch_shift_produces_finite_frames() { + let mut shifter = LivePitchShifter::new(48_000, 2, false).expect("pitch shifter"); + let rendered = shifter.render(0, DEFAULT_BLOCK_SIZE, |_start, input| { + for plane in input { + for (index, sample) in plane.iter_mut().enumerate() { + *sample = (index as f32 * 0.01).sin(); + } + } + 1.25 + }); + + assert_eq!(rendered.len(), 2); + for plane in rendered { + assert_eq!(plane.len(), DEFAULT_BLOCK_SIZE); + assert!(plane.iter().all(|sample| sample.is_finite())); + assert!(plane.iter().any(|sample| sample.abs() > f32::EPSILON)); + } + } +} diff --git a/src/plan/inline_render.rs b/src/plan/inline_render.rs index f75aaf2..e683c0c 100644 --- a/src/plan/inline_render.rs +++ b/src/plan/inline_render.rs @@ -83,6 +83,7 @@ pub(crate) struct SharedAudioPreview { /// Everything the dispatcher needs back from one inline cycle. Published by /// `render_cycle` on the cycle thread, consumed by the `HWFinished` handler. +#[derive(Default)] pub(crate) struct InlineCycleOutcome { /// The plan that was rendered; `None` when the cycle replayed the arena /// without rendering (transport paused mid-stream, offline bounce @@ -106,6 +107,7 @@ pub(crate) struct InlineCycleOutcome { struct OutcomeMailbox { ready: Option, + spare: Option, } /// Shared RT-inline render context. Owned by the `Engine`, cloned into the @@ -152,7 +154,10 @@ impl InlineRender { cycle_plan: PlanSlot::from(plan_slot.load_full()), plan_slot, render_requested: AtomicBool::new(false), - mailbox: Mutex::new(OutcomeMailbox { ready: None }), + mailbox: Mutex::new(OutcomeMailbox { + ready: None, + spare: None, + }), midi_source: Mutex::new(None), midi_routes: arc_swap::ArcSwap::from_pointee(Vec::new()), preview: arc_swap::ArcSwap::from_pointee(None), @@ -254,6 +259,13 @@ impl InlineRender { self.lock_mailbox().ready.take() } + pub(crate) fn recycle_outcome(&self, mut outcome: InlineCycleOutcome) { + outcome.plan = None; + outcome.results.clear(); + outcome.midi_in_events.clear(); + self.lock_mailbox().spare = Some(outcome); + } + /// Dispatcher (Go path, Phase 4): tag the cycle with the transport /// position it renders for. `reanchor` re-establishes the /// capture-frame ↔ transport mapping at the cycle thread (transport @@ -339,24 +351,29 @@ impl InlineRender { } } + let mut outcome = self.lock_mailbox().spare.take().unwrap_or_default(); + outcome.transport_rendered = tag; + outcome.stale = stale; + outcome.skipped_frames = skipped; + outcome.midi_in_events.reserve(64); + // Hardware MIDI-in: drained right after the capture read. On the // render path events land in the routed track ports before any task // runs, so this cycle's render sees them. A stale cycle must not push: // the events belong to the next (resynced) render, delivered via the // dispatcher buffer. - let mut midi_events: Vec = Vec::with_capacity(64); let source = self.lock_midi_source().clone(); if let Some(source) = source && let Ok(mut source) = source.lock() { - source.read_midi_events_into(&mut midi_events); + source.read_midi_events_into(&mut outcome.midi_in_events); } - if midi_events.len() > 1 && frames > 1 { - spread_event_frames(&mut midi_events, frames); + if outcome.midi_in_events.len() > 1 && frames > 1 { + spread_event_frames(&mut outcome.midi_in_events, frames); } - if render && !stale && !midi_events.is_empty() { + if render && !stale && !outcome.midi_in_events.is_empty() { let routes = self.midi_routes.load(); - for hw_event in &midi_events { + for hw_event in &outcome.midi_in_events { for route in routes.iter().filter(|r| r.device == hw_event.device) { route.track.lock().push_hw_midi_events_to_port( route.port, @@ -366,15 +383,6 @@ impl InlineRender { } } - let mut outcome = InlineCycleOutcome { - plan: None, - results: Vec::new(), - midi_in_events: midi_events, - transport_rendered: tag, - stale, - skipped_frames: skipped, - }; - if !stale && (render || self.preview_active()) { let plan = self.cycle_plan(); if render { @@ -383,14 +391,17 @@ impl InlineRender { let period = std::time::Duration::from_secs_f64( f64::from(frames) / self.sample_rate.load(Ordering::Acquire).max(1) as f64, ); - let results = self + let rendered = self .parallel .lock() .unwrap_or_else(|e| e.into_inner()) - .render_with_service(plan.clone(), period, &mut service); - if let Some(results) = results { - outcome.results = results; - } else { + .render_with_service_into( + plan.clone(), + period, + &mut service, + &mut outcome.results, + ); + if rendered.is_none() { outcome.stale = true; outcome.skipped_frames = u64::from(frames); self.stale_silence.store(true, Ordering::Release); diff --git a/src/plan/parallel_render.rs b/src/plan/parallel_render.rs index 646a89e..6b7586b 100644 --- a/src/plan/parallel_render.rs +++ b/src/plan/parallel_render.rs @@ -126,17 +126,34 @@ impl ParallelRender { plan: SharedPlan, period: Duration, ) -> Option> { - self.render_with_service(plan, period, &mut || Duration::MAX) + let mut results = Vec::new(); + self.render_with_service_into(plan, period, &mut || Duration::MAX, &mut results) + .map(|()| results) } - /// Service backend buffers while node workers own the render arena. - /// The callback returns the maximum time to wait before servicing again. + #[cfg(test)] pub(crate) fn render_with_service( &mut self, plan: SharedPlan, period: Duration, service: &mut impl FnMut() -> Duration, ) -> Option> { + let mut results = Vec::new(); + self.render_with_service_into(plan, period, service, &mut results) + .map(|()| results) + } + + /// Service backend buffers while node workers own the render arena. + /// The callback returns the maximum time to wait before servicing again. + pub(crate) fn render_with_service_into( + &mut self, + plan: SharedPlan, + period: Duration, + service: &mut impl FnMut() -> Duration, + results: &mut Vec, + ) -> Option<()> { + results.clear(); + results.reserve(plan.nodes.len()); // Never reuse an arena while a previous cycle still owns it. if self.active_plan.is_some() { return None; @@ -162,7 +179,6 @@ impl ParallelRender { self.ready.extend(plan.sources.iter().copied()); } let mut completed = 0; - let mut results = Vec::with_capacity(plan.nodes.len()); let waiter = thread::current(); loop { if Instant::now() >= deadline { @@ -198,7 +214,7 @@ impl ParallelRender { break; } self.active_plan = None; - return Some(results); + return Some(()); } // Hardware input nodes are already complete at capture fill. // All actual processing, including Zero/Sum, stays on workers. @@ -272,7 +288,7 @@ impl ParallelRender { } } - fn fail(&mut self) -> Option> { + fn fail(&mut self) -> Option<()> { self.cancelled.store(true, Ordering::Release); self.ready.clear(); self.missed = true; diff --git a/src/plugins/au_proc.rs b/src/plugins/au_proc.rs index b28295c..0578cd0 100644 --- a/src/plugins/au_proc.rs +++ b/src/plugins/au_proc.rs @@ -328,6 +328,14 @@ impl AuProcessor { } } + pub fn audio_inputs_snapshot(&self) -> &[Arc] { + &self.audio_inputs + } + + pub fn audio_outputs_snapshot(&self) -> &[Arc] { + &self.audio_outputs + } + pub fn audio_inputs(&self) -> &[Arc] { &self.audio_inputs } @@ -608,7 +616,7 @@ impl AuProcessor { while let Some(ev) = ring.pop() { let event = MidiEvent { frame: ev.sample_offset, - data: ev.data.to_vec(), + data: ev.data.as_slice().into(), }; port_buffer.push(event.clone()); output_events.push(event); diff --git a/src/plugins/clap_proc.rs b/src/plugins/clap_proc.rs index bd15ef4..051a516 100644 --- a/src/plugins/clap_proc.rs +++ b/src/plugins/clap_proc.rs @@ -290,6 +290,14 @@ impl ClapProcessor { } } + pub fn audio_inputs_snapshot(&self) -> Arc>> { + self.audio_inputs.load_full() + } + + pub fn audio_outputs_snapshot(&self) -> Arc>> { + self.audio_outputs.load_full() + } + pub fn audio_inputs(&self) -> Vec> { self.audio_inputs.load_full().as_ref().clone() } @@ -843,7 +851,7 @@ impl ClapProcessor { let midi_out_ring = RingBuffer::new(midi_out_buf, midi_out_w, midi_out_r, RING_CAPACITY); while let Some(ev) = midi_out_ring.pop() { - let event = crate::midi::io::MidiEvent::new(ev.sample_offset, ev.data.to_vec()); + let event = crate::midi::io::MidiEvent::from_slice(ev.sample_offset, &ev.data); port_buffer.push(event.clone()); midi_out.push(ClapMidiOutputEvent { port: port_idx, @@ -1121,7 +1129,7 @@ impl ClapProcessor { while let Some(ev) = ring.pop() { result.push(crate::midi::io::MidiEvent { frame: ev.sample_offset, - data: ev.data.to_vec(), + data: ev.data.as_slice().into(), }); } } diff --git a/src/plugins/lv2_proc.rs b/src/plugins/lv2_proc.rs index 6290e37..6eaab13 100644 --- a/src/plugins/lv2_proc.rs +++ b/src/plugins/lv2_proc.rs @@ -197,6 +197,14 @@ impl Lv2Processor { } } + pub fn audio_inputs_snapshot(&self) -> &[Arc] { + &self.audio_inputs + } + + pub fn audio_outputs_snapshot(&self) -> &[Arc] { + &self.audio_outputs + } + pub fn audio_inputs(&self) -> &[Arc] { &self.audio_inputs } @@ -705,7 +713,7 @@ impl Lv2Processor { while let Some(ev) = ring.pop() { let event = MidiEvent { frame: ev.sample_offset, - data: ev.data.to_vec(), + data: ev.data.as_slice().into(), }; port_buffer.push(event.clone()); output_events.push(event); @@ -843,7 +851,7 @@ impl Lv2Processor { while let Some(ev) = ring.pop() { result.push(crate::midi::io::MidiEvent { frame: ev.sample_offset, - data: ev.data.to_vec(), + data: ev.data.as_slice().into(), }); } } diff --git a/src/plugins/vst3_proc.rs b/src/plugins/vst3_proc.rs index ae2b5dc..da45106 100644 --- a/src/plugins/vst3_proc.rs +++ b/src/plugins/vst3_proc.rs @@ -210,6 +210,14 @@ impl Vst3Processor { } } + pub fn audio_inputs_snapshot(&self) -> &[Arc] { + &self.audio_inputs + } + + pub fn audio_outputs_snapshot(&self) -> &[Arc] { + &self.audio_outputs + } + pub fn audio_inputs(&self) -> &[Arc] { &self.audio_inputs } @@ -495,7 +503,7 @@ impl Vst3Processor { while let Some(ev) = ring.pop() { let event = MidiEvent { frame: ev.sample_offset, - data: ev.data.to_vec(), + data: ev.data.as_slice().into(), }; port_buffer.push(event.clone()); output_events.push(event); diff --git a/src/track/clip_render.rs b/src/track/clip_render.rs index 8c74502..bb69cec 100644 --- a/src/track/clip_render.rs +++ b/src/track/clip_render.rs @@ -1,6 +1,5 @@ #[cfg(feature = "plugins")] use crate::message::{PluginGraphNode, PluginKind}; -#[cfg(unix)] use crate::pitch_shift::LivePitchShifter; use super::*; @@ -15,6 +14,14 @@ use serde_json::Value; use std::collections::HashSet; use std::{path::Path, sync::Arc}; +fn reset_channel_buffers(buffers: &mut Vec>, channels: usize, frames: usize) { + buffers.resize_with(channels, Vec::new); + for buffer in buffers { + buffer.clear(); + buffer.resize(frames, 0.0); + } +} + /// Decoding strategy chosen for an audio clip file (see /// [`TrackData::choose_clip_strategy`]). #[cfg(feature = "audio")] @@ -27,7 +34,6 @@ pub(crate) enum ClipStrategy { } /// Channel count of any `AudioClipBuffer` variant. -#[cfg(any(unix, feature = "audio"))] fn buffer_channel_count(buffer: &AudioClipBuffer) -> usize { match buffer { #[cfg(any(feature = "audio", test))] @@ -40,7 +46,6 @@ fn buffer_channel_count(buffer: &AudioClipBuffer) -> usize { /// Effective channel count for clip processing: mono stays mono, otherwise /// the track input count wins over the buffer channel count. -#[cfg(unix)] fn effective_channels_for(buffer_channels: usize, input_count: usize) -> usize { if buffer_channels == 1 { 1 @@ -54,18 +59,20 @@ fn effective_channels_for(buffer_channels: usize, input_count: usize) -> usize { /// variants this is a `read_window` call on the streaming buffer that never /// disturbs the real-time rings; for `Buffered` it slices the in-memory /// samples. -#[cfg(any(unix, feature = "audio"))] fn clip_sample_window( buffer: &AudioClipBuffer, start: usize, len: usize, -) -> Option<(usize, Vec>)> { + window: &mut Vec>, + bytes: &mut Vec, + interleaved: &mut Vec, +) -> Option { match buffer { #[cfg(any(feature = "audio", test))] AudioClipBuffer::Buffered { channels, samples } => { let channels = (*channels).max(1); let total_frames = samples.len() / channels; - let mut window = vec![vec![0.0_f32; len]; channels]; + reset_channel_buffers(window, channels, len); for (channel, plane) in window.iter_mut().enumerate() { for (i, sample) in plane.iter_mut().enumerate() { let frame = start.saturating_add(i); @@ -74,17 +81,17 @@ fn clip_sample_window( } } } - Some((channels, window)) + Some(channels) } #[cfg(feature = "audio")] AudioClipBuffer::Streaming(stream) => stream - .read_window(start, len) + .read_window_into(start, len, window) .ok() - .map(|w| (stream.channels(), w)), + .map(|()| stream.channels()), AudioClipBuffer::SeekableStreaming(stream) => stream - .read_window(start, len) + .read_window_into(start, len, window, bytes, interleaved) .ok() - .map(|w| (stream.channels(), w)), + .map(|()| stream.channels()), } } @@ -247,12 +254,48 @@ impl TrackData { } } - #[cfg(unix)] - pub(crate) fn clip_pitch_key(clip: &crate::audio::clip::AudioClip) -> String { - format!( - "{}:{}:{}:{}:{}:{}", - clip.name, clip.start, clip.end, clip.offset, clip.input_channel, clip.reversed - ) + fn clip_pitch_shifter( + &mut self, + clip: &crate::audio::clip::AudioClip, + buffer_channels: usize, + input_count: usize, + formant: bool, + ) -> &mut LivePitchShifter { + let valid = self + .rt + .clip_pitch_shifters + .get(clip.name.as_str()) + .is_some_and(|cached| { + cached.start == clip.start + && cached.end == clip.end + && cached.offset == clip.offset + && cached.input_channel == clip.input_channel + && cached.reversed == clip.reversed + }); + if !valid { + self.rt.clip_pitch_shifters.insert( + clip.name.clone(), + ClipPitchShifter { + start: clip.start, + end: clip.end, + offset: clip.offset, + input_channel: clip.input_channel, + reversed: clip.reversed, + shifter: LivePitchShifter::new( + self.sample_rate.round().max(1.0) as usize, + effective_channels_for(buffer_channels, input_count), + formant, + ) + .expect("pitch shifter"), + }, + ); + } + &mut self + .rt + .clip_pitch_shifters + .get_mut(&clip.name) + .expect("pitch shifter") + .shifter } #[cfg(feature = "plugins")] @@ -280,6 +323,51 @@ impl TrackData { ) } + #[cfg(feature = "plugins")] + fn cached_clip_plugin_runtime_key( + &mut self, + clip: &crate::audio::clip::AudioClip, + input_count: usize, + output_count: usize, + ) -> Arc { + let valid = self + .rt + .clip_plugin_runtime_keys + .get(clip.name.as_str()) + .is_some_and(|cached| { + cached.start == clip.start + && cached.end == clip.end + && cached.offset == clip.offset + && cached.input_channel == clip.input_channel + && cached.reversed == clip.reversed + && cached.input_count == input_count + && cached.output_count == output_count + && cached.graph == clip.plugin_graph_json + }); + if !valid { + let key = Arc::::from(Self::clip_plugin_runtime_key( + clip, + input_count, + output_count, + )); + self.rt.clip_plugin_runtime_keys.insert( + clip.name.clone(), + CachedClipPluginKey { + start: clip.start, + end: clip.end, + offset: clip.offset, + input_channel: clip.input_channel, + reversed: clip.reversed, + input_count, + output_count, + graph: clip.plugin_graph_json.clone(), + key, + }, + ); + } + self.rt.clip_plugin_runtime_keys[&clip.name].key.clone() + } + #[cfg(feature = "plugins")] pub(crate) fn clip_plugin_runtime_node_from_json( value: &Value, @@ -600,18 +688,22 @@ impl TrackData { )); } let input_count = input_blocks.len().max(1); - let runtime_key = Self::clip_plugin_runtime_key(clip, input_count, input_count); - if !self.rt.clip_plugin_tracks.contains_key(&runtime_key) { + let runtime_key = self.cached_clip_plugin_runtime_key(clip, input_count, input_count); + if !self + .rt + .clip_plugin_tracks + .contains_key(runtime_key.as_ref()) + { let runtime = self.build_clip_plugin_runtime(clip, input_count, self.process_block_size())?; self.rt .clip_plugin_tracks - .insert(runtime_key.clone(), runtime); + .insert(runtime_key.to_string(), runtime); } let runtime = self .rt .clip_plugin_tracks - .get_mut(&runtime_key) + .get_mut(runtime_key.as_ref()) .ok_or_else(|| "Missing clip plugin runtime".to_string())?; Ok(runtime.process(input_blocks, request_len, ClipRuntimeProcessContext {})) @@ -670,13 +762,32 @@ impl TrackData { parent_start: usize, absolute_from: usize, request_len: usize, - #[cfg(feature = "plugins")] active_clip_plugin_keys: &mut HashSet, + #[cfg(feature = "plugins")] active_clip_plugin_keys: &mut HashSet>, out: &mut Vec>, ) -> Option<()> { let clip_start = parent_start.saturating_add(clip.start); - // `end` is an absolute timeline position (every writer stores - // `start + length`); the render length is `end - start`. let clip_len = clip.end.saturating_sub(clip.start); + self.render_audio_clip_segment_range( + clip, + (clip_start, clip_len), + absolute_from, + request_len, + #[cfg(feature = "plugins")] + active_clip_plugin_keys, + out, + ) + } + + pub(crate) fn render_audio_clip_segment_range( + &mut self, + clip: &crate::audio::clip::AudioClip, + clip_range: (usize, usize), + absolute_from: usize, + request_len: usize, + #[cfg(feature = "plugins")] active_clip_plugin_keys: &mut HashSet>, + out: &mut Vec>, + ) -> Option<()> { + let (clip_start, clip_len) = clip_range; if clip_len == 0 || request_len == 0 { return None; } @@ -691,9 +802,8 @@ impl TrackData { // Take the group scratch for the duration of this render; nested // groups then fall back to a fresh allocation (see `TrackRt`). let mut input_blocks = std::mem::take(&mut self.rt.clip_render_group_scratch); - input_blocks.clear(); - input_blocks.resize_with(channel_count, || vec![0.0; request_len]); - for child in clip.grouped_clips.clone() { + reset_channel_buffers(&mut input_blocks, channel_count, request_len); + for child in &clip.grouped_clips { let child_start = clip_start.saturating_add(child.start); let child_end = child_start.saturating_add(child.end.saturating_sub(child.start)); if absolute_to <= child_start || absolute_from >= child_end { @@ -707,7 +817,7 @@ impl TrackData { } if self .render_audio_clip_segment( - &child, + child, clip_start, child_from, child_len, @@ -744,7 +854,7 @@ impl TrackData { ); #[cfg(feature = "plugins")] if clip.plugin_graph_json.is_some() { - active_clip_plugin_keys.insert(Self::clip_plugin_runtime_key( + active_clip_plugin_keys.insert(self.cached_clip_plugin_runtime_key( clip, channel_count, channel_count, @@ -785,14 +895,13 @@ impl TrackData { let has_clip_plugins = clip.plugin_graph_json.is_some(); #[cfg(feature = "plugins")] if has_clip_plugins { - active_clip_plugin_keys.insert(Self::clip_plugin_runtime_key( + active_clip_plugin_keys.insert(self.cached_clip_plugin_runtime_key( clip, self.audio.ins.len(), self.audio.ins.len(), )); } - #[cfg(unix)] if !clip.pitch_correction_points.is_empty() { // Pitch correction needs random access into the decoded samples; // read just the needed window from the clip's buffer instead of @@ -805,61 +914,57 @@ impl TrackData { * clip.pitch_correction_inertia_ms.unwrap_or(100) as u64) / 1000) as usize; let formant = clip.pitch_correction_formant_compensation.unwrap_or(true); - let key = Self::clip_pitch_key(clip); - let corrected = { - let shifter = - self.rt - .clip_pitch_shifters - .entry(key) - .or_insert_with(|| ClipPitchShifter { - shifter: LivePitchShifter::new( - self.sample_rate.round().max(1.0) as usize, - effective_channels_for(buffer_channel_count(&buffer), input_count), - formant, - ) - .expect("pitch shifter"), - }); - shifter.shifter.set_formant_preserved(formant); - let block_size = shifter.shifter.block_size(); - // The shifter reads blocks of `block_size` frames starting - // anywhere in `[source_from, source_from + request_len)`, so - // a window of `request_len + block_size` frames covers every - // block it can request. Window frame 0 is file frame - // `source_from`. - let window_len = request_len.saturating_add(block_size); - let (buffer_channels, window) = - clip_sample_window(&buffer, source_from, window_len)?; - let effective_channels = effective_channels_for(buffer_channels, input_count); - shifter - .shifter - .render(source_from, request_len, |block_start, input| { - let local_start = block_start.saturating_sub(source_offset); - let local_mid = local_start.saturating_add(block_size / 2); - let local_end = local_start.saturating_add(block_size.saturating_sub(1)); - let semitones = - (Self::pitch_shift_for_sample(clip, local_start, inertia_samples) - + Self::pitch_shift_for_sample(clip, local_mid, inertia_samples) - + Self::pitch_shift_for_sample(clip, local_end, inertia_samples)) - / 3.0; - let scale = 2.0_f64.powf((semitones as f64) / 12.0); - for (ch, channel_input) in - input.iter_mut().enumerate().take(effective_channels) - { - let source_channel = if buffer_channels == 1 { 0 } else { ch }; - let plane = window.get(source_channel); - for (i, sample) in channel_input.iter_mut().enumerate().take(block_size) - { - let rel = block_start.saturating_sub(source_from).saturating_add(i); - *sample = plane.and_then(|p| p.get(rel)).copied().unwrap_or(0.0); - } - } - scale - }) + let buffer_channels = buffer_channel_count(&buffer); + let block_size = { + let shifter = self.clip_pitch_shifter(clip, buffer_channels, input_count, formant); + shifter.set_formant_preserved(formant); + shifter.block_size() }; + // The shifter reads blocks of `block_size` frames starting + // anywhere in `[source_from, source_from + request_len)`, so a + // window of `request_len + block_size` frames covers every block. + let window_len = request_len.saturating_add(block_size); + let mut window = std::mem::take(&mut self.rt.clip_window_scratch); + let mut bytes = std::mem::take(&mut self.rt.clip_window_bytes); + let mut interleaved = std::mem::take(&mut self.rt.clip_window_interleaved); + let window_channels = clip_sample_window( + &buffer, + source_from, + window_len, + &mut window, + &mut bytes, + &mut interleaved, + ); + self.rt.clip_window_bytes = bytes; + self.rt.clip_window_interleaved = interleaved; + let buffer_channels = window_channels?; + let effective_channels = effective_channels_for(buffer_channels, input_count); + let corrected = self + .clip_pitch_shifter(clip, buffer_channels, input_count, formant) + .render(source_from, request_len, |block_start, input| { + let local_start = block_start.saturating_sub(source_offset); + let local_mid = local_start.saturating_add(block_size / 2); + let local_end = local_start.saturating_add(block_size.saturating_sub(1)); + let semitones = + (Self::pitch_shift_for_sample(clip, local_start, inertia_samples) + + Self::pitch_shift_for_sample(clip, local_mid, inertia_samples) + + Self::pitch_shift_for_sample(clip, local_end, inertia_samples)) + / 3.0; + let scale = 2.0_f64.powf((semitones as f64) / 12.0); + for (ch, channel_input) in input.iter_mut().enumerate().take(effective_channels) + { + let source_channel = if buffer_channels == 1 { 0 } else { ch }; + let plane = window.get(source_channel); + for (i, sample) in channel_input.iter_mut().enumerate().take(block_size) { + let rel = block_start.saturating_sub(source_from).saturating_add(i); + *sample = plane.and_then(|p| p.get(rel)).copied().unwrap_or(0.0); + } + } + scale + }); let effective_channels = effective_channels_for(buffer_channel_count(&buffer), input_count); - out.clear(); - out.resize_with(input_count, || vec![0.0; request_len]); + reset_channel_buffers(out, input_count, request_len); let input_blocks: &mut Vec> = out; for (in_channel, block) in input_blocks.iter_mut().enumerate().take(input_count) { let source_channel = if effective_channels == 1 { @@ -871,6 +976,7 @@ impl TrackData { }; block[..request_len].copy_from_slice(&corrected[source_channel][..request_len]); } + self.rt.clip_window_scratch = window; Self::apply_audio_clip_fades(clip, clip_start, clip_len, absolute_from, input_blocks); #[cfg(feature = "plugins")] if has_clip_plugins @@ -906,18 +1012,27 @@ impl TrackData { }; let source_end = clip.offset.saturating_add(clip_len).min(total_frames); let local_start = absolute_from.saturating_sub(clip_start); - out.clear(); - out.resize_with(self.audio.ins.len().max(1), || vec![0.0_f32; request_len]); + reset_channel_buffers(out, self.audio.ins.len().max(1), request_len); let input_blocks: &mut Vec> = out; if source_end > clip.offset && local_start < clip_len { // Window covers [clip.offset, source_end); frame k of the // window is file frame clip.offset + k, read backwards. - let window = clip_sample_window( + let mut window = std::mem::take(&mut self.rt.clip_window_scratch); + let mut bytes = std::mem::take(&mut self.rt.clip_window_bytes); + let mut interleaved = std::mem::take(&mut self.rt.clip_window_interleaved); + let channels = clip_sample_window( &buffer, clip.offset, source_end.saturating_sub(clip.offset), - )? - .1; + &mut window, + &mut bytes, + &mut interleaved, + ); + self.rt.clip_window_scratch = window; + self.rt.clip_window_bytes = bytes; + self.rt.clip_window_interleaved = interleaved; + channels?; + let window = &self.rt.clip_window_scratch; let window_frames = window.first().map(|p| p.len()).unwrap_or(0); for (in_channel, block) in input_blocks.iter_mut().enumerate() { let source_channel = if clip_channels == 1 { @@ -974,11 +1089,9 @@ impl TrackData { let local_start = absolute_from.saturating_sub(clip_start); let source_from = clip.offset.saturating_add(local_start); let stream_blocks = &mut self.rt.clip_render_stream_scratch; - stream_blocks.clear(); - stream_blocks.resize_with(clip_channels, || vec![0.0_f32; request_len]); + reset_channel_buffers(stream_blocks, clip_channels, request_len); stream.read_frames(source_from, request_len, stream_blocks); - out.clear(); - out.resize_with(input_count, || vec![0.0_f32; request_len]); + reset_channel_buffers(out, input_count, request_len); for (in_channel, block) in out.iter_mut().enumerate() { let source_channel = if clip_channels == 1 { 0 @@ -996,11 +1109,9 @@ impl TrackData { let local_start = absolute_from.saturating_sub(clip_start); let source_from = clip.offset.saturating_add(local_start); let stream_blocks = &mut self.rt.clip_render_stream_scratch; - stream_blocks.clear(); - stream_blocks.resize_with(clip_channels, || vec![0.0_f32; request_len]); + reset_channel_buffers(stream_blocks, clip_channels, request_len); stream.read_frames(source_from, request_len, stream_blocks); - out.clear(); - out.resize_with(input_count, || vec![0.0_f32; request_len]); + reset_channel_buffers(out, input_count, request_len); for (in_channel, block) in out.iter_mut().enumerate() { let source_channel = if clip_channels == 1 { 0 @@ -1030,8 +1141,7 @@ impl TrackData { if total_frames == 0 { return None; } - out.clear(); - out.resize_with(self.audio.ins.len().max(1), || vec![0.0; request_len]); + reset_channel_buffers(out, self.audio.ins.len().max(1), request_len); for (in_channel, block) in out.iter_mut().enumerate().take(self.audio.ins.len().max(1)) { @@ -1115,12 +1225,9 @@ impl TrackData { return; } if !clip.grouped_clips.is_empty() { - // Collect children into a local list first so the recursive calls - // can borrow `self` mutably while sharing the same event buffer. - let children: Vec<_> = clip.grouped_clips.to_vec(); - for child in children { + for child in &clip.grouped_clips { self.collect_midi_clip_events_recursive( - &child, + child, clip_start, input_events, frames, @@ -1367,7 +1474,6 @@ impl TrackData { Ok(runtime) } - #[cfg(unix)] pub(crate) fn pitch_shift_for_sample( clip: &crate::audio::clip::AudioClip, sample: usize, @@ -1619,32 +1725,39 @@ impl TrackData { self.preload_midi_clip_cache(); } - pub(crate) fn cycle_segments(&self, frames: usize) -> Vec<(usize, usize, usize)> { + pub(crate) fn cycle_segments_into( + &self, + frames: usize, + segments: &mut Vec<(usize, usize, usize)>, + ) { + segments.clear(); if frames == 0 { - return vec![]; + return; } if !self.rt.loop_enabled { - return vec![( + segments.push(( self.rt.transport_sample, self.rt.transport_sample.saturating_add(frames), 0, - )]; + )); + return; } let Some((loop_start, loop_end)) = self.rt.loop_range_samples else { - return vec![( + segments.push(( self.rt.transport_sample, self.rt.transport_sample.saturating_add(frames), 0, - )]; + )); + return; }; if loop_end <= loop_start { - return vec![( + segments.push(( self.rt.transport_sample, self.rt.transport_sample.saturating_add(frames), 0, - )]; + )); + return; } - let mut segments = Vec::new(); let mut remaining = frames; let mut out_offset = 0usize; let mut current = self.rt.transport_sample; @@ -1664,6 +1777,12 @@ impl TrackData { current.saturating_add(take) }; } + } + + #[cfg(test)] + pub(crate) fn cycle_segments(&self, frames: usize) -> Vec<(usize, usize, usize)> { + let mut segments = Vec::new(); + self.cycle_segments_into(frames, &mut segments); segments } @@ -1693,8 +1812,11 @@ impl TrackData { } #[cfg(feature = "plugins")] - let mut active_clip_plugin_keys = HashSet::new(); - let segments = self.cycle_segments(frames); + let mut active_clip_plugin_keys = std::mem::take(&mut self.rt.active_clip_plugin_keys); + #[cfg(feature = "plugins")] + active_clip_plugin_keys.clear(); + let mut segments = std::mem::take(&mut self.rt.cycle_segments_scratch); + self.cycle_segments_into(frames, &mut segments); // Reusable render target for all clips this cycle; restored to // `self.rt` at the end of the loop. let mut clip_scratch = std::mem::take(&mut self.rt.clip_render_scratch); @@ -1816,10 +1938,15 @@ impl TrackData { } } self.rt.clip_render_scratch = clip_scratch; + self.rt.cycle_segments_scratch = segments; #[cfg(feature = "plugins")] self.rt .clip_plugin_tracks - .retain(|key, _| active_clip_plugin_keys.contains(key)); + .retain(|key, _| active_clip_plugin_keys.contains(key.as_str())); + #[cfg(feature = "plugins")] + { + self.rt.active_clip_plugin_keys = active_clip_plugin_keys; + } } pub(crate) fn mix_clip_midi_into_inputs( @@ -1830,7 +1957,8 @@ impl TrackData { if frames == 0 || input_events.is_empty() { return; } - let segments = self.cycle_segments(frames); + let mut segments = std::mem::take(&mut self.rt.cycle_segments_scratch); + self.cycle_segments_into(frames, &mut segments); for clip in self.midi.clips().iter() { self.collect_midi_clip_events_recursive(clip, 0, input_events, frames, &segments); } @@ -1838,6 +1966,7 @@ impl TrackData { *events = self.allocate_mpe_events(std::mem::take(events)); events.sort_by_key(|event| event.frame); } + self.rt.cycle_segments_scratch = segments; } } diff --git a/src/track/midi_io.rs b/src/track/midi_io.rs index a3ae5e2..e2940c9 100644 --- a/src/track/midi_io.rs +++ b/src/track/midi_io.rs @@ -36,7 +36,9 @@ impl TrackData { // Collect raw events from MIDI inputs first; allocation needs mutable // access to `self` (for the MPE voice allocator), so it is done after // the input borrow is released. - let mut lane_buffers: Vec> = Vec::with_capacity(self.midi.ins.len()); + let mut lane_buffers = std::mem::take(&mut self.rt.folder_input_midi_events); + lane_buffers.resize_with(self.midi.ins.len(), Vec::new); + lane_buffers.truncate(self.midi.ins.len()); for (lane, input) in self.midi.ins.iter().enumerate() { // Safety: plan single-writer invariant — this task is the sole // writer of its own ports this cycle; sources it reads were @@ -57,7 +59,7 @@ impl TrackData { } buffer.sort_by_key(|event| event.frame); input.mark_finished(); - lane_buffers.push(std::mem::take(&mut *buffer)); + std::mem::swap(&mut *buffer, &mut lane_buffers[lane]); } for buffer in &mut lane_buffers { *buffer = self.allocate_mpe_events(std::mem::take(buffer)); diff --git a/src/track/mod.rs b/src/track/mod.rs index 3100840..541b3fc 100644 --- a/src/track/mod.rs +++ b/src/track/mod.rs @@ -1,7 +1,6 @@ use super::{audio::track::AudioTrack, midi::mpe::MpeState, midi::track::MIDITrack}; #[cfg(feature = "plugins")] -use crate::message::{PluginGraphConnection, PluginGraphNode}; -#[cfg(unix)] +use crate::message::{PluginGraphConnection, PluginGraphNode, PluginKind}; use crate::pitch_shift::LivePitchShifter; use crate::kind::Kind; @@ -92,9 +91,13 @@ pub(crate) enum AudioClipBuffer { SeekableStreaming(Arc), } -#[cfg(unix)] #[derive(Debug)] pub(crate) struct ClipPitchShifter { + start: usize, + end: usize, + offset: usize, + input_channel: usize, + reversed: bool, shifter: LivePitchShifter, } @@ -736,6 +739,36 @@ impl Default for TransportSampleSnapshot { /// Per-cycle (real-time) state of a [`Track`]. #[derive(Debug)] +#[cfg(feature = "plugins")] +struct CachedClipPluginKey { + start: usize, + end: usize, + offset: usize, + input_channel: usize, + reversed: bool, + input_count: usize, + output_count: usize, + graph: Option, + key: Arc, +} + +#[cfg(feature = "plugins")] +#[derive(Default)] +pub(crate) struct PluginGraphScratch { + order: Vec<(PluginKind, usize)>, + processed: HashSet<(PluginKind, usize)>, + output_buffers: HashMap>, + source_latencies: HashMap, + output_keys: HashSet, + ready_outputs: HashSet, + input_buffers: Vec>, + // Slice lifetimes are unbound only for the current plugin call. Clear + // these vectors before mutating their backing buffers or output map. + input_slices: Vec<&'static [f32]>, + output_ptrs: Vec<*mut Vec>, + output_slices: Vec<&'static mut [f32]>, +} + pub struct TrackRt { pub echoed_parameter_updates: Vec, pub pending_hw_midi_out_events: Vec, @@ -760,7 +793,10 @@ pub struct TrackRt { audio_clip_cache: HashMap>, #[cfg(feature = "plugins")] clip_plugin_tracks: HashMap, - #[cfg(unix)] + #[cfg(feature = "plugins")] + clip_plugin_runtime_keys: HashMap, + #[cfg(feature = "plugins")] + active_clip_plugin_keys: HashSet>, pub(crate) clip_pitch_shifters: HashMap, midi_clip_cache: HashMap, internal_output_routes_cache: Vec>>, @@ -785,6 +821,9 @@ pub struct TrackRt { folder_processed_midi_plugins: HashSet, folder_clip_playback_active: bool, folder_record_tap_input_snapshots: Vec>, + output_delay_scratch: Vec, + #[cfg(feature = "plugins")] + plugin_graph_scratch: PluginGraphScratch, plugin_delay_lines: HashMap<(usize, usize), crate::render_plan::DelayLine>, /// Reusable render target for `render_audio_clip_segment` (grown on /// demand, cleared per use). Passed down recursion as `out`; never @@ -797,6 +836,10 @@ pub struct TrackRt { clip_render_group_scratch: Vec>, /// Reusable temporary for streaming clip decode (source channel planes). clip_render_stream_scratch: Vec>, + clip_window_scratch: Vec>, + clip_window_bytes: Vec, + clip_window_interleaved: Vec, + cycle_segments_scratch: Vec<(usize, usize, usize)>, } impl TrackRt { @@ -825,7 +868,10 @@ impl TrackRt { audio_clip_cache: HashMap::new(), #[cfg(feature = "plugins")] clip_plugin_tracks: HashMap::new(), - #[cfg(unix)] + #[cfg(feature = "plugins")] + clip_plugin_runtime_keys: HashMap::new(), + #[cfg(feature = "plugins")] + active_clip_plugin_keys: HashSet::new(), clip_pitch_shifters: HashMap::new(), midi_clip_cache: HashMap::new(), internal_output_routes_cache: Vec::new(), @@ -847,10 +893,17 @@ impl TrackRt { folder_processed_midi_plugins: HashSet::new(), folder_clip_playback_active: false, folder_record_tap_input_snapshots: Vec::new(), + output_delay_scratch: vec![0.0; buffer_size], + #[cfg(feature = "plugins")] + plugin_graph_scratch: PluginGraphScratch::default(), plugin_delay_lines: HashMap::new(), clip_render_scratch: Vec::new(), clip_render_group_scratch: Vec::new(), clip_render_stream_scratch: Vec::new(), + clip_window_scratch: Vec::new(), + clip_window_bytes: Vec::new(), + clip_window_interleaved: Vec::new(), + cycle_segments_scratch: Vec::new(), } } diff --git a/src/track/plugins.rs b/src/track/plugins.rs index 0cceaa5..e285650 100644 --- a/src/track/plugins.rs +++ b/src/track/plugins.rs @@ -1880,6 +1880,12 @@ impl TrackData { Ok(()) } + fn plugin_process_order_into(&self, order: &mut Vec<(PluginKind, usize)>) { + if order.is_empty() { + *order = self.plugin_process_order(); + } + } + pub(crate) fn plugin_process_order(&self) -> Vec<(PluginKind, usize)> { let mut entries: Vec<(PluginGraphNode, PluginKind, usize)> = Vec::new(); for (idx, instance) in self.clap_plugins.iter().enumerate() { @@ -2557,13 +2563,13 @@ impl TrackData { nodes.into_iter().collect() } - fn plugin_output_keys(&self) -> HashSet { - let mut keys = HashSet::new(); + fn plugin_output_keys_into(&self, keys: &mut HashSet) { + keys.clear(); for instance in &self.clap_plugins { keys.extend( instance .processor - .audio_outputs() + .audio_outputs_snapshot() .iter() .map(|port| Arc::as_ptr(port) as usize), ); @@ -2597,74 +2603,50 @@ impl TrackData { .map(|port| Arc::as_ptr(port) as usize), ); } - keys } - fn zero_plugin_output_buffers(&self, frames: usize) -> Vec<(usize, Vec)> { - let mut buffers = Vec::new(); - for instance in &self.clap_plugins { - buffers.extend( - instance - .processor - .audio_outputs() - .iter() - .map(|port| (Arc::as_ptr(port) as usize, vec![0.0; frames])), - ); - } - for instance in &self.vst3_plugins { - buffers.extend( - instance - .processor - .audio_outputs() - .iter() - .map(|port| (Arc::as_ptr(port) as usize, vec![0.0; frames])), - ); - } - #[cfg(target_os = "macos")] - for instance in &self.au_plugins { - buffers.extend( - instance - .processor - .audio_outputs() - .iter() - .map(|port| (Arc::as_ptr(port) as usize, vec![0.0; frames])), - ); - } - #[cfg(unix)] - for instance in &self.lv2_plugins { - buffers.extend( - instance - .processor - .audio_outputs() - .iter() - .map(|port| (Arc::as_ptr(port) as usize, vec![0.0; frames])), - ); + fn zero_plugin_output_buffers_into( + frames: usize, + output_keys: &HashSet, + ready_outputs: &HashSet, + output_buffers: &mut HashMap>, + ) { + for &key in output_keys { + let buffer = output_buffers.entry(key).or_default(); + if !ready_outputs.contains(&key) { + buffer.clear(); + } + buffer.resize(frames, 0.0); } - buffers } fn graph_audio_inputs_ready( input_ports: &[Arc], plugin_output_keys: &HashSet, - output_buffers: &HashMap>, + ready_outputs: &HashSet, ) -> bool { - input_ports.iter().all(|input| { - input.connections().iter().all(|source| { + let mut ready = true; + for input in input_ports { + input.visit_connections(|source| { let key = Arc::as_ptr(source) as usize; - !plugin_output_keys.contains(&key) || output_buffers.contains_key(&key) - }) - }) + if plugin_output_keys.contains(&key) && !ready_outputs.contains(&key) { + ready = false; + } + }); + if !ready { + return false; + } + } + true } fn source_slice_for_graph_key<'a>( - &'a self, + audio_inputs: &[Arc], key: usize, track_inputs: &'a [&mut [f32]], output_buffers: &'a HashMap>, ) -> Option<&'a [f32]> { - if let Some((idx, _)) = self - .audio - .ins + if let Some((idx, _)) = audio_inputs .iter() .enumerate() .find(|(_, input)| Arc::as_ptr(input) as usize == key) @@ -2674,62 +2656,63 @@ impl TrackData { output_buffers.get(&key).map(Vec::as_slice) } - fn plugin_graph_source_latencies(&self) -> HashMap { - self.audio - .ins - .iter() - .map(|input| (Arc::as_ptr(input) as usize, 0)) - .collect() - } - fn plugin_node_input_latency( &self, node: &PluginGraphNode, source_latencies: &HashMap, ) -> usize { - self.plugin_audio_input_ports_for_node(node) - .iter() - .flat_map(|input| input.connections().iter().cloned().collect::>()) - .map(|source| { - source_latencies - .get(&(Arc::as_ptr(&source) as usize)) - .copied() - .unwrap_or(0) - }) - .max() - .unwrap_or(0) - } - - fn plugin_audio_input_ports_for_node(&self, node: &PluginGraphNode) -> Vec> { + let mut max_latency = 0; + let mut visit_ports = |ports: &[Arc]| { + for input in ports { + input.visit_connections(|source| { + let key = Arc::as_ptr(source) as usize; + max_latency = max_latency.max(source_latencies.get(&key).copied().unwrap_or(0)); + }); + } + }; match node { - PluginGraphNode::ClapPluginInstance(instance_id) => self - .clap_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_inputs().to_vec()) - .unwrap_or_default(), - PluginGraphNode::Vst3PluginInstance(instance_id) => self - .vst3_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_inputs().to_vec()) - .unwrap_or_default(), + PluginGraphNode::ClapPluginInstance(instance_id) => { + if let Some(instance) = self + .clap_plugins + .iter() + .find(|instance| instance.id == *instance_id) + { + let ports = instance.processor.audio_inputs_snapshot(); + visit_ports(&ports); + } + } + PluginGraphNode::Vst3PluginInstance(instance_id) => { + if let Some(instance) = self + .vst3_plugins + .iter() + .find(|instance| instance.id == *instance_id) + { + visit_ports(instance.processor.audio_inputs()); + } + } #[cfg(target_os = "macos")] - PluginGraphNode::AuPluginInstance(instance_id) => self - .au_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_inputs().to_vec()) - .unwrap_or_default(), + PluginGraphNode::AuPluginInstance(instance_id) => { + if let Some(instance) = self + .au_plugins + .iter() + .find(|instance| instance.id == *instance_id) + { + visit_ports(instance.processor.audio_inputs()); + } + } #[cfg(unix)] - PluginGraphNode::Lv2PluginInstance(instance_id) => self - .lv2_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_inputs().to_vec()) - .unwrap_or_default(), - _ => Vec::new(), + PluginGraphNode::Lv2PluginInstance(instance_id) => { + if let Some(instance) = self + .lv2_plugins + .iter() + .find(|instance| instance.id == *instance_id) + { + visit_ports(instance.processor.audio_inputs()); + } + } + _ => {} } + max_latency } pub(crate) fn plugin_latency_samples(&self, kind: PluginKind, index: usize) -> usize { @@ -2786,121 +2769,45 @@ impl TrackData { clap_changed || vst3_changed || lv2_changed || au_changed } - pub(crate) fn plugin_graph_latency_samples(&self) -> usize { - let source_latencies = self.current_plugin_graph_source_latencies(); - self.audio - .outs + pub(crate) fn output_latency_from_plan(&self, plan: &crate::render_plan::RenderPlan) -> usize { + self.rt + .internal_output_routes_cache .iter() - .flat_map(|output| output.connections().iter().cloned().collect::>()) - .map(|source| { - source_latencies - .get(&(Arc::as_ptr(&source) as usize)) - .copied() - .unwrap_or(0) - }) + .flatten() + .filter_map(|source| plan.port_map.get(&(Arc::as_ptr(source) as usize))) + .map(|&buffer| plan.buffer_latency(buffer)) .max() .unwrap_or(0) } - pub(crate) fn current_plugin_graph_source_latencies(&self) -> HashMap { - let mut source_latencies = self.plugin_graph_source_latencies(); - for (kind, index) in self.plugin_process_order() { - let node = match kind { - PluginKind::Clap => self - .clap_plugins - .get(index) - .map(|instance| PluginGraphNode::ClapPluginInstance(instance.id)), - PluginKind::Vst3 => self - .vst3_plugins - .get(index) - .map(|instance| PluginGraphNode::Vst3PluginInstance(instance.id)), - #[cfg(target_os = "macos")] - PluginKind::Au => self - .au_plugins - .get(index) - .map(|instance| PluginGraphNode::AuPluginInstance(instance.id)), - #[cfg(unix)] - PluginKind::Lv2 => self - .lv2_plugins - .get(index) - .map(|instance| PluginGraphNode::Lv2PluginInstance(instance.id)), - }; - let Some(node) = node else { - continue; - }; - let latency = self - .plugin_node_input_latency(&node, &source_latencies) - .saturating_add(self.plugin_latency_samples(kind, index)); - for output in self.plugin_audio_output_ports_for_node(&node) { - source_latencies.insert(Arc::as_ptr(&output) as usize, latency); - } - } - source_latencies - } - - fn plugin_audio_output_ports_for_node(&self, node: &PluginGraphNode) -> Vec> { - match node { - PluginGraphNode::ClapPluginInstance(instance_id) => self - .clap_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_outputs().to_vec()) - .unwrap_or_default(), - PluginGraphNode::Vst3PluginInstance(instance_id) => self - .vst3_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_outputs().to_vec()) - .unwrap_or_default(), - #[cfg(target_os = "macos")] - PluginGraphNode::AuPluginInstance(instance_id) => self - .au_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_outputs().to_vec()) - .unwrap_or_default(), - #[cfg(unix)] - PluginGraphNode::Lv2PluginInstance(instance_id) => self - .lv2_plugins - .iter() - .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.audio_outputs().to_vec()) - .unwrap_or_default(), - _ => Vec::new(), - } - } - - fn sum_graph_audio_inputs( + fn sum_graph_audio_inputs_into( &mut self, input_ports: &[Arc], frames: usize, track_inputs: &[&mut [f32]], output_buffers: &HashMap>, source_latencies: &HashMap, - ) -> Vec> { - input_ports - .iter() - .map(|input| { - let mut dst = vec![0.0; frames]; - let sources = input.connections(); - let max_latency = sources - .iter() - .map(|source| { - source_latencies - .get(&(Arc::as_ptr(source) as usize)) - .copied() - .unwrap_or(0) - }) - .max() - .unwrap_or(0); - for (source_idx, source) in sources.iter().enumerate() { - let key = Arc::as_ptr(source) as usize; - let Some(src) = - self.source_slice_for_graph_key(key, track_inputs, output_buffers) - else { - continue; - }; - let src = src.to_vec(); + input_buffers: &mut Vec>, + ) { + input_buffers.resize_with(input_ports.len(), Vec::new); + for (input, dst) in input_ports.iter().zip(input_buffers.iter_mut()) { + dst.clear(); + dst.resize(frames, 0.0); + let mut max_latency = 0; + input.visit_connections(|source| { + let key = Arc::as_ptr(source) as usize; + max_latency = max_latency.max(source_latencies.get(&key).copied().unwrap_or(0)); + }); + let mut source_idx = 0; + input.visit_connections(|source| { + let key = Arc::as_ptr(source) as usize; + let src = Self::source_slice_for_graph_key( + &self.audio.ins, + key, + track_inputs, + output_buffers, + ); + if let Some(src) = src { let latency = source_latencies.get(&key).copied().unwrap_or(0); let delay = max_latency.saturating_sub(latency); let line = self @@ -2908,346 +2815,413 @@ impl TrackData { .plugin_delay_lines .entry((Arc::as_ptr(input) as usize, source_idx)) .or_default(); - line.process(&src, delay, &mut dst, source_idx != 0); + line.process(src, delay, dst, source_idx != 0); } - dst - }) - .collect() + source_idx += 1; + }); + } } pub(crate) fn process_track_plugins_in_graph_order_with_audio_buffers( &mut self, frames: usize, track_inputs: &[&mut [f32]], - ) -> Vec<(usize, Vec)> { + scratch: &mut PluginGraphScratch, + ) { self.apply_transport_sample_snapshot(); - let track_input_events = self.rt.folder_input_midi_events.clone(); - let order = self.plugin_process_order(); - let mut processed = HashSet::<(PluginKind, usize)>::new(); - let mut output_buffers = HashMap::>::new(); - let mut source_latencies = self.plugin_graph_source_latencies(); - let plugin_output_keys = self.plugin_output_keys(); + let mut order = std::mem::take(&mut scratch.order); + self.plugin_process_order_into(&mut order); + let mut processed = std::mem::take(&mut scratch.processed); + processed.clear(); + let mut output_buffers = std::mem::take(&mut scratch.output_buffers); + let mut source_latencies = std::mem::take(&mut scratch.source_latencies); + source_latencies.clear(); + source_latencies.extend( + self.audio + .ins + .iter() + .map(|input| (Arc::as_ptr(input) as usize, 0)), + ); + let mut plugin_output_keys = std::mem::take(&mut scratch.output_keys); + self.plugin_output_keys_into(&mut plugin_output_keys); + output_buffers.retain(|key, _| plugin_output_keys.contains(key)); + let mut ready_outputs = std::mem::take(&mut scratch.ready_outputs); + ready_outputs.clear(); self.rt.folder_processed_midi_plugins.clear(); self.rt.folder_plugin_midi_node_events.clear(); self.rt.echoed_parameter_updates.clear(); - let track_name = self.name.clone(); let can_skip_plugins = !self.is_realtime_domain() && self.rt.last_render_block_silent - && track_input_events.is_empty() + && self.rt.folder_input_midi_events.is_empty() && track_inputs .iter() .all(|input| input.iter().all(|&sample| sample == 0.0)); - if can_skip_plugins { - return self.zero_plugin_output_buffers(frames); - } - - while processed.len() < order.len() { - let mut progressed = false; - for &(kind, idx) in &order { - if processed.contains(&(kind, idx)) { - continue; - } - match kind { - PluginKind::Clap => { - let processor = self.clap_plugins[idx].processor.clone(); - let input_ports = processor.audio_inputs(); - if !Self::graph_audio_inputs_ready( - &input_ports, - &plugin_output_keys, - &output_buffers, - ) { - continue; - } - let node = PluginGraphNode::ClapPluginInstance(self.clap_plugins[idx].id); - self.plugin_midi_input_events( - &node, - processor.midi_input_count(), - &track_input_events, - &self.rt.folder_plugin_midi_node_events, - ); - let input_buffers = self.sum_graph_audio_inputs( - &input_ports, - frames, - track_inputs, - &output_buffers, - &source_latencies, - ); - let mut output_buffers_for_plugin = - vec![vec![0.0; frames]; processor.audio_outputs().len()]; - let inputs = input_buffers.iter().map(Vec::as_slice).collect::>(); - let mut outputs = output_buffers_for_plugin - .iter_mut() - .map(Vec::as_mut_slice) - .collect::>(); - let midi_outputs = processor.process_with_audio_buffers( - frames, - &[], - crate::plugins::types::ClapTransportInfo { - transport_sample: self.rt.transport_sample, - playing: (self.disk_monitor().iter().any(|&m| m) - || self.midi_disk_monitor().iter().any(|&m| m)) - && self.rt.clip_playback_enabled, - loop_enabled: self.rt.loop_enabled, - loop_range_samples: self.rt.loop_range_samples, - bpm: self.rt.tempo_bpm, - tsig_num: self.rt.tsig_num, - tsig_denom: self.rt.tsig_denom, - }, - &inputs, - &mut outputs, - ); - for (port, buffer) in processor - .audio_outputs() - .iter() - .zip(output_buffers_for_plugin) - { - let key = Arc::as_ptr(port) as usize; - output_buffers.insert(key, buffer); - source_latencies.insert( - key, - self.plugin_node_input_latency(&node, &source_latencies) - .saturating_add(processor.latency_samples()), + if !can_skip_plugins { + while processed.len() < order.len() { + let mut progressed = false; + for &(kind, idx) in &order { + if processed.contains(&(kind, idx)) { + continue; + } + match kind { + PluginKind::Clap => { + let processor = self.clap_plugins[idx].processor.clone(); + let input_ports = processor.audio_inputs_snapshot(); + if !Self::graph_audio_inputs_ready( + &input_ports, + &plugin_output_keys, + &ready_outputs, + ) { + continue; + } + let node = + PluginGraphNode::ClapPluginInstance(self.clap_plugins[idx].id); + self.plugin_midi_input_events( + &node, + processor.midi_input_count(), + &self.rt.folder_input_midi_events, + &self.rt.folder_plugin_midi_node_events, ); - } - for ev in processor.drain_echoed_parameters() { - self.rt.echoed_parameter_updates.push( - crate::message::Action::TrackSetClapParameter { - track_name: track_name.clone(), - instance_id: self.clap_plugins[idx].id, - param_id: ev.param_index, - value: ev.value as f64, - }, + scratch.input_slices.clear(); + self.sum_graph_audio_inputs_into( + &input_ports, + frames, + track_inputs, + &output_buffers, + &source_latencies, + &mut scratch.input_buffers, ); - } - for evt in midi_outputs { - self.rt - .folder_plugin_midi_node_events - .entry((node.clone(), evt.port)) - .or_default() - .push(evt.event); - } - self.rt.folder_processed_midi_plugins.insert(node); - } - PluginKind::Vst3 => { - let processor = self.vst3_plugins[idx].processor.clone(); - let input_ports = processor.audio_inputs(); - if !Self::graph_audio_inputs_ready( - input_ports, - &plugin_output_keys, - &output_buffers, - ) { - continue; - } - let node = PluginGraphNode::Vst3PluginInstance(self.vst3_plugins[idx].id); - let midi_inputs = self.plugin_midi_input_events( - &node, - processor.midi_input_count(), - &track_input_events, - &self.rt.folder_plugin_midi_node_events, - ); - let _vst3_input = midi_inputs.first().cloned().unwrap_or_default(); - let input_buffers = self.sum_graph_audio_inputs( - input_ports, - frames, - track_inputs, - &output_buffers, - &source_latencies, - ); - let mut output_buffers_for_plugin = - vec![vec![0.0; frames]; processor.audio_outputs().len()]; - let inputs = input_buffers.iter().map(Vec::as_slice).collect::>(); - let mut outputs = output_buffers_for_plugin - .iter_mut() - .map(Vec::as_mut_slice) - .collect::>(); - let midi_outputs = - processor.process_with_audio_buffers(frames, &inputs, &mut outputs); - for (port, buffer) in processor - .audio_outputs() - .iter() - .zip(output_buffers_for_plugin) - { - let key = Arc::as_ptr(port) as usize; - output_buffers.insert(key, buffer); - source_latencies.insert( - key, - self.plugin_node_input_latency(&node, &source_latencies) - .saturating_add(processor.latency_samples()), + scratch + .input_slices + .extend(scratch.input_buffers.iter().map(|buffer| unsafe { + std::slice::from_raw_parts(buffer.as_ptr(), buffer.len()) + })); + scratch.output_ptrs.clear(); + scratch.output_slices.clear(); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + let buffer = output_buffers.entry(key).or_default(); + buffer.clear(); + buffer.resize(frames, 0.0); + scratch.output_ptrs.push(buffer); + } + scratch.output_slices.extend( + scratch + .output_ptrs + .iter() + .map(|ptr| unsafe { (&mut **ptr).as_mut_slice() }), ); - } - for ev in processor.drain_echoed_parameters() { - self.rt.echoed_parameter_updates.push( - crate::message::Action::TrackSetVst3Parameter { - track_name: track_name.clone(), - instance_id: self.vst3_plugins[idx].id, - param_id: ev.param_index, - value: ev.value, + let midi_outputs = processor.process_with_audio_buffers( + frames, + &[], + crate::plugins::types::ClapTransportInfo { + transport_sample: self.rt.transport_sample, + playing: (self.disk_monitor().iter().any(|&m| m) + || self.midi_disk_monitor().iter().any(|&m| m)) + && self.rt.clip_playback_enabled, + loop_enabled: self.rt.loop_enabled, + loop_range_samples: self.rt.loop_range_samples, + bpm: self.rt.tempo_bpm, + tsig_num: self.rt.tsig_num, + tsig_denom: self.rt.tsig_denom, }, + &scratch.input_slices, + &mut scratch.output_slices, ); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + ready_outputs.insert(key); + source_latencies.insert( + key, + self.plugin_node_input_latency(&node, &source_latencies) + .saturating_add(processor.latency_samples()), + ); + } + for ev in processor.drain_echoed_parameters() { + self.rt.echoed_parameter_updates.push( + crate::message::Action::TrackSetClapParameter { + track_name: self.name.clone(), + instance_id: self.clap_plugins[idx].id, + param_id: ev.param_index, + value: ev.value as f64, + }, + ); + } + for evt in midi_outputs { + self.rt + .folder_plugin_midi_node_events + .entry((node.clone(), evt.port)) + .or_default() + .push(evt.event); + } + self.rt.folder_processed_midi_plugins.insert(node); } - if !midi_outputs.is_empty() { - self.rt - .folder_plugin_midi_node_events - .insert((node.clone(), 0), midi_outputs); - } - self.rt.folder_processed_midi_plugins.insert(node); - } - #[cfg(target_os = "macos")] - PluginKind::Au => { - let processor = self.au_plugins[idx].processor.clone(); - let input_ports = processor.audio_inputs(); - if !Self::graph_audio_inputs_ready( - input_ports, - &plugin_output_keys, - &output_buffers, - ) { - continue; - } - let node = PluginGraphNode::AuPluginInstance(self.au_plugins[idx].id); - let midi_inputs = self.plugin_midi_input_events( - &node, - processor.midi_input_count(), - &track_input_events, - &self.rt.folder_plugin_midi_node_events, - ); - let _au_input = midi_inputs.first().cloned().unwrap_or_default(); - let input_buffers = self.sum_graph_audio_inputs( - input_ports, - frames, - track_inputs, - &output_buffers, - &source_latencies, - ); - let mut output_buffers_for_plugin = - vec![vec![0.0; frames]; processor.audio_outputs().len()]; - let inputs = input_buffers.iter().map(Vec::as_slice).collect::>(); - let mut outputs = output_buffers_for_plugin - .iter_mut() - .map(Vec::as_mut_slice) - .collect::>(); - let midi_outputs = - processor.process_with_audio_buffers(frames, &inputs, &mut outputs); - for (port, buffer) in processor - .audio_outputs() - .iter() - .zip(output_buffers_for_plugin) - { - let key = Arc::as_ptr(port) as usize; - output_buffers.insert(key, buffer); - source_latencies.insert( - key, - self.plugin_node_input_latency(&node, &source_latencies) - .saturating_add(processor.latency_samples()), + PluginKind::Vst3 => { + let processor = self.vst3_plugins[idx].processor.clone(); + let input_ports = processor.audio_inputs_snapshot(); + if !Self::graph_audio_inputs_ready( + input_ports, + &plugin_output_keys, + &ready_outputs, + ) { + continue; + } + let node = + PluginGraphNode::Vst3PluginInstance(self.vst3_plugins[idx].id); + self.plugin_midi_input_events( + &node, + processor.midi_input_count(), + &self.rt.folder_input_midi_events, + &self.rt.folder_plugin_midi_node_events, ); - } - for ev in processor.drain_echoed_parameters() { - self.rt.echoed_parameter_updates.push( - crate::message::Action::TrackSetAuParameter { - track_name: track_name.clone(), - instance_id: self.au_plugins[idx].id, - param_index: ev.param_index, - value: ev.value, - }, + scratch.input_slices.clear(); + self.sum_graph_audio_inputs_into( + input_ports, + frames, + track_inputs, + &output_buffers, + &source_latencies, + &mut scratch.input_buffers, ); + scratch + .input_slices + .extend(scratch.input_buffers.iter().map(|buffer| unsafe { + std::slice::from_raw_parts(buffer.as_ptr(), buffer.len()) + })); + scratch.output_ptrs.clear(); + scratch.output_slices.clear(); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + let buffer = output_buffers.entry(key).or_default(); + buffer.clear(); + buffer.resize(frames, 0.0); + scratch.output_ptrs.push(buffer); + } + scratch.output_slices.extend( + scratch + .output_ptrs + .iter() + .map(|ptr| unsafe { (&mut **ptr).as_mut_slice() }), + ); + let midi_outputs = processor.process_with_audio_buffers( + frames, + &scratch.input_slices, + &mut scratch.output_slices, + ); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + ready_outputs.insert(key); + source_latencies.insert( + key, + self.plugin_node_input_latency(&node, &source_latencies) + .saturating_add(processor.latency_samples()), + ); + } + for ev in processor.drain_echoed_parameters() { + self.rt.echoed_parameter_updates.push( + crate::message::Action::TrackSetVst3Parameter { + track_name: self.name.clone(), + instance_id: self.vst3_plugins[idx].id, + param_id: ev.param_index, + value: ev.value, + }, + ); + } + if !midi_outputs.is_empty() { + self.rt + .folder_plugin_midi_node_events + .insert((node.clone(), 0), midi_outputs); + } + self.rt.folder_processed_midi_plugins.insert(node); } - if !midi_outputs.is_empty() { - self.rt - .folder_plugin_midi_node_events - .insert((node.clone(), 0), midi_outputs); - } - self.rt.folder_processed_midi_plugins.insert(node); - } - #[cfg(unix)] - PluginKind::Lv2 => { - let processor = self.lv2_plugins[idx].processor.clone(); - let input_ports = processor.audio_inputs(); - if !Self::graph_audio_inputs_ready( - input_ports, - &plugin_output_keys, - &output_buffers, - ) { - continue; - } - let node = PluginGraphNode::Lv2PluginInstance(self.lv2_plugins[idx].id); - let midi_inputs = self.plugin_midi_input_events( - &node, - processor.midi_input_count(), - &track_input_events, - &self.rt.folder_plugin_midi_node_events, - ); - let _lv2_input = midi_inputs.first().cloned().unwrap_or_default(); - let input_buffers = self.sum_graph_audio_inputs( - input_ports, - frames, - track_inputs, - &output_buffers, - &source_latencies, - ); - let mut output_buffers_for_plugin = - vec![vec![0.0; frames]; processor.audio_outputs().len()]; - let inputs = input_buffers.iter().map(Vec::as_slice).collect::>(); - let mut outputs = output_buffers_for_plugin - .iter_mut() - .map(Vec::as_mut_slice) - .collect::>(); - let midi_outputs = processor.process_with_audio_buffers( - frames, - crate::plugins::types::Lv2TransportInfo { - transport_sample: self.rt.transport_sample, - playing: (self.disk_monitor().iter().any(|&m| m) - || self.midi_disk_monitor().iter().any(|&m| m)) - && self.rt.clip_playback_enabled, - bpm: self.rt.tempo_bpm, - tsig_num: self.rt.tsig_num, - tsig_denom: self.rt.tsig_denom, - }, - &inputs, - &mut outputs, - ); - for (port, buffer) in processor - .audio_outputs() - .iter() - .zip(output_buffers_for_plugin) - { - let key = Arc::as_ptr(port) as usize; - output_buffers.insert(key, buffer); - source_latencies.insert( - key, - self.plugin_node_input_latency(&node, &source_latencies) - .saturating_add(processor.latency_samples()), + #[cfg(target_os = "macos")] + PluginKind::Au => { + let processor = self.au_plugins[idx].processor.clone(); + let input_ports = processor.audio_inputs_snapshot(); + if !Self::graph_audio_inputs_ready( + input_ports, + &plugin_output_keys, + &ready_outputs, + ) { + continue; + } + let node = PluginGraphNode::AuPluginInstance(self.au_plugins[idx].id); + self.plugin_midi_input_events( + &node, + processor.midi_input_count(), + &self.rt.folder_input_midi_events, + &self.rt.folder_plugin_midi_node_events, + ); + scratch.input_slices.clear(); + self.sum_graph_audio_inputs_into( + input_ports, + frames, + track_inputs, + &output_buffers, + &source_latencies, + &mut scratch.input_buffers, + ); + scratch + .input_slices + .extend(scratch.input_buffers.iter().map(|buffer| unsafe { + std::slice::from_raw_parts(buffer.as_ptr(), buffer.len()) + })); + scratch.output_ptrs.clear(); + scratch.output_slices.clear(); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + let buffer = output_buffers.entry(key).or_default(); + buffer.clear(); + buffer.resize(frames, 0.0); + scratch.output_ptrs.push(buffer); + } + scratch.output_slices.extend( + scratch + .output_ptrs + .iter() + .map(|ptr| unsafe { (&mut **ptr).as_mut_slice() }), ); + let midi_outputs = processor.process_with_audio_buffers( + frames, + &scratch.input_slices, + &mut scratch.output_slices, + ); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + ready_outputs.insert(key); + source_latencies.insert( + key, + self.plugin_node_input_latency(&node, &source_latencies) + .saturating_add(processor.latency_samples()), + ); + } + for ev in processor.drain_echoed_parameters() { + self.rt.echoed_parameter_updates.push( + crate::message::Action::TrackSetAuParameter { + track_name: self.name.clone(), + instance_id: self.au_plugins[idx].id, + param_index: ev.param_index, + value: ev.value, + }, + ); + } + if !midi_outputs.is_empty() { + self.rt + .folder_plugin_midi_node_events + .insert((node.clone(), 0), midi_outputs); + } + self.rt.folder_processed_midi_plugins.insert(node); } - for ev in processor.drain_echoed_parameters() { - self.rt.echoed_parameter_updates.push( - crate::message::Action::TrackSetLv2ControlValue { - track_name: track_name.clone(), - instance_id: self.lv2_plugins[idx].id, - index: ev.param_index, - value: ev.value, + #[cfg(unix)] + PluginKind::Lv2 => { + let processor = self.lv2_plugins[idx].processor.clone(); + let input_ports = processor.audio_inputs_snapshot(); + if !Self::graph_audio_inputs_ready( + input_ports, + &plugin_output_keys, + &ready_outputs, + ) { + continue; + } + let node = PluginGraphNode::Lv2PluginInstance(self.lv2_plugins[idx].id); + self.plugin_midi_input_events( + &node, + processor.midi_input_count(), + &self.rt.folder_input_midi_events, + &self.rt.folder_plugin_midi_node_events, + ); + scratch.input_slices.clear(); + self.sum_graph_audio_inputs_into( + input_ports, + frames, + track_inputs, + &output_buffers, + &source_latencies, + &mut scratch.input_buffers, + ); + scratch + .input_slices + .extend(scratch.input_buffers.iter().map(|buffer| unsafe { + std::slice::from_raw_parts(buffer.as_ptr(), buffer.len()) + })); + scratch.output_ptrs.clear(); + scratch.output_slices.clear(); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + let buffer = output_buffers.entry(key).or_default(); + buffer.clear(); + buffer.resize(frames, 0.0); + scratch.output_ptrs.push(buffer); + } + scratch.output_slices.extend( + scratch + .output_ptrs + .iter() + .map(|ptr| unsafe { (&mut **ptr).as_mut_slice() }), + ); + let midi_outputs = processor.process_with_audio_buffers( + frames, + crate::plugins::types::Lv2TransportInfo { + transport_sample: self.rt.transport_sample, + playing: (self.disk_monitor().iter().any(|&m| m) + || self.midi_disk_monitor().iter().any(|&m| m)) + && self.rt.clip_playback_enabled, + bpm: self.rt.tempo_bpm, + tsig_num: self.rt.tsig_num, + tsig_denom: self.rt.tsig_denom, }, + &scratch.input_slices, + &mut scratch.output_slices, ); + for port in processor.audio_outputs_snapshot().iter() { + let key = Arc::as_ptr(port) as usize; + ready_outputs.insert(key); + source_latencies.insert( + key, + self.plugin_node_input_latency(&node, &source_latencies) + .saturating_add(processor.latency_samples()), + ); + } + for ev in processor.drain_echoed_parameters() { + self.rt.echoed_parameter_updates.push( + crate::message::Action::TrackSetLv2ControlValue { + track_name: self.name.clone(), + instance_id: self.lv2_plugins[idx].id, + index: ev.param_index, + value: ev.value, + }, + ); + } + if !midi_outputs.is_empty() { + self.rt + .folder_plugin_midi_node_events + .insert((node.clone(), 0), midi_outputs); + } + self.rt.folder_processed_midi_plugins.insert(node); } - if !midi_outputs.is_empty() { - self.rt - .folder_plugin_midi_node_events - .insert((node.clone(), 0), midi_outputs); - } - self.rt.folder_processed_midi_plugins.insert(node); } + processed.insert((kind, idx)); + progressed = true; + } + if !progressed { + break; } - processed.insert((kind, idx)); - progressed = true; - } - if !progressed { - break; } } - for (key, buffer) in self.zero_plugin_output_buffers(frames) { - output_buffers.entry(key).or_insert(buffer); - } - output_buffers.into_iter().collect() + Self::zero_plugin_output_buffers_into( + frames, + &plugin_output_keys, + &ready_outputs, + &mut output_buffers, + ); + scratch.order = order; + scratch.processed = processed; + scratch.output_buffers = output_buffers; + scratch.source_latencies = source_latencies; + scratch.output_keys = plugin_output_keys; + scratch.ready_outputs = ready_outputs; } pub(crate) fn plugin_midi_ready( @@ -3279,60 +3253,42 @@ impl TrackData { pub(crate) fn plugin_midi_input_events( &self, node: &PluginGraphNode, - midi_inputs: usize, + _midi_inputs: usize, _track_input_events: &[Vec], _node_events: &HashMap<(PluginGraphNode, usize), Vec>, - ) -> Vec> { - let ports = self.plugin_midi_input_ports_for_node(node); - let mut per_port: Vec> = ports - .iter() - .map(|port| { - // Safety: plan single-writer invariant — this task is the sole - // writer of its own ports this cycle; sources it reads were - // produced by earlier plan nodes (LOCKLESS.md Phase 3). - unsafe { port.process() }; - // Safety: as above — this task just produced the buffer. - unsafe { port.buffer() }.to_vec() - }) - .collect(); - if per_port.len() < midi_inputs { - per_port.resize_with(midi_inputs, Vec::new); - } - per_port - } - - pub(crate) fn plugin_midi_input_ports_for_node( - &self, - node: &PluginGraphNode, - ) -> Vec> { - match node { + ) { + let ports = match node { PluginGraphNode::ClapPluginInstance(instance_id) => self .clap_plugins .iter() .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.midi_input_ports().to_vec()) - .unwrap_or_default(), + .map(|instance| instance.processor.midi_input_ports()), PluginGraphNode::Vst3PluginInstance(instance_id) => self .vst3_plugins .iter() .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.midi_input_ports().to_vec()) - .unwrap_or_default(), + .map(|instance| instance.processor.midi_input_ports()), #[cfg(target_os = "macos")] PluginGraphNode::AuPluginInstance(instance_id) => self .au_plugins .iter() .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.midi_input_ports().to_vec()) - .unwrap_or_default(), + .map(|instance| instance.processor.midi_input_ports()), #[cfg(unix)] PluginGraphNode::Lv2PluginInstance(instance_id) => self .lv2_plugins .iter() .find(|instance| instance.id == *instance_id) - .map(|instance| instance.processor.midi_input_ports().to_vec()) - .unwrap_or_default(), - _ => Vec::new(), + .map(|instance| instance.processor.midi_input_ports()), + _ => None, + }; + if let Some(ports) = ports { + for port in ports.iter() { + // Safety: plan single-writer invariant — this task is the sole + // writer of its own ports this cycle; sources it reads were + // produced by earlier plan nodes (LOCKLESS.md Phase 3). + unsafe { port.process() }; + } } } diff --git a/src/track/process.rs b/src/track/process.rs index 0cf23ee..c162eee 100644 --- a/src/track/process.rs +++ b/src/track/process.rs @@ -197,6 +197,8 @@ impl TrackData { pub fn invalidate_audio_route_cache(&mut self) { self.rt.audio_route_cache_dirty = true; + #[cfg(feature = "plugins")] + self.rt.plugin_graph_scratch.order.clear(); } pub fn primary_audio_ins(&self) -> usize { @@ -234,6 +236,8 @@ impl TrackData { pub fn invalidate_midi_route_cache(&mut self) { self.rt.midi_route_cache_dirty = true; + #[cfg(feature = "plugins")] + self.rt.plugin_graph_scratch.order.clear(); } pub(crate) fn ensure_midi_route_cache(&mut self) { @@ -357,8 +361,9 @@ impl TrackData { if !samples_per_beat.is_finite() || samples_per_beat <= 1.0 { return; } - let segments = self.cycle_segments(frames); - for (seg_start, seg_end, frame_offset) in segments { + let mut segments = std::mem::take(&mut self.rt.cycle_segments_scratch); + self.cycle_segments_into(frames, &mut segments); + for &(seg_start, seg_end, frame_offset) in &segments { if seg_end <= seg_start { continue; } @@ -393,6 +398,7 @@ impl TrackData { beat_idx = beat_idx.saturating_add(1); } } + self.rt.cycle_segments_scratch = segments; } #[cfg(test)] @@ -436,42 +442,41 @@ impl TrackData { metronome_output.as_deref_mut(), ); #[cfg(feature = "plugins")] - let plugin_outputs = - self.process_track_plugins_in_graph_order_with_audio_buffers(frames, audio_inputs); - // Safety: the input buffers and `plugin_outputs` outlive the - // `process_folder_output_with_audio_buffers` call below, which is the - // only consumer of the appended entries; the caller clears `sources` - // afterwards (see doc comment). + let mut plugin_scratch = std::mem::take(&mut self.rt.plugin_graph_scratch); + #[cfg(feature = "plugins")] + self.process_track_plugins_in_graph_order_with_audio_buffers( + frames, + audio_inputs, + &mut plugin_scratch, + ); + // Safety: the input buffers and plugin scratch outlive the output + // call below, which is the only consumer of the appended entries. for (audio_in, buffer) in self.audio.ins.iter().zip(audio_inputs.iter()) { let key = Arc::as_ptr(audio_in) as usize; let slice: &[f32] = buffer; - // Safety: processing of these inputs has finished; the slice is - // consumed only by folder-output processing below, before the - // caller reuses its mutable input buffers. let slice = unsafe { std::slice::from_raw_parts(slice.as_ptr(), slice.len()) }; if let Some((_, source, _)) = sources .iter_mut() .find(|(candidate, _, _)| *candidate == key) { - // The worker supplied latency without borrowing the input - // during its in-place writes. Retain that latency here. *source = slice; } else { sources.push((key, slice, 0)); } } #[cfg(feature = "plugins")] - { - let graph_latencies = self.current_plugin_graph_source_latencies(); - sources.extend(plugin_outputs.iter().map(|(key, buffer)| { - let slice = buffer.as_slice(); - ( - *key, - unsafe { std::slice::from_raw_parts(slice.as_ptr(), slice.len()) }, - graph_latencies.get(key).copied().unwrap_or(0), - ) - })); - } + sources.extend(plugin_scratch.output_buffers.iter().map(|(key, buffer)| { + let slice = buffer.as_slice(); + ( + *key, + unsafe { std::slice::from_raw_parts(slice.as_ptr(), slice.len()) }, + plugin_scratch + .source_latencies + .get(key) + .copied() + .unwrap_or(0), + ) + })); // Publish the synthesized metronome side buffer so the output stage // can sum it into the track outputs through the route cache. let metronome_buf = metronome_output.map(|buf| &*buf); @@ -486,6 +491,10 @@ impl TrackData { } } self.process_folder_output_with_audio_buffers(audio_outputs, sources); + #[cfg(feature = "plugins")] + { + self.rt.plugin_graph_scratch = plugin_scratch; + } frames } @@ -587,10 +596,11 @@ impl TrackData { let record_tap_active = self.armed() && self.rt.record_tap_enabled; { let snapshots = &mut self.rt.folder_record_tap_input_snapshots; - snapshots.clear(); - if record_tap_active { - for audio_in in audio_inputs.iter() { - snapshots.push(audio_in.to_vec()); + snapshots.resize_with(audio_inputs.len(), Vec::new); + for (snapshot, audio_in) in snapshots.iter_mut().zip(audio_inputs.iter()) { + snapshot.clear(); + if record_tap_active { + snapshot.extend_from_slice(audio_in); } } } @@ -744,7 +754,7 @@ impl TrackData { audio_inputs, audio_outputs, ); - let track_name = self.name.clone(); + let track_name = &self.name; for ev in processor.drain_echoed_parameters() { self.rt.echoed_parameter_updates.push( crate::message::Action::TrackSetClapParameter { @@ -773,16 +783,15 @@ impl TrackData { if !self.plugin_midi_ready(&node, &self.rt.folder_processed_midi_plugins) { return; } - let midi_inputs = self.plugin_midi_input_events( + self.plugin_midi_input_events( &node, processor.midi_input_count(), &self.rt.folder_input_midi_events, &self.rt.folder_plugin_midi_node_events, ); - let _vst3_input = midi_inputs.first().cloned().unwrap_or_default(); let outputs = processor.process_with_audio_buffers(frames, audio_inputs, audio_outputs); - let track_name = self.name.clone(); + let track_name = &self.name; for ev in processor.drain_echoed_parameters() { self.rt.echoed_parameter_updates.push( crate::message::Action::TrackSetVst3Parameter { @@ -810,16 +819,15 @@ impl TrackData { if !self.plugin_midi_ready(&node, &self.rt.folder_processed_midi_plugins) { return; } - let midi_inputs = self.plugin_midi_input_events( + self.plugin_midi_input_events( &node, processor.midi_input_count(), &self.rt.folder_input_midi_events, &self.rt.folder_plugin_midi_node_events, ); - let _au_input = midi_inputs.first().cloned().unwrap_or_default(); let outputs = processor.process_with_audio_buffers(frames, audio_inputs, audio_outputs); - let track_name = self.name.clone(); + let track_name = &self.name; for ev in processor.drain_echoed_parameters() { self.rt.echoed_parameter_updates.push( crate::message::Action::TrackSetAuParameter { @@ -847,13 +855,12 @@ impl TrackData { if !self.plugin_midi_ready(&node, &self.rt.folder_processed_midi_plugins) { return; } - let midi_inputs = self.plugin_midi_input_events( + self.plugin_midi_input_events( &node, processor.midi_input_count(), &self.rt.folder_input_midi_events, &self.rt.folder_plugin_midi_node_events, ); - let _lv2_input = midi_inputs.first().cloned().unwrap_or_default(); let outputs = processor.process_with_audio_buffers( frames, crate::plugins::types::Lv2TransportInfo { @@ -868,7 +875,7 @@ impl TrackData { audio_inputs, audio_outputs, ); - let track_name = self.name.clone(); + let track_name = &self.name; for ev in processor.drain_echoed_parameters() { self.rt.echoed_parameter_updates.push( crate::message::Action::TrackSetLv2ControlValue { @@ -988,13 +995,10 @@ impl TrackData { && (!c.rt.playing_session_clips.is_empty() || !c.rt.pending_session_launches.is_empty()) }); - // Take (rather than clone) the record-tap input snapshots captured by - // the folder-input pass: the loop below only reads them, and the - // field is restored before this function returns, so nothing can - // observe the temporary emptiness. This avoids copying every input - // buffer's samples once per block. let record_tap_input_snapshots = std::mem::take(&mut self.rt.folder_record_tap_input_snapshots); + let output_routes = std::mem::take(&mut self.rt.internal_output_routes_cache); + let mut delayed = std::mem::take(&mut self.rt.output_delay_scratch); let input_monitor = self.input_monitor(); let mut all_outputs_zero = true; for out_idx in 0..self.audio.outs.len().min(audio_outputs.len()) { @@ -1020,11 +1024,11 @@ impl TrackData { }; let output_gain = linear_gain * balance_gain * phase_multiplier; let unity_output_gain = (output_gain - 1.0).abs() <= f32::EPSILON; - let sources = self.rt.internal_output_routes_cache.get(out_idx).cloned(); - let has_sources = sources.as_ref().is_some_and(|s| !s.is_empty()); + let sources = output_routes.get(out_idx); + let has_sources = sources.is_some_and(|s| !s.is_empty()); let mut wrote_output = false; if self.output_enabled() - && let Some(sources) = &sources + && let Some(sources) = sources { let mut seeded = false; let max_latency = sources @@ -1059,7 +1063,7 @@ impl TrackData { Arc::as_ptr(source) as usize, )) .or_default(); - let mut delayed = vec![0.0; out_samples.len()]; + delayed.resize(out_samples.len(), 0.0); line.process(source_buf, delay, &mut delayed, false); if !seeded { if unity_output_gain { @@ -1154,6 +1158,8 @@ impl TrackData { } self.rt.folder_record_tap_input_snapshots = record_tap_input_snapshots; + self.rt.internal_output_routes_cache = output_routes; + self.rt.output_delay_scratch = delayed; self.rt.last_render_block_silent = all_outputs_zero; self.audio.set_finished(true); self.audio.set_processing(false); diff --git a/src/track/seekable_streaming.rs b/src/track/seekable_streaming.rs index 9f1e4d9..aa7cd4c 100644 --- a/src/track/seekable_streaming.rs +++ b/src/track/seekable_streaming.rs @@ -25,7 +25,7 @@ use std::fs::File; use std::io::{self, Read, Seek, SeekFrom}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering}; -use std::sync::{Arc, Mutex}; +use std::sync::{Arc, Mutex, OnceLock}; use std::thread::JoinHandle; use std::time::Duration; @@ -208,6 +208,15 @@ struct SeekControl { seek_request: Arc, generation: Arc, eof: Arc, + producer_thread: Arc>, +} + +impl SeekControl { + fn wake(&self) { + if let Some(thread) = self.producer_thread.get() { + thread.unpark(); + } + } } fn deinterleave( @@ -263,11 +272,8 @@ pub struct SeekableStreamingClipBuffer { pub channels: usize, pub engine_sample_rate: usize, total_frames: usize, - /// Only read by `read_window` (random-access offline reads: pitch - /// correction on Unix, reversed playback with `audio`). - #[cfg(any(unix, feature = "audio"))] + /// Only read by `read_window` for random-access offline reads. path: PathBuf, - #[cfg(any(unix, feature = "audio"))] layout: WavPcmLayout, rings: Vec>>, eof: Arc, @@ -336,6 +342,7 @@ impl SeekableStreamingClipBuffer { seek_request: Arc::new(AtomicUsize::new(0)), generation: Arc::new(AtomicU64::new(0)), eof: Arc::new(AtomicBool::new(false)), + producer_thread: Arc::new(OnceLock::new()), }; let (done_tx, done_rx) = std::sync::mpsc::channel(); let thread_control = control.clone(); @@ -353,13 +360,15 @@ impl SeekableStreamingClipBuffer { super::streaming::release_producer_slot(); io::Error::other(format!("Failed to spawn seekable streaming producer: {e}")) })?; + control + .producer_thread + .set(handle.thread().clone()) + .expect("seekable producer thread handle already set"); Ok(Self { channels, engine_sample_rate: engine_rate, total_frames, - #[cfg(any(unix, feature = "audio"))] path: path.to_path_buf(), - #[cfg(any(unix, feature = "audio"))] layout, rings, eof: control.eof.clone(), @@ -465,6 +474,7 @@ impl SeekableStreamingClipBuffer { ); } } + self.control.wake(); frames } @@ -474,40 +484,57 @@ impl SeekableStreamingClipBuffer { /// /// This opens a short-lived file handle on the calling thread and never /// touches the SPSC rings, so the real-time read position is undisturbed. - #[cfg(any(unix, feature = "audio"))] + #[cfg(all(test, feature = "audio"))] pub fn read_window(&self, start: usize, len: usize) -> io::Result>> { + let mut window = Vec::new(); + let mut bytes = Vec::new(); + let mut interleaved = Vec::new(); + self.read_window_into(start, len, &mut window, &mut bytes, &mut interleaved)?; + Ok(window) + } + + pub fn read_window_into( + &self, + start: usize, + len: usize, + window: &mut Vec>, + bytes: &mut Vec, + interleaved: &mut Vec, + ) -> io::Result<()> { let channels = self.channels.max(1); - let mut window = vec![vec![0.0_f32; len]; channels]; + window.resize_with(channels, Vec::new); + for plane in &mut *window { + plane.clear(); + plane.resize(len, 0.0); + } if len == 0 { - return Ok(window); + return Ok(()); } let available = self.total_frames.saturating_sub(start); let real = len.min(available); if real == 0 { - return Ok(window); + return Ok(()); } let block_align = self.layout.block_align(); let position = self .layout .data_offset .saturating_add(start as u64 * block_align as u64); - let mut bytes = vec![0u8; real.saturating_mul(block_align)]; + bytes.clear(); + bytes.resize(real.saturating_mul(block_align), 0); let file = File::open(self.layout_path_hint())?; - read_exact_at(&file, position, &mut bytes)?; - let mut interleaved = Vec::new(); - self.layout - .convert_interleaved(&bytes, real, &mut interleaved); + read_exact_at(&file, position, bytes)?; + self.layout.convert_interleaved(bytes, real, interleaved); for (channel, plane) in window.iter_mut().enumerate() { for (i, sample) in plane.iter_mut().enumerate().take(real) { *sample = interleaved[i * channels + channel]; } } - Ok(window) + Ok(()) } /// Path kept only so [`Self::read_window`] can open its own handle; the /// producer thread holds the primary one. - #[cfg(any(unix, feature = "audio"))] fn layout_path_hint(&self) -> PathBuf { self.path.clone() } @@ -516,6 +543,7 @@ impl SeekableStreamingClipBuffer { impl Drop for SeekableStreamingClipBuffer { fn drop(&mut self) { self.control.stop.store(true, Ordering::Release); + self.control.wake(); if let Ok(mut guard) = self.producer.lock() && let Some(producer) = guard.take() && !producer.handle.is_finished() @@ -581,7 +609,11 @@ fn run_producer( if at_eof { // A seekable clip may be looped after reaching EOF. Keep the // producer alive so a later seek can refill the rings. - std::thread::sleep(Duration::from_millis(1)); + if !control.stop.load(Ordering::Acquire) + && control.generation.load(Ordering::Acquire) == generation + { + std::thread::park(); + } continue; } @@ -620,12 +652,22 @@ fn run_producer( next_frame += push_frames; } if push_frames != frames { - let rest: Vec = data[push_frames * channels..].to_vec(); - pending = Some((rest, frames - push_frames)); + pending = if push_frames == 0 { + Some((data, frames)) + } else { + Some(( + data[push_frames * channels..].to_vec(), + frames - push_frames, + )) + }; if control.stop.load(Ordering::Acquire) { return Ok(()); } - std::thread::sleep(Duration::from_millis(1)); + if control.generation.load(Ordering::Acquire) == generation + && rings.iter().map(Producer::slots).min().unwrap_or(0) == 0 + { + std::thread::park(); + } } } } @@ -731,6 +773,23 @@ mod tests { ); } + #[test] + #[cfg_attr(miri, ignore = "Miri isolation does not support filesystem open")] + fn seekable_stream_wakes_after_full_ring_is_consumed() { + let (path, source) = tone_wav("maolan_seekstream_full_ring", 48_000, 0.5, 440.0); + let buffer = SeekableStreamingClipBuffer::start(&path, 48_000, 16, 1).unwrap(); + assert_eq!(wait_for_frames(&buffer, 16, Duration::from_secs(5)), 16); + + let mut out = vec![vec![0.0; 16]]; + assert_eq!(buffer.read_frames(0, 1, &mut out), 1); + assert_eq!(wait_for_frames(&buffer, 16, Duration::from_secs(5)), 16); + assert_eq!(buffer.read_frames(1, 16, &mut out), 16); + for (&actual, &expected) in out[0].iter().zip(&source[1..17]) { + assert!((actual - expected).abs() < 1.0e-6); + } + std::fs::remove_file(path).expect("remove temporary test file"); + } + #[test] #[cfg_attr(miri, ignore = "Miri isolation does not support filesystem open")] fn seekable_stream_mid_buffer_seek_is_exact() { diff --git a/src/track/session.rs b/src/track/session.rs index 35ee43d..3ca1773 100644 --- a/src/track/session.rs +++ b/src/track/session.rs @@ -223,7 +223,9 @@ impl TrackData { return; } #[cfg(feature = "plugins")] - let mut active_clip_plugin_keys = HashSet::new(); + let mut active_clip_plugin_keys = std::mem::take(&mut self.rt.active_clip_plugin_keys); + #[cfg(feature = "plugins")] + active_clip_plugin_keys.clear(); let channel_count = inputs.len(); let clip_count = self.rt.playing_session_clips.len(); let mut position_updates = Vec::new(); @@ -292,14 +294,11 @@ impl TrackData { break; } let segment_len = (frames - out_offset).min(remaining_segment); - let mut session_clip = (*arrangement_clip).clone(); - session_clip.start = 0; - session_clip.end = clip_length; if self - .render_audio_clip_segment( - &session_clip, - 0, + .render_audio_clip_segment_range( + arrangement_clip.as_ref(), + (0, clip_length), play_position, segment_len, #[cfg(feature = "plugins")] @@ -354,7 +353,11 @@ impl TrackData { #[cfg(feature = "plugins")] self.rt .clip_plugin_tracks - .retain(|key, _| active_clip_plugin_keys.contains(key)); + .retain(|key, _| active_clip_plugin_keys.contains(key.as_str())); + #[cfg(feature = "plugins")] + { + self.rt.active_clip_plugin_keys = active_clip_plugin_keys; + } let peak = inputs .iter() .map(|input| crate::simd::peak_abs(input)) diff --git a/src/track/streaming.rs b/src/track/streaming.rs index 2aa089d..ca21726 100644 --- a/src/track/streaming.rs +++ b/src/track/streaming.rs @@ -275,10 +275,22 @@ impl StreamingClipBuffer { /// decoder (decode-and-discard up to `start`, then read `len` frames) /// and never touches the SPSC rings, so the real-time read position and /// the producer are undisturbed. + #[cfg(all(test, feature = "audio"))] pub fn read_window(&self, start: usize, len: usize) -> io::Result>> { + let mut window = Vec::new(); + self.read_window_into(start, len, &mut window)?; + Ok(window) + } + + pub fn read_window_into( + &self, + start: usize, + len: usize, + window: &mut Vec>, + ) -> io::Result<()> { #[cfg(not(feature = "audio"))] { - let _ = (start, len); + let _ = (start, len, window); return Err(io::Error::other( "audio codec support is disabled (enable the `audio` cargo feature)", )); @@ -286,9 +298,13 @@ impl StreamingClipBuffer { #[cfg(feature = "audio")] { let channels = self.channels.max(1); - let mut window = vec![vec![0.0_f32; len]; channels]; + window.resize_with(channels, Vec::new); + for plane in &mut *window { + plane.clear(); + plane.resize(len, 0.0); + } if len == 0 { - return Ok(window); + return Ok(()); } let mut decoder = StreamingDecoder::new(&self.path)?; let mut position = 0usize; @@ -313,7 +329,7 @@ impl StreamingClipBuffer { filled += take; position += frames; } - Ok(window) + Ok(()) } } diff --git a/src/workers/hw_worker.rs b/src/workers/hw_worker.rs index 3c9f5f7..c489160 100644 --- a/src/workers/hw_worker.rs +++ b/src/workers/hw_worker.rs @@ -88,27 +88,36 @@ const RT_POLICY: i32 = libc::SCHED_FIFO; const RT_PRIORITY_WORKER: i32 = 18; impl HwWorker { - fn configure_rt_thread(name: &str, priority: i32) -> Result<(), String> { + fn configure_rt_thread(name: &'static str, priority: i32) -> Result<(), String> { #[cfg(unix)] { let thread = unsafe { libc::pthread_self() }; - #[cfg(unix)] - let c_name = std::ffi::CString::new(name).map_err(|e| e.to_string())?; - #[cfg(target_os = "linux")] - unsafe { - let rc = libc::pthread_setname_np(thread, c_name.as_ptr()); - crate::report_status(rc, "Failed to name hardware worker thread"); - } - #[cfg(target_os = "macos")] - unsafe { - // macOS names the current thread and takes no thread handle. - let rc = libc::pthread_setname_np(c_name.as_ptr()); - crate::report_status(rc, "Failed to name hardware worker thread"); - } - #[cfg(any(target_os = "freebsd", target_os = "openbsd"))] - unsafe { - libc::pthread_set_name_np(thread, c_name.as_ptr()); - } + std::thread_local! { + static NAMED_RT_THREAD: std::cell::Cell> = + const { std::cell::Cell::new(None) }; + } + NAMED_RT_THREAD.with(|configured| { + if configured.get() != Some(name) { + let c_name = std::ffi::CString::new(name).map_err(|e| e.to_string())?; + #[cfg(target_os = "linux")] + unsafe { + let rc = libc::pthread_setname_np(thread, c_name.as_ptr()); + crate::report_status(rc, "Failed to name hardware worker thread"); + } + #[cfg(target_os = "macos")] + unsafe { + // macOS names the current thread and takes no thread handle. + let rc = libc::pthread_setname_np(c_name.as_ptr()); + crate::report_status(rc, "Failed to name hardware worker thread"); + } + #[cfg(any(target_os = "freebsd", target_os = "openbsd"))] + unsafe { + libc::pthread_set_name_np(thread, c_name.as_ptr()); + } + configured.set(Some(name)); + } + Ok::<(), String>(()) + })?; let param = unsafe { let mut p = std::mem::zeroed::(); diff --git a/src/workers/worker.rs b/src/workers/worker.rs index 50d2d20..06e34d1 100644 --- a/src/workers/worker.rs +++ b/src/workers/worker.rs @@ -19,7 +19,6 @@ pub(crate) struct NodeJobResult { pub(crate) worker_id: usize, pub(crate) epoch: u64, pub(crate) node: u32, - pub(crate) output_linear: Vec, pub(crate) parameter_updates: Vec, pub(crate) latency_changed: bool, } @@ -1161,264 +1160,259 @@ impl Worker { /// so downstream `Sum` nodes and the hardware drain see the result. pub(crate) fn process_node_job_result(worker_id: usize, job: NodeJob) -> NodeJobResult { let NodeJob { epoch, plan, node } = job; - let (output_linear, parameter_updates, latency_changed) = - Self::with_node_scratch(|scratch| { - match &plan.nodes[node as usize] { - Op::Zero { output } => { - // Safety: this worker executes this node; the plan's - // single-producer-chain invariant guarantees exclusive - // access to the output buffer. - unsafe { &mut *plan.buffer_ptr(*output) }.fill(0.0); - plan.set_buffer_latency(*output, 0); - (Vec::new(), Vec::new(), false) - } - Op::Sum { - inputs, - delays, - output, - } => { - // Safety: see `Op::Zero`; additionally, every input buffer's - // producer completed before this node was dispatched. - let out = unsafe { &mut *plan.buffer_ptr(*output) }; - out.fill(0.0); - let max_latency = inputs - .iter() - .map(|&input| plan.buffer_latency(input)) - .max() - .unwrap_or(0); - for (idx, &input) in inputs.iter().enumerate() { - let src = unsafe { plan.buffer(input) }; - let delay = max_latency.saturating_sub(plan.buffer_latency(input)); - // Safety: this Sum node is the only writer of its delay - // lines during this cycle, and the executor never - // dispatches the same node concurrently. - let line = unsafe { &mut *delays[idx].get() }; - line.process(src, delay, out, idx != 0); - } - plan.set_buffer_latency(*output, max_latency); - (Vec::new(), Vec::new(), false) - } - Op::HwInput { output, .. } => { - // The hardware driver wrote this buffer before the cycle - // started; nothing to do. - plan.set_buffer_latency(*output, 0); - (Vec::new(), Vec::new(), false) - } - Op::IoDelayGenerator { node, output } => { - // Safety: this worker owns the generator output buffer. - let out_buf = unsafe { &mut *plan.buffer_ptr(*output) }; - node.process_generator(out_buf); - plan.set_buffer_latency(*output, 0); - (Vec::new(), Vec::new(), false) - } - Op::IoDelayMeasurement { node, input } => { - // Safety: this worker reads the input after its Sum node completed. - let in_buf = unsafe { plan.buffer(*input) }; - node.process(in_buf); - (Vec::new(), Vec::new(), false) + let (parameter_updates, latency_changed) = Self::with_node_scratch(|scratch| { + match &plan.nodes[node as usize] { + Op::Zero { output } => { + // Safety: this worker executes this node; the plan's + // single-producer-chain invariant guarantees exclusive + // access to the output buffer. + unsafe { &mut *plan.buffer_ptr(*output) }.fill(0.0); + plan.set_buffer_latency(*output, 0); + (Vec::new(), false) + } + Op::Sum { + inputs, + delays, + output, + } => { + // Safety: see `Op::Zero`; additionally, every input buffer's + // producer completed before this node was dispatched. + let out = unsafe { &mut *plan.buffer_ptr(*output) }; + out.fill(0.0); + let max_latency = inputs + .iter() + .map(|&input| plan.buffer_latency(input)) + .max() + .unwrap_or(0); + for (idx, &input) in inputs.iter().enumerate() { + let src = unsafe { plan.buffer(input) }; + let delay = max_latency.saturating_sub(plan.buffer_latency(input)); + // Safety: this Sum node is the only writer of its delay + // lines during this cycle, and the executor never + // dispatches the same node concurrently. + let line = unsafe { &mut *delays[idx].get() }; + line.process(src, delay, out, idx != 0); } - Op::Task { task, ins, outs } => { - let track = match task { - ProcessTask::Track(t) - | ProcessTask::FolderInput(t) - | ProcessTask::FolderOutput(t) => t, - #[cfg(feature = "plugins")] - ProcessTask::Plugin { track, .. } => track, - }; - let mut t = track.lock(); - // The dispatcher may skip `prepare_task_track` entirely - // (generation fast path), so the worker marks the track as - // processing for the whole task; task bodies clear the flag - // at the end. Plugin-mutation handlers rely on this flag to - // reject changes while a task holds the track. - t.audio.set_processing(true); - match task { - ProcessTask::Track(_) => { - let audio_out_count = t.audio.outs.len(); - let metronome_output = - Self::metronome_output_buffer(&plan, &t, outs); - // Safety: track tasks are registered as in-place - // writers for their input buffers. + plan.set_buffer_latency(*output, max_latency); + (Vec::new(), false) + } + Op::HwInput { output, .. } => { + // The hardware driver wrote this buffer before the cycle + // started; nothing to do. + plan.set_buffer_latency(*output, 0); + (Vec::new(), false) + } + Op::IoDelayGenerator { node, output } => { + // Safety: this worker owns the generator output buffer. + let out_buf = unsafe { &mut *plan.buffer_ptr(*output) }; + node.process_generator(out_buf); + plan.set_buffer_latency(*output, 0); + (Vec::new(), false) + } + Op::IoDelayMeasurement { node, input } => { + // Safety: this worker reads the input after its Sum node completed. + let in_buf = unsafe { plan.buffer(*input) }; + node.process(in_buf); + (Vec::new(), false) + } + Op::Task { task, ins, outs } => { + let track = match task { + ProcessTask::Track(t) + | ProcessTask::FolderInput(t) + | ProcessTask::FolderOutput(t) => t, + #[cfg(feature = "plugins")] + ProcessTask::Plugin { track, .. } => track, + }; + let mut t = track.lock(); + // The dispatcher may skip `prepare_task_track` entirely + // (generation fast path), so the worker marks the track as + // processing for the whole task; task bodies clear the flag + // at the end. Plugin-mutation handlers rely on this flag to + // reject changes while a task holds the track. + t.audio.set_processing(true); + match task { + ProcessTask::Track(_) => { + let audio_out_count = t.audio.outs.len(); + let metronome_output = Self::metronome_output_buffer(&plan, &t, outs); + // Safety: track tasks are registered as in-place + // writers for their input buffers. + scratch + .input_ptrs + .extend(ins.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); + // Safety: each pointer came from a task input buffer + // this node owns in-place. + scratch.inputs_mut.extend( scratch .input_ptrs - .extend(ins.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); - // Safety: each pointer came from a task input buffer - // this node owns in-place. - scratch.inputs_mut.extend( - scratch - .input_ptrs - .iter() - .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), - ); - // The track body appends its own inputs and - // inline plugin outputs after processing them. - // Do not borrow arena inputs while inputs_mut - // owns them, or unrelated workers' buffers. - // Keep only input latency metadata here; the - // track replaces the empty slices after its - // in-place input processing has finished. + .iter() + .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), + ); + // The track body appends its own inputs and + // inline plugin outputs after processing them. + // Do not borrow arena inputs while inputs_mut + // owns them, or unrelated workers' buffers. + // Keep only input latency metadata here; the + // track replaces the empty slices after its + // in-place input processing has finished. + scratch + .source_buffers + .extend(t.audio.ins.iter().zip(ins).map(|(port, &buffer)| { + ( + Arc::as_ptr(port) as usize, + &[][..], + plan.buffer_latency(buffer), + ) + })); + // Safety: this worker executes the unique producer + // node for each output buffer. + scratch.output_ptrs.extend( + outs.iter() + .take(audio_out_count) + .map(|&buf| unsafe { plan.buffer_ptr(buf) }), + ); + // Safety: each pointer came from a distinct task + // output buffer owned by this node. + scratch.outputs_mut.extend( scratch - .source_buffers - .extend(t.audio.ins.iter().zip(ins).map(|(port, &buffer)| { - ( - Arc::as_ptr(port) as usize, - &[][..], - plan.buffer_latency(buffer), - ) - })); - // Safety: this worker executes the unique producer - // node for each output buffer. - scratch.output_ptrs.extend( - outs.iter() - .take(audio_out_count) - .map(|&buf| unsafe { plan.buffer_ptr(buf) }), - ); - // Safety: each pointer came from a distinct task - // output buffer owned by this node. - scratch.outputs_mut.extend( - scratch - .output_ptrs - .iter() - .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), - ); - let metronome_output_ptr = metronome_output.map(|buf| { - // Safety: the track task is the registered - // producer of the metronome side-output buffer. - unsafe { plan.buffer_ptr(buf) } - }); - let metronome_output = metronome_output_ptr.map(|ptr| { - // Safety: the side-output buffer is excluded from - // the normal audio output slice above. - unsafe { (&mut *ptr).as_mut_slice() } - }); - t.process_render_block_with_audio_buffers_and_metronome( - &mut scratch.inputs_mut, - &mut scratch.outputs_mut, - &mut scratch.source_buffers, - metronome_output, - ); - #[cfg(feature = "plugins")] - for &out in outs.iter().take(audio_out_count) { - plan.set_buffer_latency(out, t.plugin_graph_latency_samples()); - } + .output_ptrs + .iter() + .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), + ); + let metronome_output_ptr = metronome_output.map(|buf| { + // Safety: the track task is the registered + // producer of the metronome side-output buffer. + unsafe { plan.buffer_ptr(buf) } + }); + let metronome_output = metronome_output_ptr.map(|ptr| { + // Safety: the side-output buffer is excluded from + // the normal audio output slice above. + unsafe { (&mut *ptr).as_mut_slice() } + }); + t.process_render_block_with_audio_buffers_and_metronome( + &mut scratch.inputs_mut, + &mut scratch.outputs_mut, + &mut scratch.source_buffers, + metronome_output, + ); + #[cfg(feature = "plugins")] + for &out in outs.iter().take(audio_out_count) { + plan.set_buffer_latency(out, t.output_latency_from_plan(&plan)); } - ProcessTask::FolderInput(_) => { - let metronome_output = - Self::metronome_output_buffer(&plan, &t, outs); - // Safety: folder-input tasks are registered as - // in-place writers for their input buffers. + } + ProcessTask::FolderInput(_) => { + let metronome_output = Self::metronome_output_buffer(&plan, &t, outs); + // Safety: folder-input tasks are registered as + // in-place writers for their input buffers. + scratch + .input_ptrs + .extend(ins.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); + // Safety: each pointer came from a task input buffer + // this node owns in-place. + scratch.inputs_mut.extend( scratch .input_ptrs - .extend(ins.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); - // Safety: each pointer came from a task input buffer - // this node owns in-place. - scratch.inputs_mut.extend( - scratch - .input_ptrs - .iter() - .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), - ); - let metronome_output_ptr = metronome_output.map(|buf| { - // Safety: the folder-input task is the registered - // producer of the metronome side-output buffer. - unsafe { plan.buffer_ptr(buf) } - }); - let metronome_output = metronome_output_ptr.map(|ptr| { - // Safety: this buffer is a side output, distinct - // from the folder input buffers. - unsafe { (&mut *ptr).as_mut_slice() } - }); - t.process_folder_input_with_audio_buffers_and_metronome( - &mut scratch.inputs_mut, - metronome_output, - ); - for &input in ins { - plan.set_buffer_latency(input, 0); - } - } - ProcessTask::FolderOutput(_) => { - Self::collect_arena_source_slices( - &plan, - &t.internal_audio_sources(), - outs, - &mut scratch.source_buffers, - ); - // Safety: this worker executes the unique producer - // node for each output buffer. - scratch.output_ptrs.extend( - outs.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) }), - ); - // Safety: each pointer came from a distinct task - // output buffer owned by this node. - scratch.outputs_mut.extend( - scratch - .output_ptrs - .iter() - .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), - ); - t.process_folder_output_with_audio_buffers( - &mut scratch.outputs_mut, - &scratch.source_buffers, - ); - #[cfg(feature = "plugins")] - for &out in outs { - plan.set_buffer_latency(out, t.plugin_graph_latency_samples()); - } + .iter() + .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), + ); + let metronome_output_ptr = metronome_output.map(|buf| { + // Safety: the folder-input task is the registered + // producer of the metronome side-output buffer. + unsafe { plan.buffer_ptr(buf) } + }); + let metronome_output = metronome_output_ptr.map(|ptr| { + // Safety: this buffer is a side output, distinct + // from the folder input buffers. + unsafe { (&mut *ptr).as_mut_slice() } + }); + t.process_folder_input_with_audio_buffers_and_metronome( + &mut scratch.inputs_mut, + metronome_output, + ); + for &input in ins { + plan.set_buffer_latency(input, 0); } - #[cfg(feature = "plugins")] - ProcessTask::Plugin { kind, index, .. } => { - let input_latency = ins + } + ProcessTask::FolderOutput(_) => { + Self::collect_arena_source_slices( + &plan, + &t.internal_audio_sources(), + outs, + &mut scratch.source_buffers, + ); + // Safety: this worker executes the unique producer + // node for each output buffer. + scratch + .output_ptrs + .extend(outs.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); + // Safety: each pointer came from a distinct task + // output buffer owned by this node. + scratch.outputs_mut.extend( + scratch + .output_ptrs .iter() - .map(|&input| plan.buffer_latency(input)) - .max() - .unwrap_or(0); - Self::collect_arena_input_slices( - &plan, - ins, - &mut scratch.inputs_shared, - ); - // Safety: this worker executes the unique producer - // node for each output buffer. - scratch.output_ptrs.extend( - outs.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) }), - ); - // Safety: each pointer came from a distinct task - // output buffer owned by this node. - scratch.outputs_mut.extend( - scratch - .output_ptrs - .iter() - .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), - ); - t.process_plugin_with_audio_buffers( - *kind, - *index, - &scratch.inputs_shared, - &mut scratch.outputs_mut, - ); - let latency = input_latency - .saturating_add(t.plugin_latency_samples(*kind, *index)); - for &out in outs { - plan.set_buffer_latency(out, latency); - } + .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), + ); + t.process_folder_output_with_audio_buffers( + &mut scratch.outputs_mut, + &scratch.source_buffers, + ); + #[cfg(feature = "plugins")] + for &out in outs { + plan.set_buffer_latency(out, t.output_latency_from_plan(&plan)); } } - t.audio.set_processing(false); #[cfg(feature = "plugins")] - let latency_changed = t.take_plugin_latency_changed(); - #[cfg(not(feature = "plugins"))] - let latency_changed = false; - let updates = std::mem::take(&mut t.rt.echoed_parameter_updates); - let meter = t.output_meter_linear(); - (meter, updates, latency_changed) + ProcessTask::Plugin { kind, index, .. } => { + let input_latency = ins + .iter() + .map(|&input| plan.buffer_latency(input)) + .max() + .unwrap_or(0); + Self::collect_arena_input_slices( + &plan, + ins, + &mut scratch.inputs_shared, + ); + // Safety: this worker executes the unique producer + // node for each output buffer. + scratch + .output_ptrs + .extend(outs.iter().map(|&buf| unsafe { plan.buffer_ptr(buf) })); + // Safety: each pointer came from a distinct task + // output buffer owned by this node. + scratch.outputs_mut.extend( + scratch + .output_ptrs + .iter() + .map(|&ptr| unsafe { (&mut *ptr).as_mut_slice() }), + ); + t.process_plugin_with_audio_buffers( + *kind, + *index, + &scratch.inputs_shared, + &mut scratch.outputs_mut, + ); + let latency = input_latency + .saturating_add(t.plugin_latency_samples(*kind, *index)); + for &out in outs { + plan.set_buffer_latency(out, latency); + } + } } + t.audio.set_processing(false); + #[cfg(feature = "plugins")] + let latency_changed = t.take_plugin_latency_changed(); + #[cfg(not(feature = "plugins"))] + let latency_changed = false; + let updates = std::mem::take(&mut t.rt.echoed_parameter_updates); + (updates, latency_changed) } - }); + } + }); NodeJobResult { worker_id, epoch, node, - output_linear, parameter_updates, latency_changed, } @@ -1470,7 +1464,6 @@ impl From for Message { worker_id: result.worker_id, epoch: result.epoch, node: result.node, - output_linear: result.output_linear, parameter_updates: result.parameter_updates, latency_changed: result.latency_changed, } @@ -1688,13 +1681,11 @@ mod tests { worker_id, epoch, node, - output_linear, .. } => { assert_eq!(worker_id, 4); assert_eq!(epoch, 1); assert_eq!(node, 0); - assert!(output_linear.is_empty()); } other => panic!("unexpected message: {other:?}"), }