From 245015fd89135eaa0f9b014091e4c8ed5fc0d86c Mon Sep 17 00:00:00 2001 From: Limestudio90 Date: Tue, 13 Oct 2026 14:55:34 +0200 Subject: [PATCH 01/19] VST3 host: IMessage and IAttributeList for plugins (Helix loads its database) `IHostApplication::createInstance` returned nothing, so plugins whose controller and processor exchange `IMessage`s through `IConnectionPoint::notify` could not create one. Line 6 Helix Stadium Native reported "Failed to get content database recovery info (Out of memory condition. [code -2])", loaded no models and exposed no parameters. The host now creates `IMessage` (an id plus its attribute list) and `IAttributeList` (ints, floats, UTF-16 strings and binary blobs, by NUL-terminated attribute id). Strings and blobs are kept in their own allocation so pointers from `getBinary` stay valid while the list holds the value; strings are capped at 1M UTF-16 units and blobs at 256 MiB. Null arguments are refused rather than read. Other classes are still not provided. Verified with Helix Stadium Native 1.03.3a on Windows: the error is gone, its model database and presets load, and its parameters appear in the generic plugin window. A unit test drives the objects through the COM interfaces the way a plugin does. Co-Authored-By: Claude Opus 5.5 --- ROADMAP.md | 1 + crates/vst3-host/src/ffi.rs | 267 +++++++++++++++++++++++++++++++++++- docs/plugin-parity.md | 3 +- 3 files changed, 264 insertions(+), 7 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 73197650..094a9a7d 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -122,6 +122,7 @@ mutated and truncated movies. Field reports from the first public week are track ## Progress log +- **2026-10-13 (VST3 host messages):** The VST3 host creates `IMessage` and `IAttributeList` objects for plugins (`IHostApplication::createInstance`), so plugins whose controller and processor talk through `IConnectionPoint::notify` work: Line 6 Helix Stadium Native now loads its content database (it reported "Failed to get content database recovery info (Out of memory condition)") and exposes its parameters. No readiness percentage change. - **2026-10-13:** `mix.instrument` takes the built-in instrument's parameters in `params` (validated, clamped) and refuses any other field, so a synth setting written beside `plugin` is an error instead of being accepted and ignored (#265) - **2026-10-13:** A bounce of a bus that an aux returns onto lines up with the timeline: the aux insert's lookahead is compensated like the main mix's (it left the bus late and cut the end off), and tracks routed to that bus wait for it too (#246) - **2026-10-13:** Delay compensation covers the inserts of the master faders: a bounce of the main mix with a Maximizer on the master lines up with the same mix without it (it came out 71 samples late) (#351) diff --git a/crates/vst3-host/src/ffi.rs b/crates/vst3-host/src/ffi.rs index d1ddea23..df42934a 100644 --- a/crates/vst3-host/src/ffi.rs +++ b/crates/vst3-host/src/ffi.rs @@ -1,4 +1,4 @@ -//! The FFI boundary: the only module of this crate allowed to use `unsafe`. +//! The FFI boundary: the only module of this rate allowed to use `unsafe`. //! //! It loads VST3 binaries (`libloading`), runs the platform module entry, calls the COM //! interfaces of the factory, component, audio processor and edit controller (`vst3` raw @@ -646,13 +646,32 @@ impl IHostApplicationTrait for HostContext { } } - unsafe fn createInstance(&self, _cid: *mut sb::TUID, _iid: *mut sb::TUID, obj: *mut *mut c_void) -> sb::tresult { - // IMessage / IAttributeList are not provided yet; plugins must cope with that. + /// Creates the objects plugins may ask the host for: `IMessage` (what a controller and its + /// processor send each other through `IConnectionPoint::notify`) and `IAttributeList`. + /// Plugins that talk between their halves this way fail without them (Line 6 Helix + /// reported "Failed to get content database recovery info (Out of memory condition)"). + unsafe fn createInstance(&self, cid: *mut sb::TUID, iid: *mut sb::TUID, obj: *mut *mut c_void) -> sb::tresult { // SAFETY: `obj` is the plugin's out-pointer (or null, handled). - if let Some(o) = unsafe { obj.as_mut() } { - *o = std::ptr::null_mut(); + let Some(out) = (unsafe { obj.as_mut() }) else { return sb::kInvalidArgument }; + *out = std::ptr::null_mut(); + // SAFETY: `cid` and `iid` point to 16-byte TUIDs (or are null, handled). + let (Some(cid), Some(iid)) = (unsafe { cid.as_ref() }, unsafe { iid.as_ref() }) else { return sb::kInvalidArgument }; + let (cid, iid) = (tuid_bytes(cid), tuid_bytes(iid)); + let wants = |class: [u8; 16]| cid == class && (iid == class || iid == FUnknown::IID); + let made = if wants(sv::IMessage::IID) { + ComWrapper::new(HostMessage::default()).to_com_ptr::().map(|p| p.into_raw().cast::()) + } else if wants(sv::IAttributeList::IID) { + ComWrapper::new(HostAttributes::default()).to_com_ptr::().map(|p| p.into_raw().cast::()) + } else { + None + }; + match made { + Some(p) => { + *out = p; + sb::kResultOk + } + None => sb::kResultFalse, } - sb::kResultFalse } } @@ -684,6 +703,191 @@ impl IComponentHandlerTrait for HostContext { } } +/// Longest string attribute kept, in UTF-16 units (longer ones are cut). +const ATTR_STRING_MAX: usize = 1 << 20; +/// Largest binary attribute kept. +const ATTR_BINARY_MAX: usize = 256 << 20; + +/// One `IAttributeList` value. Strings and blobs live in their own allocation, so a pointer +/// handed out by `getBinary` stays valid while the list holds the value. +enum Attr { + Int(i64), + Float(f64), + Str(Box<[u16]>), + Bin(Box<[u8]>), +} + +/// The host's `IAttributeList`: what a plugin puts in an `IMessage`. +#[derive(Default)] +pub(crate) struct HostAttributes { + values: Mutex, Attr>>, +} + +impl Class for HostAttributes { + type Interfaces = (sv::IAttributeList,); +} + +/// An attribute id's bytes (`None` for a null id). +fn attr_key(id: sv::IAttributeList_::AttrID) -> Option> { + // SAFETY: a non-null AttrID is a NUL-terminated C string owned by the caller. + (!id.is_null()).then(|| unsafe { std::ffi::CStr::from_ptr(id) }.to_bytes().to_vec()) +} + +impl HostAttributes { + fn values(&self) -> std::sync::MutexGuard<'_, std::collections::HashMap, Attr>> { + self.values.lock().unwrap_or_else(PoisonError::into_inner) + } + + fn set(&self, id: sv::IAttributeList_::AttrID, v: Attr) -> sb::tresult { + let Some(k) = attr_key(id) else { return sb::kInvalidArgument }; + self.values().insert(k, v); + sb::kResultOk + } +} + +impl sv::IAttributeListTrait for HostAttributes { + unsafe fn setInt(&self, id: sv::IAttributeList_::AttrID, value: sb::int64) -> sb::tresult { + self.set(id, Attr::Int(value)) + } + + unsafe fn getInt(&self, id: sv::IAttributeList_::AttrID, value: *mut sb::int64) -> sb::tresult { + // SAFETY: `value` is the caller's out-pointer (or null, handled). + match ( + attr_key(id).and_then(|k| match self.values().get(&k) { + Some(Attr::Int(v)) => Some(*v), + _ => None, + }), + unsafe { value.as_mut() }, + ) { + (Some(v), Some(out)) => { + *out = v; + sb::kResultOk + } + _ => sb::kResultFalse, + } + } + + unsafe fn setFloat(&self, id: sv::IAttributeList_::AttrID, value: f64) -> sb::tresult { + self.set(id, Attr::Float(value)) + } + + unsafe fn getFloat(&self, id: sv::IAttributeList_::AttrID, value: *mut f64) -> sb::tresult { + // SAFETY: `value` is the caller's out-pointer (or null, handled). + match ( + attr_key(id).and_then(|k| match self.values().get(&k) { + Some(Attr::Float(v)) => Some(*v), + _ => None, + }), + unsafe { value.as_mut() }, + ) { + (Some(v), Some(out)) => { + *out = v; + sb::kResultOk + } + _ => sb::kResultFalse, + } + } + + unsafe fn setString(&self, id: sv::IAttributeList_::AttrID, string: *const sv::TChar) -> sb::tresult { + if string.is_null() { + return sb::kInvalidArgument; + } + let mut s = Vec::new(); + // SAFETY: a non-null string is NUL-terminated UTF-16 owned by the caller; reading stops at + // the NUL or at ATTR_STRING_MAX units. + while s.len() < ATTR_STRING_MAX { + let c = unsafe { *string.add(s.len()) }; + if c == 0 { + break; + } + s.push(c); + } + self.set(id, Attr::Str(s.into_boxed_slice())) + } + + unsafe fn getString(&self, id: sv::IAttributeList_::AttrID, string: *mut sv::TChar, size_in_bytes: sb::uint32) -> sb::tresult { + let units = size_in_bytes as usize / 2; + if string.is_null() || units == 0 { + return sb::kInvalidArgument; + } + let Some(k) = attr_key(id) else { return sb::kInvalidArgument }; + let values = self.values(); + let Some(Attr::Str(s)) = values.get(&k) else { return sb::kResultFalse }; + let n = s.len().min(units - 1); + // SAFETY: the caller's buffer holds `units` UTF-16 units; `n + 1 <= units` are written. + unsafe { + std::ptr::copy_nonoverlapping(s.as_ptr(), string, n); + *string.add(n) = 0; + } + sb::kResultOk + } + + unsafe fn setBinary(&self, id: sv::IAttributeList_::AttrID, data: *const c_void, size_in_bytes: sb::uint32) -> sb::tresult { + let n = size_in_bytes as usize; + if n > ATTR_BINARY_MAX { + return sb::kOutOfMemory; + } + let bytes: Box<[u8]> = if n == 0 || data.is_null() { + Box::new([]) + } else { + // SAFETY: the caller's `data` holds `n` readable bytes. + unsafe { std::slice::from_raw_parts(data.cast::(), n) }.into() + }; + self.set(id, Attr::Bin(bytes)) + } + + unsafe fn getBinary(&self, id: sv::IAttributeList_::AttrID, data: *mut *const c_void, size_in_bytes: *mut sb::uint32) -> sb::tresult { + let Some(k) = attr_key(id) else { return sb::kInvalidArgument }; + let values = self.values(); + let Some(Attr::Bin(b)) = values.get(&k) else { return sb::kResultFalse }; + // SAFETY: both are the caller's out-pointers (or null, handled). The pointer handed out + // stays valid until this attribute is replaced or the list is released (VST3 contract). + match (unsafe { data.as_mut() }, unsafe { size_in_bytes.as_mut() }) { + (Some(d), Some(sz)) => { + *d = b.as_ptr().cast::(); + *sz = u32::try_from(b.len()).unwrap_or(u32::MAX); + sb::kResultOk + } + _ => sb::kInvalidArgument, + } + } +} + +/// The host's `IMessage`: an id and an attribute list, created for a plugin through +/// `IHostApplication::createInstance`. +pub(crate) struct HostMessage { + id: Mutex, + attributes: ComWrapper, +} + +impl Default for HostMessage { + fn default() -> Self { + HostMessage { id: Mutex::new(std::ffi::CString::default()), attributes: ComWrapper::new(HostAttributes::default()) } + } +} + +impl Class for HostMessage { + type Interfaces = (sv::IMessage,); +} + +impl sv::IMessageTrait for HostMessage { + unsafe fn getMessageID(&self) -> sb::FIDString { + // The string's buffer lives until the next `setMessageID`, as the interface expects. + self.id.lock().unwrap_or_else(PoisonError::into_inner).as_ptr() + } + + unsafe fn setMessageID(&self, id: sb::FIDString) { + // SAFETY: a non-null id is a NUL-terminated C string owned by the caller. + let s = if id.is_null() { std::ffi::CString::default() } else { unsafe { std::ffi::CStr::from_ptr(id) }.to_owned() }; + *self.id.lock().unwrap_or_else(PoisonError::into_inner) = s; + } + + unsafe fn getAttributes(&self) -> *mut sv::IAttributeList { + // Not add-ref'ed: the list belongs to the message (VST3 contract). + self.attributes.as_com_ref::().map_or(std::ptr::null_mut(), |r| r.as_ptr()) + } +} + /// One parameter's points for one block. SoundCraft sends at most one point per block; a /// plugin writing output changes may add more, of which only the last is kept. #[derive(Default)] @@ -2137,6 +2341,57 @@ mod window { #[cfg(test)] mod tests { use super::*; + use sv::{IAttributeListTrait as _, IMessageTrait as _}; + + fn tuid(iid: [u8; 16]) -> sb::TUID { + iid.map(|b| b as c_char) + } + + /// Asks the host for an object the way a plugin does. + fn create(host: &ComWrapper, cid: [u8; 16]) -> Option> { + let app = host.to_com_ptr::()?; + let (mut c, mut i) = (tuid(cid), tuid(I::IID)); + let mut obj: *mut c_void = std::ptr::null_mut(); + // SAFETY: valid TUIDs and out-pointer, as a plugin passes them. + let r = unsafe { app.createInstance(&mut c, &mut i, &mut obj) }; + // SAFETY: on success `obj` is an owned (add-ref'ed) pointer to `I`. + (r == sb::kResultOk).then(|| unsafe { ComPtr::from_raw(obj.cast::()) }).flatten() + } + + #[test] + fn plugins_get_messages_and_attribute_lists_from_the_host() { + let host = ComWrapper::new(HostContext::default()); + let msg = create::(&host, sv::IMessage::IID).expect("IMessage"); + // SAFETY: calls through the interface with valid C strings and buffers. + unsafe { + msg.setMessageID(c"DatabaseInfo".as_ptr()); + assert_eq!(std::ffi::CStr::from_ptr(msg.getMessageID()).to_str(), Ok("DatabaseInfo")); + let attrs = vst3::ComRef::from_raw(msg.getAttributes()).expect("attributes"); + assert_eq!(attrs.setInt(c"count".as_ptr(), 42), sb::kResultOk); + assert_eq!(attrs.setFloat(c"gain".as_ptr(), 0.5), sb::kResultOk); + let text: Vec = "Helix".encode_utf16().chain([0]).collect(); + assert_eq!(attrs.setString(c"name".as_ptr(), text.as_ptr()), sb::kResultOk); + assert_eq!(attrs.setBinary(c"blob".as_ptr(), [1u8, 2, 3].as_ptr().cast(), 3), sb::kResultOk); + + let (mut i, mut f) = (0i64, 0f64); + assert_eq!(attrs.getInt(c"count".as_ptr(), &mut i), sb::kResultOk); + assert_eq!(attrs.getFloat(c"gain".as_ptr(), &mut f), sb::kResultOk); + assert_eq!((i, f), (42, 0.5)); + assert_eq!(attrs.getInt(c"gain".as_ptr(), &mut i), sb::kResultFalse, "a float is not an int"); + assert_eq!(attrs.getInt(c"missing".as_ptr(), &mut i), sb::kResultFalse); + // A buffer of 4 units takes 3 characters and the NUL. + let mut buf = [0xFFFFu16; 4]; + assert_eq!(attrs.getString(c"name".as_ptr(), buf.as_mut_ptr(), 8), sb::kResultOk); + assert_eq!(buf, ['H' as u16, 'e' as u16, 'l' as u16, 0]); + let (mut p, mut n): (*const c_void, u32) = (std::ptr::null(), 0); + assert_eq!(attrs.getBinary(c"blob".as_ptr(), &mut p, &mut n), sb::kResultOk); + assert_eq!(std::slice::from_raw_parts(p.cast::(), n as usize), [1, 2, 3]); + assert_eq!(attrs.setInt(std::ptr::null(), 1), sb::kInvalidArgument, "a null id is refused"); + } + assert!(create::(&host, sv::IAttributeList::IID).is_some()); + // Anything else is still not provided. + assert!(create::(&host, sv::IComponentHandler::IID).is_none()); + } #[test] fn the_transport_fills_the_process_context() { diff --git a/docs/plugin-parity.md b/docs/plugin-parity.md index 9280d921..97532447 100644 --- a/docs/plugin-parity.md +++ b/docs/plugin-parity.md @@ -1,6 +1,6 @@ # Plugin parity: built-in processors and plugin hosting -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** trivial (mix.instrument sets built-in instrument parameters in params (#265); previously minor: plugin editors on Windows) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (VST3 host messages: IMessage and IAttributeList; previously minor: plugin editors on Windows) · **Target:** Avid Pro Tools Ultimate 2026.4.1 Pro Tools users live in plugins: the bundled set covers everyday mixing, and third-party plugins cover the rest. This doc tracks both. Our plugins have our own names and are written from @@ -58,6 +58,7 @@ User report #152: a saved instrument level does not reach the bounce. | Date | Change | Summary | |---|---|---| +| 2026-10-13 | minor | VST3 host: IMessage and IAttributeList for plugins whose halves talk through messages (Line 6 Helix Stadium Native verified) | | 2026-10-13 | trivial | mix.instrument sets built-in instrument parameters in params (#265) | | 2026-10-12 | minor | Editors: VST3 and embedded CLAP editors on Windows | | 2026-10-10 | major | Created: built-in processor inventory by category and third-party hosting checklist | From d13f6657f8843c03dd1bb952ff2933f202093e4b Mon Sep 17 00:00:00 2001 From: MarekSpodBiedry <73122968+MarekSpodBiedry@users.noreply.github.com> Date: Tue, 13 Oct 2026 17:50:33 +0200 Subject: [PATCH 02/19] Keep MIDI note selection valid across clip, session and note-order changes (#443) --- crates/engine/src/cmd/midi.rs | 27 +++++++++++++++++- crates/ui-egui/src/lib.rs | 15 ++++++++++ crates/ui-egui/src/midi_editor.rs | 36 ++++++++++++++++++++++-- crates/ui-egui/tests/pro_tools_keys.rs | 38 ++++++++++++++++++++++++++ 4 files changed, 113 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/midi.rs b/crates/engine/src/cmd/midi.rs index 10bcd767..05f6b6ac 100644 --- a/crates/engine/src/cmd/midi.rs +++ b/crates/engine/src/cmd/midi.rs @@ -130,8 +130,19 @@ fn notes_move(e: &mut Engine, p: &Value) -> Result { n.pitch = (i64::from(n.pitch) + ds).clamp(0, 127) as u8; } } + let moved: Vec = seq.notes.iter().enumerate().filter(|(i, _)| idx.contains(i)).map(|(_, n)| *n).collect(); seq.sort(); - Ok(json!({"moved": idx.len()})) + // Where the moved notes ended up after sorting, so the editor can keep them selected. + let mut taken = vec![false; seq.notes.len()]; + let mut indices = Vec::with_capacity(moved.len()); + for m in &moved { + if let Some(j) = seq.notes.iter().enumerate().position(|(j, n)| !taken[j] && n == m) { + taken[j] = true; + indices.push(j); + } + } + indices.sort_unstable(); + Ok(json!({"moved": idx.len(), "indices": indices})) } #[cfg(test)] @@ -157,6 +168,20 @@ mod tests { assert!(e.execute("midi.note_edit", &json!({"clip": clip, "index": 99})).is_err()); } + #[test] + fn notes_move_reports_where_the_moved_notes_went() { + let mut e = Engine::default(); + let t = e.session_mut().add_track(TrackKind::Instrument, ChannelFormat::Stereo, Some("Keys")); + let clip = e.execute("midi.new_clip", &json!({"track": t.0})).unwrap()["clip"].as_u64().unwrap(); + for start in [0, 480, 960] { + e.execute("midi.note_add", &json!({"clip": clip, "pitch": 60, "start_ticks": start})).unwrap(); + } + let r = e.execute("midi.notes_move", &json!({"clip": clip, "indices": [0], "ticks": 720})).unwrap(); + assert_eq!(r["indices"], json!([1])); + let notes = e.execute("midi.notes", &json!({"clip": clip})).unwrap(); + assert_eq!(notes["notes"][1]["start"], 720); + } + #[test] fn rejects_audio_tracks() { let mut e = Engine::default(); diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index ddd54275..87938518 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -425,6 +425,10 @@ impl SoundApp { let replacing = matches!(id, "session.new" | "session.open" | "session.close" | "session.revert"); match self.engine.execute(id, ¶ms) { Ok(v) => { + if replacing { + // Note indices and gestures belong to the old session's clips. + self.midi = midi_editor::MidiEditorState::default(); + } if replacing || (id.starts_with("session.save") && !self.engine.is_dirty()) { self.release_autosave(false); } @@ -1344,6 +1348,17 @@ mod tests { assert_eq!(super::failed_plugin_status(&s, t, soundcraft_mix::INSTRUMENT_SLOT), None); } + #[test] + fn replacing_the_session_drops_the_midi_note_selection() { + for command in ["session.new", "session.close"] { + let mut app = SoundApp::new(soundcraft_engine::demo::demo_engine(), None, Services::default()); + app.midi.selected = vec![0, 1]; + app.midi.clip = Some(soundcraft_model::ClipId(1)); + app.run(command, json!({})).unwrap(); + assert!(app.midi.selected.is_empty() && app.midi.clip.is_none(), "{command}"); + } + } + #[test] fn new_session_cancels_play_queued_before_the_next_frame() { let mut app = SoundApp::new(soundcraft_engine::demo::demo_engine(), None, Services::default()); diff --git a/crates/ui-egui/src/midi_editor.rs b/crates/ui-egui/src/midi_editor.rs index 8ea18699..dbd6f6d2 100644 --- a/crates/ui-egui/src/midi_editor.rs +++ b/crates/ui-egui/src/midi_editor.rs @@ -21,6 +21,19 @@ pub struct MidiEditorState { pub band: Option, } +impl MidiEditorState { + /// Start editing `id`. Note indices only mean something inside one clip, so the selection and + /// any gesture in progress are dropped when the clip changes. + fn switch_clip(&mut self, id: ClipId) { + if self.clip != Some(id) { + self.selected.clear(); + self.drag = None; + self.band = None; + } + self.clip = Some(id); + } +} + #[derive(Debug, Clone)] pub struct NoteDrag { pub index: usize, @@ -148,7 +161,7 @@ pub fn show(app: &mut SoundApp, ui: &mut Ui) { let hi = sequence.notes.iter().map(|n| i32::from(n.pitch)).max().unwrap_or(72); let lo = sequence.notes.iter().map(|n| i32::from(n.pitch)).min().unwrap_or(48); app.midi.scroll = (127 - (hi + lo) / 2 - rows / 2) as f32 * ROW_H; - app.midi.clip = Some(cid); + app.midi.switch_clip(cid); } if ui.rect_contains_pointer(roll) { app.midi.scroll -= ui.input(|i| i.smooth_scroll_delta.y); @@ -346,7 +359,10 @@ pub fn show(app: &mut SoundApp, ui: &mut Ui) { 0 }; if (semi != 0 || ticks != 0) && !app.midi.selected.is_empty() { - let _ = app.run("midi.notes_move", json!({"clip": cid.0, "indices": app.midi.selected, "ticks": ticks, "semitones": semi})); + let moved = app.run("midi.notes_move", json!({"clip": cid.0, "indices": app.midi.selected, "ticks": ticks, "semitones": semi})); + // The engine re-sorts the notes: follow the moved ones to their new indices, so the + // selection never points at other notes and the arrows can keep nudging it. + app.midi.selected = moved.ok().and_then(|v| serde_json::from_value(v["indices"].clone()).ok()).unwrap_or_default(); } } if !app.midi.selected.is_empty() @@ -376,3 +392,19 @@ pub fn show(app: &mut SoundApp, ui: &mut Ui) { let _ = app.engine.execute_merged("midi.note_edit", &json!({"clip": cid.0, "index": i, "velocity": v}), &format!("vel:{}", cid.0)); } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn switching_clip_drops_selection_and_gestures() { + let mut st = MidiEditorState { selected: vec![0, 2], clip: Some(ClipId(1)), band: Some(pos2(1.0, 2.0)), ..Default::default() }; + st.switch_clip(ClipId(1)); + assert_eq!(st.selected, vec![0, 2]); + st.switch_clip(ClipId(2)); + assert!(st.selected.is_empty()); + assert!(st.drag.is_none() && st.band.is_none()); + assert_eq!(st.clip, Some(ClipId(2))); + } +} diff --git a/crates/ui-egui/tests/pro_tools_keys.rs b/crates/ui-egui/tests/pro_tools_keys.rs index c87ede65..97952c1e 100644 --- a/crates/ui-egui/tests/pro_tools_keys.rs +++ b/crates/ui-egui/tests/pro_tools_keys.rs @@ -233,6 +233,44 @@ fn the_piano_roll_leaves_modified_arrows_to_the_shortcuts() { assert_eq!(pitch(&app), before + 1); } +#[test] +fn the_piano_roll_selection_follows_notes_the_arrows_move_past_others() { + let mut app = SoundApp::new(soundcraft_engine::demo::demo_engine(), None, Services::default()); + app.ui.show_midi_editor = true; + app.run("edit.select", json!({"tracks": ["Keys"]})).unwrap(); + let ctx = egui::Context::default(); + let frame = |app: &mut SoundApp, events: Vec| { + let raw = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0))), events, ..Default::default() }; + ctx.run_ui(raw, |ui| { + app.logic(ui.ctx()); + app.ui(ui); + }) + .textures_delta + .clear(); + }; + for _ in 0..6 { + frame(&mut app, vec![]); + } + let body = ctx.data(|d| d.get_temp::(egui::Id::new("soundcraft-midi-body"))).unwrap(); + frame(&mut app, vec![Event::PointerMoved(body.center())]); + let notes = |app: &SoundApp| { + let clip = soundcraft_ui_egui::midi_editor::target_clip(app).unwrap(); + match &app.engine.session().find_clip(clip).unwrap().1.content { + ClipContent::Midi { sequence } => sequence.notes.clone(), + _ => panic!("not a MIDI clip"), + } + }; + // The first chord's lowest note, an octave up, sorts after the other chord notes. + let first = notes(&app)[0]; + app.midi.selected = vec![0]; + for octaves in 1..=2u8 { + frame(&mut app, keys(Key::ArrowUp, Modifiers::SHIFT)); + let &[i] = app.midi.selected.as_slice() else { panic!("selection {:?}", app.midi.selected) }; + assert_ne!(i, 0); + assert_eq!((notes(&app)[i].start, notes(&app)[i].pitch), (first.start, first.pitch + 12 * octaves)); + } +} + #[test] fn shift_tab_extends_the_selection_and_tab_to_transient_stops_on_hits() { for (os, cmd) in OSES { From 2dd8f7da55c8ed919117b24dc309b4381b362e5e Mon Sep 17 00:00:00 2001 From: Billy Coleman III Date: Tue, 13 Oct 2026 13:39:46 -0400 Subject: [PATCH 03/19] Preserve exact channel formats when committing tracks Retain the source ChannelFormat for committed audio tracks and reject unsupported widths, overflowing ranges and incomplete renders before replacing selected tracks. Preserve current routing and rollback behavior and document the existing renderer limits with multichannel coverage. --- contributors/people.toml | 3 + crates/engine/src/io.rs | 23 ++- crates/engine/tests/commit_multichannel.rs | 160 +++++++++++++++++++++ docs/commit-multichannel.md | 41 ++++++ 4 files changed, 223 insertions(+), 4 deletions(-) create mode 100644 crates/engine/tests/commit_multichannel.rs create mode 100644 docs/commit-multichannel.md diff --git a/contributors/people.toml b/contributors/people.toml index 1c344199..f67fdd57 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -50,3 +50,6 @@ sync_github_name = false [people.Momentum96] sync_github_name = true + +[people.ProdByBuddha] +sync_github_name = true diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index 7b26e0b1..49d325c7 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -801,12 +801,27 @@ pub fn commit_track(e: &mut Engine, t: TrackId) -> Result> { if end <= 0 { return Ok(None); } - let range = Range::new(0, end + s.sample_rate.samples(2.0)); - // The track renders through a main mix of at least two channels. - refuse_longer(s, "track.commit", &tr.name, "commit", range.len(), render_limit(tr.channels().max(2)))?; + let fmt = tr.format; + if fmt.channels() > soundcraft_mix::MAX_CHANNELS { + return Err(EngineError::BadParams( + "track.commit".into(), + format!("track commit supports at most {} channels; cannot render {}", soundcraft_mix::MAX_CHANNELS, fmt.label()), + )); + } + let too_long = || EngineError::BadParams("track.commit".into(), format!("`{}` is too long to commit within the offline render limit", tr.name)); + let end = end.checked_add(s.sample_rate.samples(2.0)).ok_or_else(too_long)?; + let frames = usize::try_from(end).map_err(|_| too_long())?; + // The shared renderer uses a stereo main mix for mono, then folds it back to mono. + // Reject requests it would truncate before rendering or replacing the source track. + if frames > soundcraft_mix::MAX_RENDER_SAMPLES / fmt.channels().max(2) { + return Err(too_long()); + } + let range = Range::new(0, end); let audio = soundcraft_mix::render_track_pre_fader(s, t, range); + if audio.len() != fmt.channels() || audio.iter().any(|channel| channel.len() != frames) { + return Err(EngineError::Io("track commit did not render the complete channel format and range".into())); + } let name = format!("{}.cm", tr.name); - let fmt = ChannelFormat::for_channels(audio.len().clamp(1, 2)); let mixer = tr.mixer.clone(); let buf = AudioBuffer { sample_rate: s.sample_rate.hz(), channels: audio }; let s = e.session_mut(); diff --git a/crates/engine/tests/commit_multichannel.rs b/crates/engine/tests/commit_multichannel.rs new file mode 100644 index 00000000..e2900a48 --- /dev/null +++ b/crates/engine/tests/commit_multichannel.rs @@ -0,0 +1,160 @@ +use serde_json::json; +use soundcraft_audio_io::{AudioBuffer, BitDepth, EncodeOptions, FileFormat}; +use soundcraft_engine::{Engine, io}; +use soundcraft_model::{ChannelFormat, Clip, ClipContent, Insert, Route, SendSlot, Session, TrackId, TrackKind}; +use soundcraft_time::{Range, SampleRate}; +use std::sync::Arc; + +const SIGNAL_FRAMES: usize = 128; + +fn fixture(format: ChannelFormat) -> (Engine, TrackId, Vec>) { + let mut session = Session::new("Commit layout", SampleRate::new(8_000).unwrap()); + session.outputs[0].format = format; + let track = session.add_track(TrackKind::Audio, format, Some("Distinct channels")); + // Each channel has a different bipolar waveform: swapping, summing or dropping channels + // cannot pass a width-only assertion or an identical-signal comparison. + let channels: Vec> = (0..format.channels()) + .map(|ch| (0..SIGNAL_FRAMES).map(|frame| (((frame * (ch + 3)) % 31) as f32 - 15.0) * (ch + 1) as f32 / 3_200.0).collect()) + .collect(); + let source = + io::add_source(&mut session, "Distinct channels", AudioBuffer { sample_rate: 8_000, channels: channels.clone() }, None, FileFormat::Wav); + let clip = session.new_clip_id(); + let tr = session.track_mut(track).unwrap(); + tr.playlist_mut().unwrap().clips.push(Clip::audio(clip, "Signal", source, 0, 0, SIGNAL_FRAMES as i64)); + tr.mixer.inserts[0] = Some(Insert::new("invert")); + session.edit.selected_tracks = vec![track]; + (Engine::new(session), track, channels) +} + +fn commit(e: &mut Engine, track: TrackId) -> TrackId { + TrackId(e.execute("track.commit", &json!({"tracks": [track.0]})).unwrap()["tracks"][0].as_u64().unwrap()) +} + +fn committed_audio(e: &Engine, track: TrackId) -> &AudioBuffer { + let ClipContent::Audio { source, .. } = e.session().track(track).unwrap().clips()[0].content else { panic!("commit must create audio") }; + &e.session().pool.get(source).unwrap().buffer +} + +fn assert_audio_eq(actual: &[Vec], expected: &[Vec]) { + assert_eq!(actual.len(), expected.len()); + for (ch, (actual, expected)) in actual.iter().zip(expected).enumerate() { + assert_eq!(actual.len(), expected.len(), "channel {ch} length"); + for (frame, (actual, expected)) in actual.iter().zip(expected).enumerate() { + assert!((actual - expected).abs() < 1e-6, "channel {ch}, frame {frame}: {actual} != {expected}"); + } + } +} + +#[test] +fn commit_keeps_every_renderable_exact_format_and_processed_channel_order() { + for format in ChannelFormat::ALL.into_iter().filter(|format| format.channels() <= soundcraft_mix::MAX_CHANNELS) { + let (mut e, track, signal) = fixture(format); + let committed = commit(&mut e, track); + assert_eq!(e.session().track(committed).unwrap().format, format, "{}", format.label()); + let audio = committed_audio(&e, committed); + assert_eq!(audio.num_channels(), format.channels(), "{}", format.label()); + assert_eq!(audio.frames(), SIGNAL_FRAMES + 16_000); + // Existing mono rendering uses a -3 dB center pan followed by SQRT_2 compensation. + // Model that small baseline gain explicitly, retaining the same strict signal tolerance. + let gain = if format == ChannelFormat::Mono { 10.0_f32.powf(-3.0 / 20.0) * std::f32::consts::SQRT_2 } else { 1.0 }; + let expected: Vec> = signal.iter().map(|ch| ch.iter().map(|sample| -sample * gain).collect()).collect(); + let head: Vec> = audio.channels.iter().map(|ch| ch[..SIGNAL_FRAMES].to_vec()).collect(); + assert_audio_eq(&head, &expected); + assert!(audio.channels.iter().all(|ch| ch[SIGNAL_FRAMES..].iter().all(|sample| sample.abs() < 1e-6))); + assert!(e.session().track(track).unwrap().inactive && e.session().track(track).unwrap().hidden); + assert_eq!(e.session().track_index(committed), e.session().track_index(track).map(|index| index + 1)); + } +} + +#[test] +fn commit_preserves_bus_and_send_audio_after_undo_reopen_and_wav_export() { + for format in [ChannelFormat::Surround60, ChannelFormat::Atmos504, ChannelFormat::Ambisonics(1)] { + let (mut e, track, _) = fixture(format); + let s = e.session_mut(); + let bus = s.add_bus("Same-layout bus", format); + let aux = s.add_track(TrackKind::Aux, format, Some("Bus return")); + s.track_mut(aux).unwrap().mixer.input = Route::Bus(bus); + let tr = s.track_mut(track).unwrap(); + tr.mixer.output = Route::Bus(bus); + tr.mixer.volume_db = -4.5; + let mut send = SendSlot::new(Route::Main); + send.level_db = -9.0; + tr.mixer.sends[0] = Some(send); + let mixer = tr.mixer.clone(); + let range = Range::new(0, SIGNAL_FRAMES as i64); + let before = soundcraft_mix::render_range(e.session(), range, 64); + let committed = commit(&mut e, track); + let tr = e.session().track(committed).unwrap(); + assert_eq!(tr.mixer.output, mixer.output); + assert_eq!(tr.mixer.sends, mixer.sends); + assert_eq!(tr.mixer.volume_db, mixer.volume_db); + assert!(tr.mixer.inserts.iter().all(Option::is_none), "processing is baked once"); + assert_audio_eq(&soundcraft_mix::render_range(e.session(), range, 64), &before); + assert!(e.undo()); + assert!(e.session().track(committed).is_none()); + assert!(!e.session().track(track).unwrap().inactive); + assert_audio_eq(&soundcraft_mix::render_range(e.session(), range, 64), &before); + assert!(e.redo()); + + let dir = std::env::temp_dir().join(format!("soundcraft-commit-layout-{}-{}", std::process::id(), format.channels())); + let _ = std::fs::remove_dir_all(&dir); + let path = dir.join("Commit.scraft").to_string_lossy().into_owned(); + io::save_session(&mut e, &path).unwrap(); + let mut reopened = Engine::default(); + assert!(io::open_session(&mut reopened, &path).unwrap().is_empty()); + assert_eq!(reopened.session().track(committed).unwrap().format, format); + assert_audio_eq(&committed_audio(&reopened, committed).channels, &committed_audio(&e, committed).channels); + assert_audio_eq(&soundcraft_mix::render_range(reopened.session(), range, 64), &before); + + let opts = EncodeOptions { format: FileFormat::Wav, bit_depth: BitDepth::Float32, dither: false, bwf: None }; + let wav_path = dir.join("mix.wav"); + io::Bounce::new(reopened.session_arc(), &wav_path, range, &opts, None, false, false).unwrap().run().unwrap(); + let wav = std::fs::read(&wav_path).unwrap(); + let (_, decoded) = soundcraft_audio_io::decode(&wav, Some("wav")).unwrap(); + assert_audio_eq(&decoded.channels, &before); + // The WAV extensible mask must describe this layout, not another layout of equal width. + let fmt_at = wav.windows(4).position(|tag| tag == b"fmt ").unwrap(); + let mask = u32::from_le_bytes(wav[fmt_at + 28..fmt_at + 32].try_into().unwrap()); + assert_eq!(mask, format.channel_mask()); + std::fs::remove_dir_all(&dir).unwrap(); + } +} + +#[test] +fn oversized_or_overflowing_commit_rolls_back_all_selected_tracks() { + for (format, length) in [ + (ChannelFormat::Mono, (soundcraft_mix::MAX_RENDER_SAMPLES / 2 + 1) as i64), + (ChannelFormat::Surround51, (soundcraft_mix::MAX_RENDER_SAMPLES / 6 + 1) as i64), + (ChannelFormat::Ambisonics(3), (soundcraft_mix::MAX_RENDER_SAMPLES / 16 + 1) as i64), + (ChannelFormat::Surround51, i64::MAX), + ] { + let (mut e, first, _) = fixture(format); + let s = e.session_mut(); + let second = s.add_track(TrackKind::Audio, format, Some("Too long")); + let mut clip = s.track(first).unwrap().clips()[0].clone(); + clip.id = s.new_clip_id(); + clip.length = length; + s.track_mut(second).unwrap().playlist_mut().unwrap().clips.push(clip); + let before = e.session_arc(); + let dirty = e.is_dirty(); + let result = e.execute("track.commit", &json!({"tracks": [first.0, second.0]})); + assert!(result.unwrap_err().to_string().contains("offline render limit")); + assert!(Arc::ptr_eq(&before, &e.session_arc()), "no hidden track, truncated source or partially committed first track"); + assert_eq!(e.is_dirty(), dirty); + assert!(!e.can_undo(), "failed commit must not add an undo step"); + } +} + +#[test] +fn commit_rejects_formats_wider_than_the_renderer_without_replacing_tracks() { + for format in ChannelFormat::ALL.into_iter().filter(|format| format.channels() > soundcraft_mix::MAX_CHANNELS) { + let (mut e, track, _) = fixture(format); + let before = e.session_arc(); + let result = e.execute("track.commit", &json!({"tracks": [track.0]})); + assert!(result.unwrap_err().to_string().contains("at most 16 channels")); + assert!(Arc::ptr_eq(&before, &e.session_arc())); + assert!(!e.session().track(track).unwrap().inactive); + assert!(!e.session().track(track).unwrap().hidden); + assert!(!e.can_undo()); + } +} diff --git a/docs/commit-multichannel.md b/docs/commit-multichannel.md new file mode 100644 index 00000000..57874a03 --- /dev/null +++ b/docs/commit-multichannel.md @@ -0,0 +1,41 @@ +# Track Commit channel-format integrity + +**Last reviewed:** 2026-10-13 · **Last updated:** 2026-10-13 + +Track Commit retains the source track's exact `ChannelFormat`, including surround, height and +ambisonic layouts. Channel count alone cannot identify a layout: 5.1 and 6.0 both have six +channels, while Quad, LCRS and first-order ambisonics all have four. + +The shared pre-fader renderer already returns multichannel audio in the track's own layout. +Commit copies that format to the new audio track and checks the returned channel count and +frame count before adding the source or hiding the original track. Formats wider than the +renderer’s 16-channel limit are rejected before rendering. The fixed two-second tail uses +checked arithmetic; overflowing ranges or requests beyond the renderer’s sample limit return +an error. A command committing several tracks rolls back all of them if any selected track +fails. Current routing and mixer inheritance remain unchanged. + +The regression fixtures use distinct bipolar signals on each channel across all 30 declared +formats within the 16-channel limit, with an insert applied before committing. The four higher +ambisonic orders are rejected without replacing the source track. Additional cases check +bus/send routing, undo/redo, session save/reopen and float WAV export, including its output +speaker mask. + +Mono uses a two-channel frame limit because the existing renderer temporarily targets stereo +before folding back to mono. This frame limit does not bound total process memory. The shared +mono renderer’s -3 dB center-pan gain followed by `SQRT_2` compensation produces approximately ++0.0103 dB gain; the signal fixture accounts for that existing processing behavior. + +Session track metadata retains the exact layout. Generic source WAV saving still infers its +channel mask from channel count. This change preserves the shared renderer, the fixed tail +and the existing commit options. + +Implementation: `crates/engine/src/io.rs::commit_track` and +`crates/mix/src/lib.rs::render_track_pre_fader`. Regression fixtures: +`crates/engine/tests/commit_multichannel.rs`. + +## Revision history + +| Date | Change | +|---|---| +| 2026-10-13 | Refresh against current main; document source-supported format checks, existing renderer limits and regression fixtures. | +| 2026-10-12 | Preserve exact committed formats and reject incomplete or unsupported-width renders; add channel-signal, routing, persistence/export and rollback coverage. | From 28c936a256f43e354a334bd9e90d2d8259f6e4bb Mon Sep 17 00:00:00 2001 From: Billy Coleman III Date: Tue, 13 Oct 2026 20:42:34 -0400 Subject: [PATCH 04/19] Prevent track-name collisions after truncation Validate the trimmed 64-scalar stored track name before mutating the document, return that exact name, and preserve no-op document state. Retain routing-folder bus naming and repair with unique bus names, stable routes and undo/redo coverage. --- contributors/people.toml | 3 + crates/engine/src/cmd/track.rs | 15 +- crates/engine/tests/track_name_collisions.rs | 173 +++++++++++++++++++ 3 files changed, 189 insertions(+), 2 deletions(-) create mode 100644 crates/engine/tests/track_name_collisions.rs diff --git a/contributors/people.toml b/contributors/people.toml index 1c344199..f67fdd57 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -50,3 +50,6 @@ sync_github_name = false [people.Momentum96] sync_github_name = true + +[people.ProdByBuddha] +sync_github_name = true diff --git a/crates/engine/src/cmd/track.rs b/crates/engine/src/cmd/track.rs index 87912389..6f585dcf 100644 --- a/crates/engine/src/cmd/track.rs +++ b/crates/engine/src/cmd/track.rs @@ -613,15 +613,26 @@ fn delete(e: &mut Engine, p: &Value) -> Result { fn rename(e: &mut Engine, p: &Value) -> Result { let t = track_param(e, "track.rename", p, "track")?.ok_or_else(|| bad("track.rename", "`track` required"))?; let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad("track.rename", "`name` required"))?; - let s = e.session_mut(); + // Validate the stored name, including its existing 64-character limit. + let name: String = name.chars().take(64).collect(); + let s = e.session(); if s.tracks.iter().any(|x| x.name == name && x.id != t) { return Err(bad("track.rename", format!("a track named `{name}` already exists"))); } - let name: String = name.chars().take(64).collect(); let bus = s.track(t).and_then(|track| match (track.kind, &track.mixer.input) { (TrackKind::Folder, Route::Bus(bus)) => Some(*bus), _ => None, }); + let track = s.track(t).ok_or_else(|| bad("track.rename", "unknown track"))?; + if track.name == name + && bus.is_none_or(|id| { + let expected = unique_folder_bus_name(s, &format!("{name} Bus"), Some(id)); + s.bus(id).is_none_or(|bus| bus.name == expected) + }) + { + return Ok(json!({"name": name})); + } + let s = e.session_mut(); if let Some(track) = s.track_mut(t) { track.name.clone_from(&name); } diff --git a/crates/engine/tests/track_name_collisions.rs b/crates/engine/tests/track_name_collisions.rs new file mode 100644 index 00000000..cff5b277 --- /dev/null +++ b/crates/engine/tests/track_name_collisions.rs @@ -0,0 +1,173 @@ +use serde_json::json; +use soundcraft_engine::Engine; +use soundcraft_model::{ChannelFormat, Session, TrackKind}; +use std::sync::Arc; + +#[test] +fn truncated_ascii_and_unicode_names_cannot_collide_with_another_track() { + for character in ['A', '界'] { + let existing: String = std::iter::repeat_n(character, 64).collect(); + let mut session = Session::default(); + let occupied = session.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some(&existing)); + let target = session.add_track(TrackKind::Aux, ChannelFormat::Mono, Some("Target")); + let mut engine = Engine::new(session); + let before = engine.session_arc(); + let revision = engine.revision; + + let result = engine.execute("track.rename", &json!({"track": target.0, "name": format!(" {existing} extra ")})); + assert!(result.is_err()); + assert!(Arc::ptr_eq(&before, &engine.session_arc())); + assert_eq!(engine.revision, revision); + assert_eq!(engine.session().track(occupied).unwrap().name, existing); + assert_eq!(engine.session().track(target).unwrap().name, "Target"); + assert!(!engine.is_dirty()); + assert!(!engine.can_undo()); + } +} + +#[test] +fn rename_returns_the_stored_unicode_name_and_undo_restores_the_document() { + let mut session = Session::default(); + let track = session.add_track(TrackKind::Audio, ChannelFormat::Surround51, Some("Original")); + session.track_mut(track).unwrap().comments = "Retain this comment".into(); + let mut engine = Engine::new(session); + let before = engine.session().to_json().unwrap(); + let stored = "é".repeat(64); + + let result = engine.execute("track.rename", &json!({"track": track.0, "name": format!(" {stored}extra ")})).unwrap(); + assert_eq!(result["name"], stored); + let renamed = engine.session().track(track).unwrap(); + assert_eq!(renamed.name, stored); + assert_eq!(renamed.name.chars().count(), 64); + assert_eq!(renamed.id, track); + assert_eq!(renamed.format, ChannelFormat::Surround51); + assert_eq!(renamed.comments, "Retain this comment"); + assert_eq!(engine.undo_history(), ["Rename Track"]); + assert!(engine.undo()); + assert_eq!(engine.session().to_json().unwrap(), before); + assert!(engine.redo()); + assert_eq!(engine.session().track(track).unwrap().name, stored); +} + +#[test] +fn unchanged_name_after_truncation_does_not_make_an_undo_step() { + let name = "A".repeat(64); + let mut session = Session::default(); + let track = session.add_track(TrackKind::Audio, ChannelFormat::Mono, Some(&name)); + let mut engine = Engine::new(session); + let before = engine.session_arc(); + let revision = engine.revision; + + let result = engine.execute("track.rename", &json!({"track": track.0, "name": format!("{name} suffix")})).unwrap(); + assert_eq!(result["name"], name); + assert!(Arc::ptr_eq(&before, &engine.session_arc())); + assert_eq!(engine.revision, revision); + assert!(!engine.is_dirty()); + assert!(!engine.can_undo()); +} + +#[test] +fn routing_folder_rename_preserves_unique_owned_bus_routes_and_history() { + use soundcraft_model::{BusId, Route, TrackId}; + + let stored = "界".repeat(64); + let first_name = format!("{stored} Bus"); + let second_name = format!("{stored} Bus 2"); + let mut session = Session::default(); + let member = session.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some("Member")); + let user_bus = session.add_bus(&first_name, ChannelFormat::Stereo); + let second_user_bus = session.add_bus(&second_name, ChannelFormat::Stereo); + let mut engine = Engine::new(session); + let unrelated = engine.execute("track.new", &json!({"kind": "folder", "name": "Unrelated"})).unwrap(); + let unrelated = TrackId(unrelated["tracks"][0].as_u64().unwrap()); + let unrelated_route = engine.session().track(unrelated).unwrap().mixer.input.clone(); + let created = engine.execute("track.move_to_new_folder", &json!({"tracks": [member.0], "name": "Initial"})).unwrap(); + let folder = TrackId(created["folder"].as_u64().unwrap()); + let owned_bus = BusId(created["bus"].as_u64().unwrap()); + let before = engine.session().to_json().unwrap(); + let history = engine.undo_history(); + let bus_count = engine.session().busses.len(); + + let result = engine.execute("track.rename", &json!({"track": folder.0, "name": format!(" {stored} suffix ")})).unwrap(); + assert_eq!(result["name"], stored); + assert_eq!(engine.session().track(folder).unwrap().name, stored); + assert_eq!(engine.session().bus(owned_bus).unwrap().name, format!("{stored} Bus 3")); + assert_eq!(engine.session().bus(user_bus).unwrap().name, first_name); + assert_eq!(engine.session().bus(second_user_bus).unwrap().name, second_name); + assert_eq!(engine.session().track(unrelated).unwrap().mixer.input, unrelated_route); + assert_eq!(engine.session().track(folder).unwrap().mixer.input, Route::Bus(owned_bus)); + assert_eq!(engine.session().track(member).unwrap().mixer.output, Route::Bus(owned_bus)); + assert_eq!(engine.session().track(member).unwrap().folder, Some(folder)); + assert_eq!(engine.session().busses.len(), bus_count); + assert_eq!(engine.undo_history().len(), history.len() + 1); + assert_eq!(engine.undo_label(), Some("Rename Track")); + let renamed = engine.session().to_json().unwrap(); + + let document = engine.session_arc(); + let revision = engine.revision; + let history = engine.undo_history(); + engine.execute("track.rename", &json!({"track": folder.0, "name": format!("{stored} more")})).unwrap(); + assert!(Arc::ptr_eq(&document, &engine.session_arc())); + assert_eq!(engine.revision, revision); + assert_eq!(engine.undo_history(), history); + assert!(engine.undo()); + assert_eq!(engine.session().to_json().unwrap(), before); + assert!(engine.redo()); + assert_eq!(engine.session().to_json().unwrap(), renamed); + + // Current-main same-name folder rename also repairs the folder's own bus, without taking + // either colliding user bus or changing its members' bus identity. + engine.session_mut().busses.iter_mut().find(|bus| bus.id == owned_bus).unwrap().name = "Manually named owned bus".into(); + let manual = engine.session().to_json().unwrap(); + engine.execute("track.rename", &json!({"track": folder.0, "name": stored})).unwrap(); + assert_eq!(engine.session().bus(owned_bus).unwrap().name, format!("{stored} Bus 3")); + assert_eq!(engine.session().bus(user_bus).unwrap().name, first_name); + assert_eq!(engine.session().bus(second_user_bus).unwrap().name, second_name); + assert_eq!(engine.session().track(member).unwrap().mixer.output, Route::Bus(owned_bus)); + assert!(engine.undo()); + assert_eq!(engine.session().to_json().unwrap(), manual); + assert!(engine.redo()); + assert_eq!(engine.session().to_json().unwrap(), renamed); +} + +#[test] +fn truncated_folder_collision_refuses_bus_and_document_changes_with_redo_pending() { + use soundcraft_model::{Route, TrackId}; + + for character in ['B', '界'] { + let occupied_name: String = std::iter::repeat_n(character, 64).collect(); + let mut session = Session::default(); + let occupied = session.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some(&occupied_name)); + let mut engine = Engine::new(session); + let created = engine.execute("track.new", &json!({"kind": "folder", "name": "Target"})).unwrap(); + let folder = TrackId(created["tracks"][0].as_u64().unwrap()); + let owned_bus = match engine.session().track(folder).unwrap().mixer.input { + Route::Bus(bus) => bus, + _ => panic!("the routing folder must own a bus"), + }; + engine.execute("mix.volume", &json!({"track": folder.0, "db": -3})).unwrap(); + assert!(engine.undo()); + engine.mark_clean(); + let document = engine.session_arc(); + let before = engine.session().to_json().unwrap(); + let revision = engine.revision; + let journal = engine.journal.clone(); + let undo = engine.undo_history(); + let redo = engine.redo_label().map(str::to_owned); + assert!(redo.is_some()); + + let result = engine.execute("track.rename", &json!({"track": folder.0, "name": format!(" {occupied_name} suffix ")})); + assert!(result.unwrap_err().to_string().contains(&occupied_name)); + assert!(Arc::ptr_eq(&document, &engine.session_arc())); + assert_eq!(engine.session().to_json().unwrap(), before); + assert_eq!(engine.revision, revision); + assert_eq!(engine.journal, journal); + assert_eq!(engine.undo_history(), undo); + assert_eq!(engine.redo_label(), redo.as_deref()); + assert!(!engine.is_dirty()); + assert_eq!(engine.session().track(occupied).unwrap().name, occupied_name); + assert_eq!(engine.session().track(folder).unwrap().name, "Target"); + assert_eq!(engine.session().bus(owned_bus).unwrap().name, "Target Bus"); + assert_eq!(engine.session().track(folder).unwrap().mixer.input, Route::Bus(owned_bus)); + } +} From 1e1458caf1e4d9d0ec06956539fe3efade781118 Mon Sep 17 00:00:00 2001 From: Billy Coleman III Date: Wed, 14 Oct 2026 13:14:38 -0400 Subject: [PATCH 05/19] Compile exact dependency order for deep Aux routing Prepare longest-path depths for acyclic Aux and Folder input routes so reverse-created chains beyond eight returns preserve their audio. Count output and send destinations once per producer, retain depth ties in session order, and preserve the whole-graph bounded fallback for cycles. Add public PCM regressions for deep chains, routing edits, callback sizes and cycle compatibility, plus focused private ordering cases. --- contributors/people.toml | 3 + crates/mix/src/lib.rs | 157 +++++++++++-- crates/mix/tests/aux_routing_order.rs | 307 ++++++++++++++++++++++++++ docs/aux-routing-order.md | 17 ++ 4 files changed, 468 insertions(+), 16 deletions(-) create mode 100644 crates/mix/tests/aux_routing_order.rs create mode 100644 docs/aux-routing-order.md diff --git a/contributors/people.toml b/contributors/people.toml index 1c344199..f67fdd57 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -50,3 +50,6 @@ sync_github_name = false [people.Momentum96] sync_github_name = true + +[people.ProdByBuddha] +sync_github_name = true diff --git a/crates/mix/src/lib.rs b/crates/mix/src/lib.rs index e8c4fbad..2c482fbd 100644 --- a/crates/mix/src/lib.rs +++ b/crates/mix/src/lib.rs @@ -1306,26 +1306,97 @@ fn processing_order(s: &Session) -> Vec { (0..s.tracks.len()).filter(|&i| s.tracks.get(i).is_some_and(|t| !matches!(t.kind, TrackKind::Aux | TrackKind::Folder))).collect(); let mut auxes: Vec = (0..s.tracks.len()).filter(|&i| s.tracks.get(i).is_some_and(|t| matches!(t.kind, TrackKind::Aux | TrackKind::Folder))).collect(); - // Depth = how many aux hops feed this aux's input bus (bounded; cycles cap out). - let depth = |i: usize| -> usize { - let mut d = 0; - let mut cur = vec![i]; - for _ in 0..8 { - let inputs: Vec<&Route> = cur.iter().filter_map(|&k| s.tracks.get(k)).map(|t| &t.mixer.input).collect(); - let feeders: Vec = auxes_feeding(s, &inputs); - if feeders.is_empty() { - break; - } - d += 1; - cur = feeders; - } - d - }; - auxes.sort_by_key(|&i| depth(i)); + if let Some(depths) = acyclic_aux_depths(s, &auxes) { + // Stable sorting preserves session order among auxes at the same longest-path depth. + auxes.sort_by_key(|&i| depths.get(i).copied().unwrap_or(0)); + } else { + // A cycle keeps the existing bounded ordering for the entire graph, including any + // independent acyclic branches. Feedback does not have a finite longest-path depth. + auxes.sort_by_key(|&i| bounded_aux_depth(s, i)); + } order.extend(auxes); order } +/// Exact aux-hop depths when the whole Aux/Folder graph is acyclic. Bus joins retain only +/// producer counts and consumers, avoiding a producer-by-consumer adjacency matrix. +fn acyclic_aux_depths(s: &Session, auxes: &[usize]) -> Option> { + #[derive(Default)] + struct BusDependencies { + remaining: usize, + depth: usize, + last_producer: Option, + last_processed: Option, + consumers: Vec, + } + let mut busses = HashMap::::new(); + for &i in auxes { + for bus in aux_output_busses(s.tracks.get(i)?) { + let dependency = busses.entry(bus).or_default(); + // Output and multiple sends from this producer may name the same bus. + if dependency.last_producer != Some(i) { + dependency.last_producer = Some(i); + dependency.remaining = dependency.remaining.checked_add(1)?; + } + } + } + let mut depths = vec![0usize; s.tracks.len()]; + let mut ready = Vec::with_capacity(auxes.len()); + for &i in auxes { + if let Route::Bus(bus) = &s.tracks.get(i)?.mixer.input { + let dependency = busses.entry(*bus).or_default(); + dependency.consumers.push(i); + if dependency.remaining > 0 { + continue; + } + } + ready.push(i); + } + let mut processed = 0usize; + while let Some(&i) = ready.get(processed) { + processed = processed.checked_add(1)?; + let next_depth = depths.get(i)?.checked_add(1)?; + for bus in aux_output_busses(s.tracks.get(i)?) { + let dependency = busses.get_mut(&bus)?; + if dependency.last_processed == Some(i) { + continue; + } + dependency.last_processed = Some(i); + dependency.depth = dependency.depth.max(next_depth); + dependency.remaining = dependency.remaining.checked_sub(1)?; + if dependency.remaining == 0 { + for &consumer in &dependency.consumers { + *depths.get_mut(consumer)? = dependency.depth; + ready.push(consumer); + } + } + } + } + (processed == auxes.len()).then_some(depths) +} + +fn aux_output_busses(t: &Track) -> impl Iterator + '_ { + std::iter::once(&t.mixer.output) + .chain(t.mixer.sends.iter().flatten().map(|send| &send.target)) + .filter_map(|route| if let Route::Bus(bus) = route { Some(*bus) } else { None }) +} + +/// The previous bounded depth calculation, retained unchanged for any cyclic graph. +fn bounded_aux_depth(s: &Session, i: usize) -> usize { + let mut d = 0; + let mut cur = vec![i]; + for _ in 0..8 { + let inputs: Vec<&Route> = cur.iter().filter_map(|&k| s.tracks.get(k)).map(|t| &t.mixer.input).collect(); + let feeders: Vec = auxes_feeding(s, &inputs); + if feeders.is_empty() { + break; + } + d += 1; + cur = feeders; + } + d +} + fn auxes_feeding(s: &Session, inputs: &[&Route]) -> Vec { s.tracks .iter() @@ -1338,6 +1409,60 @@ fn auxes_feeding(s: &Session, inputs: &[&Route]) -> Vec { .collect() } +#[cfg(test)] +#[allow(clippy::unwrap_used)] +mod processing_order_tests { + use super::*; + use soundcraft_model::SendSlot; + + #[test] + fn acyclic_bus_joins_use_longest_depth_and_keep_session_order_for_ties() { + let mut s = Session::default(); + s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None); + let consumer = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None); + let first_root = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None); + let second_root = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None); + let middle = s.add_track(TrackKind::Folder, ChannelFormat::Stereo, None); + let first_bus = s.add_bus("First", ChannelFormat::Stereo); + let join = s.add_bus("Join", ChannelFormat::Stereo); + s.track_mut(consumer).unwrap().mixer.input = Route::Bus(join); + let root = s.track_mut(first_root).unwrap(); + root.mixer.output = Route::Main; + root.mixer.sends[0] = Some(SendSlot::new(Route::Bus(first_bus))); + let root = s.track_mut(second_root).unwrap(); + root.mixer.output = Route::Bus(join); + root.mixer.sends[0] = Some(SendSlot::new(Route::Bus(join))); + root.mixer.sends[1] = Some(SendSlot::new(Route::Bus(join))); + let folder = s.track_mut(middle).unwrap(); + folder.mixer.input = Route::Bus(first_bus); + folder.mixer.output = Route::Bus(join); + folder.mixer.sends[0] = Some(SendSlot::new(Route::Bus(join))); + + assert_eq!(processing_order(&s), vec![0, 2, 3, 4, 1]); + } + + #[test] + fn a_cycle_preserves_bounded_order_for_the_whole_graph() { + let mut s = Session::default(); + let busses: Vec<_> = (0..10).map(|i| s.add_bus(&format!("Chain {i}"), ChannelFormat::Stereo)).collect(); + let tracks: Vec<_> = (0..10).map(|_| s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None)).collect(); + for (i, id) in tracks.iter().enumerate() { + let track = s.track_mut(*id).unwrap(); + track.mixer.input = Route::Bus(busses[i]); + track.mixer.output = if i == 0 { Route::Main } else { Route::Bus(busses[i - 1]) }; + } + assert_eq!(processing_order(&s), vec![9, 8, 7, 6, 5, 4, 3, 2, 1, 0]); + let cycle_bus = s.add_bus("Feedback", ChannelFormat::Stereo); + let cycle = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None); + let track = s.track_mut(cycle).unwrap(); + track.mixer.input = Route::Bus(cycle_bus); + track.mixer.output = Route::Bus(cycle_bus); + + // Both deepest independent returns tie with the cycle at the legacy eight-hop cap. + assert_eq!(processing_order(&s), vec![9, 8, 7, 6, 5, 4, 3, 2, 0, 1, 10]); + } +} + /// Implicit solo: an aux is not muted when a soloed track feeds its input bus. fn receives_solo(s: &Session, t: &Track) -> bool { let Route::Bus(b) = &t.mixer.input else { return false }; diff --git a/crates/mix/tests/aux_routing_order.rs b/crates/mix/tests/aux_routing_order.rs new file mode 100644 index 00000000..4c557fa7 --- /dev/null +++ b/crates/mix/tests/aux_routing_order.rs @@ -0,0 +1,307 @@ +//! Aux and routing-folder dependencies preserve PCM beyond eight hops. Cyclic graphs keep +//! the established whole-graph fallback, including its session-order-dependent audio. +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use soundcraft_audio_io::AudioBuffer; +use soundcraft_mix::{MixEngine, render_range}; +use soundcraft_model::{BusId, ChannelFormat, Clip, Route, SendSlot, Session, SourceAudio, SourceId, TrackId, TrackKind}; +use soundcraft_time::Range; +use std::sync::Arc; + +const FRAMES: usize = 4097; +const DEPTH: usize = 12; + +fn signal() -> Vec> { + // Distinct, exactly representable channels expose lost, duplicated, swapped and delayed PCM. + vec![ + (0..FRAMES).map(|frame| ((frame % 31) as i32 - 15) as f32 / 256.0).collect(), + (0..FRAMES).map(|frame| ((frame % 17) as i32 - 8) as f32 / 512.0).collect(), + ] +} + +fn scaled_signal(gain: f32) -> Vec> { + signal().into_iter().map(|channel| channel.into_iter().map(|value| value * gain).collect()).collect() +} + +fn session(pdc: bool) -> Session { + let mut session = Session::default(); + session.edit.click = false; + session.edit.delay_compensation = pdc; + session +} + +fn add_source(session: &mut Session, output: Route) -> TrackId { + let source = SourceId(session.alloc()); + session.pool.insert(source, Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: signal() }))); + let clip = session.new_clip_id(); + let track = session.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some("PCM source")); + let track_state = session.track_mut(track).unwrap(); + track_state.mixer.output = output; + track_state.playlist_mut().unwrap().clips.push(Clip::audio(clip, "PCM", source, 0, 0, FRAMES as i64)); + track +} + +fn add_aux(session: &mut Session, kind: TrackKind, input: BusId, output: Route) -> TrackId { + let track = session.add_track(kind, ChannelFormat::Stereo, None); + let mixer = &mut session.track_mut(track).unwrap().mixer; + mixer.input = Route::Bus(input); + mixer.output = output; + track +} + +fn send(bus: BusId) -> SendSlot { + let mut send = SendSlot::new(Route::Bus(bus)); + send.level_db = 0.0; + send +} + +struct Chain { + session: Session, + buses: Vec, + /// Logical routing order, deliberately different from the session's creation order. + tracks: Vec, +} + +fn reverse_chain(pdc: bool, send_links: bool, folders: bool) -> Chain { + let mut session = session(pdc); + let buses: Vec<_> = (0..DEPTH).map(|stage| session.add_bus(&format!("Stage {stage}"), ChannelFormat::Stereo)).collect(); + let mut tracks = Vec::new(); + for stage in (0..DEPTH).rev() { + let kind = if folders && stage % 3 == 1 { TrackKind::Folder } else { TrackKind::Aux }; + let output = if stage + 1 == DEPTH { + Route::Main + } else if send_links { + Route::None + } else { + Route::Bus(buses[stage + 1]) + }; + let track = add_aux(&mut session, kind, buses[stage], output); + if send_links && stage + 1 < DEPTH { + session.track_mut(track).unwrap().mixer.sends[0] = Some(send(buses[stage + 1])); + } + tracks.push(track); + } + tracks.reverse(); + add_source(&mut session, Route::Bus(buses[0])); + Chain { session, buses, tracks } +} + +fn assert_pcm(actual: &[Vec], expected: &[Vec], context: &str) { + assert_eq!(actual.len(), expected.len(), "{context}: channel count"); + for (channel, (actual, expected)) in actual.iter().zip(expected).enumerate() { + assert_eq!(actual.len(), expected.len(), "{context}: channel {channel} length"); + for (frame, (actual, expected)) in actual.iter().zip(expected).enumerate() { + assert_eq!(actual, expected, "{context}: channel {channel}, frame {frame}"); + } + } +} + +fn render(session: &Session, block: usize) -> Vec> { + render_range(session, Range::new(0, FRAMES as i64), block) +} + +fn engine_block(engine: &mut MixEngine, session: &Session) -> Vec> { + let mut out = vec![vec![0.0; 128]; 2]; + engine.render(session, 0, 128, &mut out); + out +} + +fn first_block(pcm: Vec>) -> Vec> { + pcm.into_iter().map(|channel| channel.into_iter().take(128).collect()).collect() +} + +#[test] +fn reverse_created_twelve_aux_chain_preserves_every_sample() { + for pdc in [false, true] { + let chain = reverse_chain(pdc, false, false); + assert_pcm(&render(&chain.session, 1024), &signal(), "deep output chain"); + } +} + +#[test] +fn deep_dependencies_through_sends_without_outputs_preserve_every_sample() { + for pdc in [false, true] { + let chain = reverse_chain(pdc, true, false); + assert_pcm(&render(&chain.session, 97), &signal(), "deep send-only chain"); + } +} + +#[test] +fn output_and_send_to_the_same_bus_sum_audio_without_duplicate_dependency() { + for pdc in [false, true] { + let mut chain = reverse_chain(pdc, false, false); + chain.session.track_mut(chain.tracks[4]).unwrap().mixer.sends[0] = Some(send(chain.buses[5])); + assert_pcm(&render(&chain.session, 256), &scaled_signal(2.0), "duplicate destination"); + } +} + +#[test] +fn short_and_deep_branches_both_reach_the_join() { + for pdc in [false, true] { + let mut chain = reverse_chain(pdc, false, false); + add_aux(&mut chain.session, TrackKind::Aux, chain.buses[0], Route::Bus(chain.buses[DEPTH - 1])); + assert_pcm(&render(&chain.session, 512), &scaled_signal(2.0), "branch join"); + } +} + +#[test] +fn routing_folders_participate_in_deep_dependencies() { + for pdc in [false, true] { + let chain = reverse_chain(pdc, true, true); + assert_pcm(&render(&chain.session, 63), &signal(), "aux and folder send chain"); + } +} + +#[test] +fn output_edit_reorders_the_same_engine_before_the_next_block() { + let mut session = session(true); + let root = session.add_bus("Root", ChannelFormat::Stereo); + let join = session.add_bus("Join", ChannelFormat::Stereo); + add_aux(&mut session, TrackKind::Aux, join, Route::Main); + let producer = add_aux(&mut session, TrackKind::Aux, root, Route::Main); + add_source(&mut session, Route::Bus(root)); + let mut engine = MixEngine::new(48_000.0, 128); + let expected = first_block(signal()); + assert_pcm(&engine_block(&mut engine, &session), &expected, "before output edit"); + session.track_mut(producer).unwrap().mixer.output = Route::Bus(join); + assert_pcm(&engine_block(&mut engine, &session), &expected, "after output edit"); +} + +#[test] +fn input_edit_reorders_the_same_engine_before_the_next_block() { + let mut session = session(true); + let root = session.add_bus("Root", ChannelFormat::Stereo); + let join = session.add_bus("Join", ChannelFormat::Stereo); + let consumer = add_aux(&mut session, TrackKind::Folder, root, Route::Main); + add_aux(&mut session, TrackKind::Aux, root, Route::Bus(join)); + add_source(&mut session, Route::Bus(root)); + let mut engine = MixEngine::new(48_000.0, 128); + let expected = first_block(signal()); + assert_pcm(&engine_block(&mut engine, &session), &expected, "before input edit"); + session.track_mut(consumer).unwrap().mixer.input = Route::Bus(join); + assert_pcm(&engine_block(&mut engine, &session), &expected, "after input edit"); +} + +#[test] +fn send_add_retarget_remove_and_readd_update_the_same_engine() { + let mut session = session(true); + let root = session.add_bus("Root", ChannelFormat::Stereo); + let join = session.add_bus("Join", ChannelFormat::Stereo); + let unused = session.add_bus("Unused", ChannelFormat::Stereo); + add_aux(&mut session, TrackKind::Aux, join, Route::Main); + let producer = add_aux(&mut session, TrackKind::Folder, root, Route::None); + add_source(&mut session, Route::Bus(root)); + let mut engine = MixEngine::new(48_000.0, 128); + let expected = first_block(signal()); + let silence = vec![vec![0.0; 128]; 2]; + assert_pcm(&engine_block(&mut engine, &session), &silence, "before send"); + session.track_mut(producer).unwrap().mixer.sends[0] = Some(send(join)); + assert_pcm(&engine_block(&mut engine, &session), &expected, "send added"); + session.track_mut(producer).unwrap().mixer.sends[0].as_mut().unwrap().target = Route::Bus(unused); + assert_pcm(&engine_block(&mut engine, &session), &silence, "send retargeted"); + session.track_mut(producer).unwrap().mixer.sends[0].as_mut().unwrap().target = Route::Bus(join); + assert_pcm(&engine_block(&mut engine, &session), &expected, "send retargeted back"); + session.track_mut(producer).unwrap().mixer.sends[0] = None; + assert_pcm(&engine_block(&mut engine, &session), &silence, "send removed"); + session.track_mut(producer).unwrap().mixer.sends[0] = Some(send(join)); + assert_pcm(&engine_block(&mut engine, &session), &expected, "send readded"); +} + +#[test] +fn track_reorder_removal_and_new_identity_rebuild_the_same_engine() { + let mut chain = reverse_chain(true, false, false); + let mut engine = MixEngine::new(48_000.0, 128); + let expected = first_block(signal()); + assert_pcm(&engine_block(&mut engine, &chain.session), &expected, "initial track order"); + chain.session.tracks.reverse(); + assert_pcm(&engine_block(&mut engine, &chain.session), &expected, "tracks reordered"); + chain.session.tracks.retain(|track| track.id != chain.tracks[6]); + let silence = vec![vec![0.0; 128]; 2]; + assert_pcm(&engine_block(&mut engine, &chain.session), &silence, "track removed"); + let replacement = add_aux(&mut chain.session, TrackKind::Aux, chain.buses[6], Route::Bus(chain.buses[7])); + assert_ne!(replacement, chain.tracks[6]); + assert_pcm(&engine_block(&mut engine, &chain.session), &expected, "track readded with new identity"); +} + +#[test] +fn strip_and_bus_format_edits_refresh_the_same_engine_workspace() { + let mut chain = reverse_chain(true, false, false); + let mut engine = MixEngine::new(48_000.0, 128); + let stereo = first_block(signal()); + assert_pcm(&engine_block(&mut engine, &chain.session), &stereo, "initial stereo formats"); + chain.session.track_mut(chain.tracks[5]).unwrap().format = ChannelFormat::Mono; + // A stereo bus folds to mono at -6 dB; the retained hard-left pan sends that mono to L. + let mono: Vec<_> = stereo[0].iter().zip(&stereo[1]).map(|(left, right)| 0.5 * (left + right)).collect(); + assert_pcm(&engine_block(&mut engine, &chain.session), &[mono.clone(), vec![0.0; 128]], "mono strip"); + chain.session.track_mut(chain.tracks[5]).unwrap().format = ChannelFormat::Stereo; + assert_pcm(&engine_block(&mut engine, &chain.session), &stereo, "stereo strip restored"); + chain.session.busses.iter_mut().find(|bus| bus.id == chain.buses[5]).unwrap().format = ChannelFormat::Mono; + // A mono bus feeds both channels of the following stereo aux at unity. + assert_pcm(&engine_block(&mut engine, &chain.session), &[mono.clone(), mono], "mono bus"); +} + +#[test] +fn deep_routing_is_invariant_to_offline_and_callback_block_sizes() { + let chain = reverse_chain(true, true, true); + let expected = signal(); + for block in [16, 63, 97, 256, 512, 1024] { + assert_pcm(&render(&chain.session, block), &expected, "offline block size"); + } + let mut engine = MixEngine::new(48_000.0, 1024); + let callbacks = [1, 63, 257, 17, 511, 1024]; + let mut out = vec![Vec::new(), Vec::new()]; + let mut position = 0; + let mut callback = 0; + while position < FRAMES { + let frames = callbacks[callback % callbacks.len()].min(FRAMES - position); + let mut block = vec![vec![0.0; frames]; 2]; + engine.render(&chain.session, position as i64, frames, &mut block); + for (destination, channel) in out.iter_mut().zip(block) { + destination.extend(channel); + } + position += frames; + callback += 1; + } + assert_pcm(&out, &expected, "varying callback sizes"); +} + +#[test] +fn self_loop_preserves_audio_and_selects_fallback_for_the_whole_graph() { + for pdc in [false, true] { + let mut chain = reverse_chain(pdc, false, false); + let loop_bus = chain.session.add_bus("Self loop", ChannelFormat::Stereo); + let aux = add_aux(&mut chain.session, TrackKind::Aux, loop_bus, Route::Main); + chain.session.track_mut(aux).unwrap().mixer.sends[0] = Some(send(loop_bus)); + add_source(&mut chain.session, Route::Bus(loop_bus)); + // The self-loop reads its source once, then writes back to the already-read bus. + // The disconnected deep chain remains silent under the established eight-hop fallback. + assert_pcm(&render(&chain.session, 97), &signal(), "self-loop whole-graph fallback"); + } +} + +#[test] +fn two_aux_cycle_preserves_session_order_audio_and_whole_graph_fallback() { + for pdc in [false, true] { + for reverse in [false, true] { + let mut chain = reverse_chain(pdc, false, false); + let a_bus = chain.session.add_bus("Cycle A", ChannelFormat::Stereo); + let b_bus = chain.session.add_bus("Cycle B", ChannelFormat::Stereo); + let (a, b) = if reverse { + let b = add_aux(&mut chain.session, TrackKind::Aux, b_bus, Route::Main); + let a = add_aux(&mut chain.session, TrackKind::Folder, a_bus, Route::Main); + (a, b) + } else { + let a = add_aux(&mut chain.session, TrackKind::Folder, a_bus, Route::Main); + let b = add_aux(&mut chain.session, TrackKind::Aux, b_bus, Route::Main); + (a, b) + }; + chain.session.track_mut(a).unwrap().mixer.sends[0] = Some(send(b_bus)); + chain.session.track_mut(b).unwrap().mixer.sends[0] = Some(send(a_bus)); + add_source(&mut chain.session, Route::Bus(a_bus)); + // A then B: both hear the source. B then A: B reads its still-empty bus. + // Buses clear each block, so neither order feeds a previous block back into this one. + let expected = scaled_signal(if reverse { 1.0 } else { 2.0 }); + assert_pcm(&render(&chain.session, 256), &expected, "two-aux whole-graph fallback"); + } + } +} diff --git a/docs/aux-routing-order.md b/docs/aux-routing-order.md new file mode 100644 index 00000000..3c93eddd --- /dev/null +++ b/docs/aux-routing-order.md @@ -0,0 +1,17 @@ +# Aux and Folder routing order + +Updated: 2026-10-14 + +Aux and Folder strips read audio from busses populated by earlier strips. The mixer prepares their execution order when the existing session-structure fingerprint changes, then reuses that order for subsequent blocks. + +For an acyclic routing graph, preparation computes the longest producer path to every Aux or Folder input. Producers reach a bus before its consumers read it, even when tracks were created in reverse routing order or the chain contains more than eight returns. Output and send routes both create dependencies. Multiple routes from the same producer to the same bus contribute audio normally but count as one producer dependency. Strips at the same depth retain session order, preserving the previous ordering for ordinary short acyclic graphs. + +The earlier ordering calculation capped every depth at eight. In a sufficiently deep reverse-created chain, that made a consumer tie with its producer and execute first. Because bus buffers are cleared each block, the consumer could receive silence. Exact acyclic depths remove that tie. + +If any cycle exists, the whole graph retains the previous bounded depth calculation and deterministic session-order ties. Preparation does not reject a cyclic session or change its feedback policy. This increment does not alter PDC accounting, plugin processing or failure containment, render-helper APIs, pan coefficients, Master insert order, playback ownership, or device selection. + +This is the routing-order increment of the remaining runtime work discussed in #394. Further runtime changes require independent treatment of prepared routing coefficients, workspace and instance lifetime, hosted automation delivery, graph latency, and explicit render failures. This increment does not claim to complete that rewrite or move all preparation off the audio callback. + +Regression tests use synthetic source samples and public mixer APIs. They cover deep reverse-created chains, output/send dependencies, duplicate routes, branching, Folder consumers, callback-size invariance, edits on an existing mixer and preserved cyclic behavior with PDC enabled or disabled. The same public fixture can run against the previous main to demonstrate the depth-cap failure independently of the new preparation helper. + +Revision history: 2026-10-14 — exact acyclic routing order with the existing whole-graph cyclic fallback. From b50373d6db9a89e32406bdb659fab6d112b39f1a Mon Sep 17 00:00:00 2001 From: Marco Arnulfo Date: Wed, 14 Oct 2026 19:25:20 +0200 Subject: [PATCH 06/19] A Pencil click on a MIDI clip selects it, so the MIDI Editor follows (fixes #562) --- crates/ui-egui/src/edit_window.rs | 9 +++++++-- crates/ui-egui/tests/new_midi_clip.rs | 15 +++++++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/edit_window.rs b/crates/ui-egui/src/edit_window.rs index f77560a5..78fc4ff2 100644 --- a/crates/ui-egui/src/edit_window.rs +++ b/crates/ui-egui/src/edit_window.rs @@ -2177,8 +2177,13 @@ fn lane_interaction(app: &mut SoundApp, ui: &mut Ui, track: &Track, lane: Rect, "automation.set_point", json!({"track": track.id.0, "param": automation_id(param), "at": at, "value": lo + (hi - lo) * k}), ); - } else if track.kind.is_midi() && hit.is_none() { - new_midi_clip(app, &s, track.id, at, at); + } else if track.kind.is_midi() { + match &hit { + Some(c) => { + let _ = app.run("edit.select", json!({"clips": [c.id.0]})); + } + None => new_midi_clip(app, &s, track.id, at, at), + } } } _ if !selector_press => place_insertion(app, ui, &s, track.id, at, mods.shift), diff --git a/crates/ui-egui/tests/new_midi_clip.rs b/crates/ui-egui/tests/new_midi_clip.rs index ec3fb07b..46b54616 100644 --- a/crates/ui-egui/tests/new_midi_clip.rs +++ b/crates/ui-egui/tests/new_midi_clip.rs @@ -135,3 +135,18 @@ fn a_click_in_the_empty_midi_editor_adds_a_clip_at_the_insertion_point() { assert_eq!(r.clips(), vec![(r.bar(3), r.bar(4))]); assert_eq!(midi_editor::target_clip(&r.app), Some(r.app.engine.session().tracks[0].clips()[0].id)); } + +#[test] +fn a_pencil_click_on_a_clip_selects_it_for_the_midi_editor() { + let mut r = Rig::new("instrument"); + r.app.ui.show_midi_editor = true; + r.drag((r.bar(2) + r.bar(3)) / 2, (r.bar(3) + r.bar(4)) / 2); + r.drag((r.bar(6) + r.bar(7)) / 2, (r.bar(7) + r.bar(8)) / 2); + let ids: Vec<_> = r.app.engine.session().tracks[0].clips().iter().map(|c| c.id).collect(); + assert_eq!(r.clips(), vec![(r.bar(2), r.bar(4)), (r.bar(6), r.bar(8))]); + assert_eq!(midi_editor::target_clip(&r.app), Some(ids[1])); + r.click((r.bar(2) + r.bar(3)) / 2); + assert_eq!(r.clips().len(), 2); + assert_eq!(r.app.engine.session().edit.selected_clips, vec![ids[0]]); + assert_eq!(midi_editor::target_clip(&r.app), Some(ids[0])); +} From 952ca5e4ed66a09da6ac51606d7659a072b921e8 Mon Sep 17 00:00:00 2001 From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com> Date: Wed, 14 Oct 2026 23:16:37 +0200 Subject: [PATCH 07/19] Round negative timecode and feet+frames positions symmetrically Found while testing crates/time/src/timecode.rs:111 Co-Authored-By: Claude Haiku 5.5 Co-Authored-By: Claude Sonnet 5.5 --- crates/time/src/format.rs | 13 +++++++++++++ crates/time/src/timecode.rs | 16 +++++++++++++++- 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/crates/time/src/format.rs b/crates/time/src/format.rs index bdd2fcb1..995b3265 100644 --- a/crates/time/src/format.rs +++ b/crates/time/src/format.rs @@ -185,6 +185,19 @@ mod tests { } } + #[test] + fn parse_round_trips_timecode_negative() { + let (sr, map, _) = ctx(); + let rate = FrameRate::Fps25; + for fmt in [TimeFormat::Timecode, TimeFormat::FeetFrames] { + for s in [-48_000i64, -96_000 * 3, -1_440_000] { + let text = format_position(s, fmt, sr, &map, rate, 0, 0); + let back = parse_position(&text, fmt, sr, &map, rate, 0, 0).unwrap(); + assert_eq!(back, s, "{fmt:?} {s} → {text} → {back}"); + } + } + } + #[test] fn parse_rejects_garbage() { let (sr, map, rate) = ctx(); diff --git a/crates/time/src/timecode.rs b/crates/time/src/timecode.rs index f8f6041b..b16f392c 100644 --- a/crates/time/src/timecode.rs +++ b/crates/time/src/timecode.rs @@ -108,7 +108,9 @@ impl FrameRate { if n == 0 { return 0; } - let v = (i128::from(f) * i128::from(sr.hz()) * i128::from(d) + i128::from(n) / 2) / i128::from(n); + // Round half away from zero so negative frames mirror positive ones. + let mag = (i128::from(f.unsigned_abs()) * i128::from(sr.hz()) * i128::from(d) + i128::from(n) / 2) / i128::from(n); + let v = if f < 0 { -mag } else { mag }; i64::try_from(v).unwrap_or(if v < 0 { i64::MIN } else { i64::MAX }) } @@ -221,6 +223,18 @@ mod tests { assert_eq!(tc.to_samples(FrameRate::Fps25, sr), 48_000 * 3661); } + #[test] + fn negative_timecode_rounds_symmetrically() { + let sr = SampleRate::HZ_48000; + let tc = Timecode::parse("-00:00:01:00").unwrap(); + assert_eq!(tc.to_samples(FrameRate::Fps25, sr), -48_000); + for r in [FrameRate::Fps25, FrameRate::Fps29_97, FrameRate::Fps29_97Drop, FrameRate::Fps23_976] { + for f in [1i64, 7, 25, 1799, 107_892] { + assert_eq!(r.samples_at_frame(-f, sr), -r.samples_at_frame(f, sr), "{r:?} frame {f}"); + } + } + } + #[test] fn drop_frame_labels() { let r = FrameRate::Fps29_97Drop; From 315745b02207b29b3d8bdec5586f3091a6e0f7ea Mon Sep 17 00:00:00 2001 From: midasmatterhorn <248507632+midasmatterhorn@users.noreply.github.com> Date: Thu, 15 Oct 2026 00:36:03 +0300 Subject: [PATCH 08/19] ui: MIDI Real-Time Properties submits only the property that changed (#444) --- crates/ui-egui/src/ops_windows.rs | 92 +++++++++++++++++++++++++++--- crates/ui-egui/tests/rtp_window.rs | 54 ++++++++++++++++++ 2 files changed, 139 insertions(+), 7 deletions(-) create mode 100644 crates/ui-egui/tests/rtp_window.rs diff --git a/crates/ui-egui/src/ops_windows.rs b/crates/ui-egui/src/ops_windows.rs index beba5237..45a2f3a9 100644 --- a/crates/ui-egui/src/ops_windows.rs +++ b/crates/ui-egui/src/ops_windows.rs @@ -30,6 +30,9 @@ pub struct OpsState { pub rtp_transpose: i64, pub rtp_duration: f64, pub rtp_delay: i64, + /// The MIDI tracks the Real-Time Properties form was last filled from: the form re-reads the + /// tracks when the target selection changes (#444). + pub rtp_targets: Vec, pub identify_bars: u32, } @@ -57,6 +60,7 @@ impl Default for OpsState { rtp_transpose: 0, rtp_duration: 100.0, rtp_delay: 0, + rtp_targets: Vec::new(), identify_bars: 1, } } @@ -261,15 +265,25 @@ fn rtp(app: &mut SoundApp, ctx: &egui::Context) { if !open { return; } + // Fill the form from the tracks it edits whenever the target selection changes, so it never + // shows (and a control change never writes back) stale defaults (#444). + let targets = app.engine.target_tracks(); + if app.ops.rtp_targets != targets { + app.ops.rtp_targets = targets.clone(); + let (velocity, transpose, duration, delay) = rtp_form_values(app.engine.session(), &targets); + app.ops.rtp_velocity = velocity; + app.ops.rtp_transpose = transpose; + app.ops.rtp_duration = duration; + app.ops.rtp_delay = delay; + } egui::Window::new("MIDI Real-Time Properties").open(&mut open).default_size(vec2(340.0, 200.0)).show(ctx, |ui| { ui.label("Non-destructive, applied at playback to the selected MIDI tracks."); - let mut changed = false; - changed |= ui.add(egui::Slider::new(&mut app.ops.rtp_velocity, -127..=127).text("Velocity +")).changed(); - changed |= ui.add(egui::Slider::new(&mut app.ops.rtp_transpose, -48..=48).text("Transpose")).changed(); - changed |= ui.add(egui::Slider::new(&mut app.ops.rtp_duration, 1.0..=400.0).text("Duration %")).changed(); - changed |= ui.add(egui::Slider::new(&mut app.ops.rtp_delay, -960..=960).text("Delay (ticks)")).changed(); - if changed { - let p = json!({"velocity": app.ops.rtp_velocity, "transpose": app.ops.rtp_transpose, "duration": app.ops.rtp_duration, "delay": app.ops.rtp_delay}); + let mut changed = RtpChanged::default(); + changed.velocity = ui.add(egui::Slider::new(&mut app.ops.rtp_velocity, -127..=127).text("Velocity +")).changed(); + changed.transpose = ui.add(egui::Slider::new(&mut app.ops.rtp_transpose, -48..=48).text("Transpose")).changed(); + changed.duration = ui.add(egui::Slider::new(&mut app.ops.rtp_duration, 1.0..=400.0).text("Duration %")).changed(); + changed.delay = ui.add(egui::Slider::new(&mut app.ops.rtp_delay, -960..=960).text("Delay (ticks)")).changed(); + if let Some(p) = rtp_params(changed, &app.ops) { let _ = app.engine.execute_merged("event.midi_rtp", &p, "rtp"); } ui.horizontal(|ui| { @@ -288,6 +302,47 @@ fn rtp(app: &mut SoundApp, ctx: &egui::Context) { app.ui.show_rtp = open; } +/// Which of the form's controls the user changed this frame. +#[derive(Default, Clone, Copy)] +struct RtpChanged { + velocity: bool, + transpose: bool, + duration: bool, + delay: bool, +} + +/// A form change submits only the properties the user touched: the command stores each key it is +/// sent, so sending untouched ones would overwrite the target's values with the form's (#444). +fn rtp_params(changed: RtpChanged, ops: &OpsState) -> Option { + let mut p = serde_json::Map::new(); + if changed.velocity { + p.insert("velocity".into(), json!(ops.rtp_velocity)); + } + if changed.transpose { + p.insert("transpose".into(), json!(ops.rtp_transpose)); + } + if changed.duration { + p.insert("duration".into(), json!(ops.rtp_duration)); + } + if changed.delay { + p.insert("delay".into(), json!(ops.rtp_delay)); + } + (!p.is_empty()).then_some(Value::Object(p)) +} + +/// The values the form shows for `targets`: the first target's own Real-Time Properties, or the +/// neutral defaults when nothing is selected. +fn rtp_form_values(s: &soundcraft_model::Session, targets: &[soundcraft_model::TrackId]) -> (i64, i64, f64, i64) { + let Some(&t) = targets.first() else { return (0, 0, 100.0, 0) }; + let value = |key: &str, d: f64| s.edit.value(&format!("rtp.{}.{key}", t.0), d); + ( + value("velocity", 0.0).clamp(-127.0, 127.0) as i64, + value("transpose", 0.0).clamp(-127.0, 127.0) as i64, + value("duration", 100.0).clamp(1.0, 1000.0), + value("delay", 0.0).clamp(-1e7, 1e7) as i64, + ) +} + #[cfg(test)] mod tests { use super::*; @@ -308,4 +363,27 @@ mod tests { assert_eq!(id, "event.tempo_linear"); assert_eq!(p["end_bpm"], 140.0); } + + /// One control moved: only its property is submitted, so the command cannot overwrite the + /// target's other Real-Time Properties with the form's values (#444). + #[test] + fn rtp_submits_only_the_property_that_changed() { + let ops = OpsState { rtp_velocity: 12, rtp_transpose: 7, rtp_duration: 50.0, rtp_delay: 480, ..OpsState::default() }; + let only_velocity = RtpChanged { velocity: true, ..RtpChanged::default() }; + assert_eq!(rtp_params(only_velocity, &ops), Some(json!({"velocity": 12}))); + let only_duration = RtpChanged { duration: true, ..RtpChanged::default() }; + assert_eq!(rtp_params(only_duration, &ops), Some(json!({"duration": 50.0}))); + assert_eq!(rtp_params(RtpChanged::default(), &ops), None, "no control moved, no command"); + } + + /// The form reads the target's own values when the window opens or the selection changes. + #[test] + fn the_rtp_form_shows_the_target_tracks_values() { + let mut e = soundcraft_engine::Engine::default(); + e.execute("track.new", &json!({"kind": "instrument", "name": "Synth"})).unwrap(); + let t = e.session().tracks.last().unwrap().id; + e.execute("event.midi_rtp", &json!({"track": t.0, "velocity": -12, "transpose": 7, "duration": 50.0, "delay": 480})).unwrap(); + assert_eq!(rtp_form_values(e.session(), &[]), (0, 0, 100.0, 0), "no target: the neutral defaults"); + assert_eq!(rtp_form_values(e.session(), &[t]), (-12, 7, 50.0, 480)); + } } diff --git a/crates/ui-egui/tests/rtp_window.rs b/crates/ui-egui/tests/rtp_window.rs new file mode 100644 index 00000000..cd62eb53 --- /dev/null +++ b/crates/ui-egui/tests/rtp_window.rs @@ -0,0 +1,54 @@ +use egui::accesskit::Role; +use egui::{Event, Modifiers, PointerButton, Pos2, vec2}; +use egui_kittest::{Harness, kittest::Queryable}; +use serde_json::json; +use soundcraft_ui_egui::{Services, SoundApp, menus}; + +fn press(h: &mut Harness<'_, SoundApp>, pos: Pos2, pressed: bool) { + h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); + h.run_steps(2); +} + +/// #444: the MIDI Real-Time Properties window submitted all four properties from its form on any +/// change, so editing Velocity reset the target's Transpose, Duration and Delay to the form's +/// (stale) defaults — and the form never showed the target's own values. +#[test] +fn editing_rtp_velocity_leaves_the_other_properties_alone() { + let mut app = SoundApp::new(soundcraft_engine::Engine::default(), None, Services::default()); + app.engine.execute("track.new", &json!({"kind": "instrument", "name": "Synth"})).unwrap(); + let t = app.engine.session().tracks.last().unwrap().id; + app.engine.execute("event.midi_rtp", &json!({"track": t.0, "transpose": 7, "duration": 50.0})).unwrap(); + app.run("edit.select", json!({"tracks": [t.0], "exact": true})).unwrap(); + menus::invoke_menu(&mut app, "window.rtp", "Event > MIDI Real-Time Properties"); + + let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state( + |ui, app: &mut SoundApp| { + let ctx = ui.ctx().clone(); + app.logic(&ctx); + app.ui(ui); + }, + app, + ); + h.run_steps(3); + assert!(h.state().ui.show_rtp, "the window did not open"); + let rtp = |h: &Harness<'_, SoundApp>, key: &str, d: f64| h.state().engine.session().edit.value(&format!("rtp.{}.{key}", t.0), d); + + // Drag the Velocity slider right: the velocity changes, the rest must stay as the track had it. + let rect = h.get_by_role_and_label(Role::Slider, "Velocity +").rect(); + let from = rect.center(); + let to = from + vec2(30.0, 0.0); + h.event(Event::PointerMoved(from)); + h.run_steps(1); + press(&mut h, from, true); + h.event(Event::PointerMoved(to)); + h.run_steps(2); + press(&mut h, to, false); + assert!(rtp(&h, "velocity", 0.0) > 0.0, "the velocity drag did not reach the engine"); + assert_eq!(rtp(&h, "transpose", 0.0), 7.0, "editing Velocity reset Transpose"); + assert_eq!(rtp(&h, "duration", 100.0), 50.0, "editing Velocity reset Duration"); + assert_eq!(rtp(&h, "delay", 0.0), 0.0, "editing Velocity reset Delay"); + + // The form shows the target track's values, not its defaults. + assert_eq!(h.state().ops.rtp_transpose, 7, "the form did not show the track's Transpose"); + assert_eq!(h.state().ops.rtp_duration, 50.0, "the form did not show the track's Duration"); +} From ea0e4719fcb20db268f2d784b752855e6d713634 Mon Sep 17 00:00:00 2001 From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com> Date: Thu, 15 Oct 2026 04:00:26 +0200 Subject: [PATCH 09/19] Release held VST3 notes on reset instead of discarding them Fixes #441 Co-Authored-By: Claude Haiku 5.5 Co-Authored-By: Claude Opus 5.5 --- crates/vst3-host/src/plugin.rs | 8 +++++++- crates/vst3-host/tests/fixture_e2e.rs | 23 +++++++++++++++++++++++ 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/crates/vst3-host/src/plugin.rs b/crates/vst3-host/src/plugin.rs index 2975465f..20d5fa6f 100644 --- a/crates/vst3-host/src/plugin.rs +++ b/crates/vst3-host/src/plugin.rs @@ -213,8 +213,14 @@ impl Plugin for Vst3Plugin { } fn reset(&mut self) { - self.notes.clear(); + // Keep pending releases and release whatever is still held, so the processor's voices stop + // on the next block instead of sounding on while the host forgets them. + self.notes.retain(|e| matches!(e, NoteEvent::Off { .. })); + for e in &mut self.notes { + e.set_time(0); + } self.controls.clear(); + self.all_notes_off(); self.held = [false; 128]; } diff --git a/crates/vst3-host/tests/fixture_e2e.rs b/crates/vst3-host/tests/fixture_e2e.rs index 5efd33cc..9c87b8bb 100644 --- a/crates/vst3-host/tests/fixture_e2e.rs +++ b/crates/vst3-host/tests/fixture_e2e.rs @@ -144,6 +144,29 @@ fn synth_plays_notes_at_their_offsets() { assert!(mono[0].iter().all(|&x| (x - 1.0).abs() < 1e-6), "the note is still held"); } +#[test] +fn reset_after_all_notes_off_still_releases_held_voices() { + let mut p = soundcraft_vst3_host::create(&id_of("Fixture Synth")).unwrap(); + p.prepare(48_000.0, 64, 2); + p.note_on(0, 60, 127); + let mut io = vec![vec![0.0f32; 64], vec![0.0f32; 64]]; + p.process(&mut io, 64); + assert!((io[0][63] - 1.0).abs() < 1e-6, "the note sounds"); + // Mixer::reset calls these two in a row on an instrument (stop / seek). + p.all_notes_off(); + p.reset(); + let mut io = vec![vec![9.0f32; 64], vec![9.0f32; 64]]; + p.process(&mut io, 64); + assert!(io[0].iter().all(|x| x.abs() < 1e-6), "voice still sounding after reset: {}", io[0][63]); + // A reset alone also releases what the host still holds. + p.note_on(0, 61, 127); + p.process(&mut io, 64); + assert!((io[0][63] - 1.0).abs() < 1e-6); + p.reset(); + p.process(&mut io, 64); + assert!(io[0].iter().all(|x| x.abs() < 1e-6), "voice still sounding after reset: {}", io[0][63]); +} + #[test] fn many_instances_create_and_drop_cleanly() { let (g, s) = (id_of("Fixture Gain"), id_of("Fixture Synth")); From fb087c879b31b4ecd44e5a3f5a2e3a9c7e9d923c Mon Sep 17 00:00:00 2001 From: MarekSpodBiedry <73122968+MarekSpodBiedry@users.noreply.github.com> Date: Thu, 15 Oct 2026 17:14:38 +0200 Subject: [PATCH 10/19] Give the New Tracks name field its own row so it stays wide (#626) --- crates/ui-egui/src/dialogs.rs | 4 +++- crates/ui-egui/tests/new_tracks.rs | 10 ++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 713e94b7..87a29f59 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -327,8 +327,10 @@ pub fn show(app: &mut SoundApp, ctx: &egui::Context) { ui.selectable_value(timebase, "ticks".to_string(), "Ticks"); }, ); + }); + ui.horizontal(|ui| { ui.label("Name:"); - ui.add(egui::TextEdit::singleline(name).desired_width(140.0)); + ui.add(egui::TextEdit::singleline(name).desired_width(240.0)); }); if buttons(ui, "Create", enter) { action = diff --git a/crates/ui-egui/tests/new_tracks.rs b/crates/ui-egui/tests/new_tracks.rs index 86f9132f..3a6d37a6 100644 --- a/crates/ui-egui/tests/new_tracks.rs +++ b/crates/ui-egui/tests/new_tracks.rs @@ -65,3 +65,13 @@ fn double_click_right_of_the_last_strip_opens_new_tracks() { click(&mut h, at); assert_eq!(h.state().dialogs.open_name(), Some("new_tracks")); } + +#[test] +fn the_new_tracks_name_field_is_wide_enough_to_read_a_name() { + let mut h = harness(0); + h.get_by_label_contains("New Tracks").click(); + h.run_steps(4); + assert_eq!(h.state().dialogs.open_name(), Some("new_tracks")); + let width = h.get_by_value("Audio").rect().width(); + assert!(width >= 200.0, "the Name field is only {width}px wide"); +} From 7a086baa7b11602d7d2099f1f6a7aae12f8d37a4 Mon Sep 17 00:00:00 2001 From: euisuh <55032583+euisuh@users.noreply.github.com> Date: Fri, 16 Oct 2026 13:36:19 +0900 Subject: [PATCH 11/19] fix(ui): capture live plugin state before saving track presets Track presets serialized the insert model's earlier capture instead of the hosted plugin's current state. Reuse the existing save/bounce capture path before preset serialization and exercise it with the real CLAP fixture. Closes #661 Related #639 Co-Authored-By: OpenAI Codex --- crates/clap-host/tests/common/mod.rs | 2 +- crates/clap-host/tests/fixture/Cargo.toml | 2 +- crates/ui-egui/src/lib.rs | 2 +- crates/ui-egui/tests/track_preset_state.rs | 36 ++++++++++++++++++++++ docs/gaps.md | 9 ++++-- 5 files changed, 45 insertions(+), 6 deletions(-) create mode 100644 crates/ui-egui/tests/track_preset_state.rs diff --git a/crates/clap-host/tests/common/mod.rs b/crates/clap-host/tests/common/mod.rs index 2da23955..6ae4ef74 100644 --- a/crates/clap-host/tests/common/mod.rs +++ b/crates/clap-host/tests/common/mod.rs @@ -9,7 +9,7 @@ use std::sync::OnceLock; pub fn fixture_dir() -> &'static Path { static DIR: OnceLock = OnceLock::new(); DIR.get_or_init(|| { - let manifest = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixture/Cargo.toml"); + let manifest = Path::new(env!("CARGO_MANIFEST_DIR")).join("../clap-host/tests/fixture/Cargo.toml"); let target = Path::new(env!("CARGO_TARGET_TMPDIR")).join("clap-fixture-target"); let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into()); let st = Command::new(cargo) diff --git a/crates/clap-host/tests/fixture/Cargo.toml b/crates/clap-host/tests/fixture/Cargo.toml index dac4af39..18efb527 100644 --- a/crates/clap-host/tests/fixture/Cargo.toml +++ b/crates/clap-host/tests/fixture/Cargo.toml @@ -1,4 +1,4 @@ -# A tiny CLAP plugin used only by soundcraft-clap-host's integration tests. Not part of the +# A tiny CLAP plugin used only by SoundCraft's integration tests. Not part of the # SoundCraft workspace (the empty [workspace] table makes it its own root); the test builds it # with `cargo build` and loads the resulting library. Never shipped. [package] diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index ddd54275..cd756716 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -418,7 +418,7 @@ impl SoundApp { if let Some(r) = menus::run_ui_command(self, id, ¶ms) { return r; } - if id.starts_with("session.save") || id.starts_with("file.bounce") { + if id.starts_with("session.save") || id.starts_with("file.bounce") || id == "track.save_preset" { // Third-party plugins keep state the session can't see: store it first. self.capture_plugin_states(); } diff --git a/crates/ui-egui/tests/track_preset_state.rs b/crates/ui-egui/tests/track_preset_state.rs new file mode 100644 index 00000000..155a7997 --- /dev/null +++ b/crates/ui-egui/tests/track_preset_state.rs @@ -0,0 +1,36 @@ +//! Track presets capture the hosted plugin's current state before writing the model. + +#[path = "../../clap-host/tests/common/mod.rs"] +mod common; + +use serde_json::{Value, json}; +use soundcraft_engine::Engine; +use soundcraft_model::{ChannelFormat, Insert, TrackKind, b64}; +use soundcraft_playback::Player; +use soundcraft_ui_egui::{Services, SoundApp}; + +#[test] +fn track_preset_captures_live_plugin_state_before_serializing() { + common::fixture_dir(); + let mut engine = Engine::default(); + let track = engine.session_mut().add_track(TrackKind::Audio, ChannelFormat::Mono, Some("Vox")); + engine.session_mut().track_mut(track).unwrap().mixer.inserts[0] = Some(Insert::new("clap:org.soundcraft.test.gain")); + let player = Player::new(engine.session_arc()); + let states = player.capture_states(); + assert_eq!(states.len(), 1, "the synthetic CLAP plugin must load even without an audio device"); + assert_eq!((states[0].0, states[0].1), (track, 0)); + let live = states[0].2.clone(); + + // The model still holds the earlier capture while the live plugin has its current settings. + let stale: Vec = [0.25_f64, 0.0].into_iter().flat_map(f64::to_le_bytes).collect(); + assert_ne!(live, stale); + engine.session_mut().track_mut(track).unwrap().mixer.inserts[0].as_mut().unwrap().set_state_bytes(&stale); + let mut app = SoundApp::new(engine, Some(player), Services::default()); + assert_eq!(app.engine.session().track(track).unwrap().mixer.inserts[0].as_ref().unwrap().state_bytes(), Some(stale)); + + let path = std::path::Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("track-preset-state-{}.json", std::process::id())); + app.run("track.save_preset", json!({"track": track.0, "path": path.to_string_lossy()})).unwrap(); + let preset: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); + std::fs::remove_file(path).unwrap(); + assert_eq!(preset["mixer"]["inserts"][0]["state"], b64::encode(&live), "the preset must contain the current hosted state"); +} diff --git a/docs/gaps.md b/docs/gaps.md index f8c39b8a..6703b6f9 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -1,6 +1,6 @@ # Where SoundCraft falls short of Pro Tools -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (G-01: audio device settings and opt-in ASIO) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-16 · **Change:** minor (G-16: live plugin state in track-preset saves) · **Target:** Avid Pro Tools Ultimate 2026.4.1 Every known shortfall, one entry each, ranked by how much it stops a Pro Tools user from doing real work in SoundCraft. This is the work list: pick from the top. Rows marked **alpha blocker** @@ -163,8 +163,10 @@ varispeed, high-quality offline) plus Elastic Pitch and warp-marker editing dept ### G-16. Session management -No session templates, track presets, workspace/sound browser with previews, batch rename (new in -2026.4), disk-usage and relink depth. ≈ 25–40 h. +Session templates, track-preset recall UI and browser, workspace/sound browser with previews, +batch rename (new in 2026.4), disk-usage and relink depth remain. Track-preset saves capture the +current hosted-plugin state before writing (#661); recall UI, partial recall and preset browsing remain +tracked in #639. ≈ 25–40 h. ### G-17. Video and post @@ -199,6 +201,7 @@ missing. Out of scope unless the owner decides otherwise. | Date | Change | Summary | |---|---|---| +| 2026-10-16 | minor | G-16: capture current hosted-plugin state before saving a track preset (#661); broader preset work remains (#639) | | 2026-10-12 | minor | G-01 shrunk: audio device, rate and buffer choice; opt-in ASIO | | 2026-10-10 | minor | Marked the alpha blockers (G-01, G-02, G-03; parts of G-05 and G-06) from the core-workflow gate | | 2026-10-10 | major | Created from the full re-measure against Pro Tools Ultimate 2026.4.1: 22 ranked gaps with evidence and estimates | From 3ea890496e108aa0432d0f7a8f9d628b6e5867af Mon Sep 17 00:00:00 2001 From: reoniazx <76652649+reoniazx@users.noreply.github.com> Date: Fri, 16 Oct 2026 12:33:09 +0800 Subject: [PATCH 12/19] fix(engine): preserve channels when splitting tracks into mono --- ROADMAP.md | 4 +- crates/engine/src/cmd/track.rs | 42 ++++++- crates/engine/tests/split_into_mono.rs | 159 +++++++++++++++++++++++++ docs/gaps.md | 7 +- 4 files changed, 207 insertions(+), 5 deletions(-) create mode 100644 crates/engine/tests/split_into_mono.rs diff --git a/ROADMAP.md b/ROADMAP.md index 73197650..7af8c561 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ **Stage: pre-alpha** · next: alpha, ~5% and ~110–180 h away (the alpha gate's three failing workflows) -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** minor (readiness by audience with hours to ~95 %) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-10-16 · **Last updated:** 2026-10-16 · **Change:** trivial (Split into Mono channel preservation) · **Target:** Avid Pro Tools Ultimate 2026.4.1 SoundCraft is a clean-room, pure-Rust digital audio workstation that aims at full parity with Avid Pro Tools, and then beyond it: faster, open, scriptable and agent-controllable. This page is @@ -122,6 +122,7 @@ mutated and truncated movies. Field reports from the first public week are track ## Progress log +- **2026-10-16:** Split into Mono extracts the correct source channel for each mono track instead of playing channel zero on every track. Clip offsets, gain, fades and stretch, source timestamps, Undo/Redo and saved audio are preserved; repeated clips share each extracted mono source. Unavailable media returns an error without partial edits. No readiness percentage change. - **2026-10-13:** `mix.instrument` takes the built-in instrument's parameters in `params` (validated, clamped) and refuses any other field, so a synth setting written beside `plugin` is an error instead of being accepted and ignored (#265) - **2026-10-13:** A bounce of a bus that an aux returns onto lines up with the timeline: the aux insert's lookahead is compensated like the main mix's (it left the bus late and cut the end off), and tracks routed to that bus wait for it too (#246) - **2026-10-13:** Delay compensation covers the inserts of the master faders: a bounce of the main mix with a Maximizer on the master lines up with the same mix without it (it came out 71 samples late) (#351) @@ -155,6 +156,7 @@ mutated and truncated movies. Field reports from the first public week are track | Date | Change | Summary | |---|---|---| +| 2026-10-16 | trivial | Split into Mono preserves each source channel, clip edits and saved audio; readiness estimates unchanged | | 2026-10-13 | trivial | Progress log: mix.instrument params, unknown fields refused (#265) | | 2026-10-13 | trivial | Progress log: bus bounce compensates aux returns (#246) | | 2026-10-13 | trivial | Progress log: master insert latency compensated (#351) | diff --git a/crates/engine/src/cmd/track.rs b/crates/engine/src/cmd/track.rs index 87912389..c0ebcbee 100644 --- a/crates/engine/src/cmd/track.rs +++ b/crates/engine/src/cmd/track.rs @@ -3,7 +3,7 @@ use super::*; use crate::cmd; use serde_json::json; -use soundcraft_model::{ChannelFormat, Group, GroupId, Playlist, Route, Session, Track, TrackHeight, TrackKind}; +use soundcraft_model::{ChannelFormat, ClipContent, Group, GroupId, Playlist, Route, Session, Track, TrackHeight, TrackKind}; pub fn specs() -> Vec { vec![ @@ -362,6 +362,8 @@ fn split_mono(e: &mut Engine, p: &Value) -> Result { let tracks = tracks_required(e, "track.split_into_mono", p)?; let s = e.session_mut(); let mut out = Vec::new(); + let mut mono_sources = std::collections::BTreeMap::new(); + let mut copied_samples = 0usize; for t in tracks { let Some(src) = s.track(t).cloned() else { continue }; if src.channels() < 2 || src.kind != TrackKind::Audio { @@ -377,12 +379,46 @@ fn split_mono(e: &mut Engine, p: &Value) -> Result { let mut clips = src.clips().to_vec(); for c in &mut clips { c.id = s.new_clip_id(); - // Mono tracks read channel 0 of the source; record the channel in the name for now. + if let ClipContent::Audio { source, .. } = &mut c.content { + let audio = + s.pool.get(*source).ok_or_else(|| bad("track.split_into_mono", format!("audio unavailable for clip `{}`", c.name)))?; + let channels = audio.buffer.channels.len(); + if channels == 0 { + return Err(bad("track.split_into_mono", format!("audio has no channels for clip `{}`", c.name))); + } + // Match the renderer's channel wrapping when a track is wider than its source. + // An already-mono source can be shared without copying it. + if channels > 1 { + let key = (*source, ch % channels); + let mono = if let Some(&id) = mono_sources.get(&key) { + id + } else { + let samples = + audio.buffer.channels.get(key.1).ok_or_else(|| bad("track.split_into_mono", "source channel unavailable"))?; + copied_samples = copied_samples + .checked_add(samples.len()) + .filter(|&n| n <= crate::io::MAX_IMPORT_SAMPLES) + .ok_or_else(|| bad("track.split_into_mono", "split would copy too much audio"))?; + // Keep the full channel: the cloned clips retain their offsets, stretch, + // gain and fades, and every reader sees genuine mono media (including saves). + let buf = soundcraft_audio_io::AudioBuffer { sample_rate: s.sample_rate.hz(), channels: vec![samples.clone()] }; + let original = s.source(*source); + let name = format!("{}.{suffix}.wav", original.map_or(c.name.as_str(), |source| source.name.as_str())); + let time_reference = original.map_or(0, |source| source.time_reference); + let id = crate::io::add_source(s, &name, buf, None, soundcraft_audio_io::FileFormat::Wav); + if let Some(source) = s.sources.iter_mut().find(|source| source.id == id) { + source.time_reference = time_reference; + } + mono_sources.insert(key, id); + id + }; + *source = mono; + } + } c.name = format!("{}.{suffix}", c.name); } if let Some(tr) = s.track_mut(id) { tr.mixer.pan = vec![if ch == 0 { -1.0 } else { 1.0 }]; - tr.comments = format!("source_channel={ch}"); if let Some(pl) = tr.playlist_mut() { pl.clips = clips; } diff --git a/crates/engine/tests/split_into_mono.rs b/crates/engine/tests/split_into_mono.rs new file mode 100644 index 00000000..7925af58 --- /dev/null +++ b/crates/engine/tests/split_into_mono.rs @@ -0,0 +1,159 @@ +//! Split tracks into mono without replacing the right/surround channels with channel zero. + +use serde_json::json; +use soundcraft_audio_io::{AudioBuffer, FileFormat}; +use soundcraft_engine::{Engine, io}; +use soundcraft_model::{ChannelFormat, Clip, Session, SourceAudio, SourceId, TrackId, TrackKind}; +use soundcraft_time::Range; +use std::sync::Arc; + +fn fixture(format: ChannelFormat, channels: usize) -> (Engine, TrackId, SourceId) { + let mut s = Session::default(); + let track = s.add_track(TrackKind::Audio, format, Some("Original")); + let channels = (0..channels).map(|ch| (0..256).map(|i| (ch + 1) as f32 * 0.1 + i as f32 * 0.0001).collect()).collect(); + let source = io::add_source(&mut s, "Original.wav", AudioBuffer { sample_rate: 48_000, channels }, None, FileFormat::Wav); + s.sources[0].time_reference = 123_456; + let mut clip = Clip::audio(s.new_clip_id(), "Edited", source, 7, 13, 47); + clip.gain_db = -6.0; + clip.gain_env = vec![(0, -3.0), (20, 0.0), (46, -9.0)]; + clip.fade_in.len = 5; + clip.fade_out.len = 9; + clip.stretch = 1.25; + let mut second = clip.clone(); + second.id = s.new_clip_id(); + second.start = 100; + second.content = soundcraft_model::ClipContent::Audio { source, offset: 90 }; + s.track_mut(track).unwrap().playlist_mut().unwrap().clips = vec![clip, second]; + (Engine::new(s), track, source) +} + +fn split(e: &mut Engine, track: TrackId) -> Vec { + let result = e.execute("track.split_into_mono", &json!({"track": track.0})).unwrap(); + result["tracks"].as_array().unwrap().iter().map(|id| TrackId(id.as_u64().unwrap())).collect() +} + +#[test] +fn split_into_mono_preserves_every_channel_and_clip_edit() { + for (format, channels) in [(ChannelFormat::Stereo, 2), (ChannelFormat::Surround51, 6)] { + let (mut e, track, source) = fixture(format, channels); + let original = e.session().track(track).unwrap().clone(); + let audio = Arc::clone(e.session().pool.get(source).unwrap()); + let expected = soundcraft_mix::render_clips(e.session(), track, Range::new(0, 192)); + let tracks = split(&mut e, track); + assert_eq!(tracks.len(), channels); + assert_eq!(e.session().track(track).unwrap(), &original); + assert!(Arc::ptr_eq(e.session().pool.get(source).unwrap(), &audio)); + // Two clips referencing the same source share one extracted source per channel. + assert_eq!(e.session().sources.len(), 1 + channels); + for (ch, &id) in tracks.iter().enumerate() { + let mono = e.session().track(id).unwrap(); + assert_eq!(mono.format, ChannelFormat::Mono); + let actual = soundcraft_mix::render_clips(e.session(), id, Range::new(0, 192)); + assert_eq!(actual[0], expected[ch], "{format:?} channel {ch}"); + let mono_source = mono.clips()[0].source().unwrap(); + assert_ne!(mono_source, source); + assert!(mono.clips().iter().all(|clip| clip.source() == Some(mono_source))); + let data = e.session().pool.get(mono_source).unwrap(); + assert_eq!(data.buffer.channels, vec![audio.buffer.channels[ch].clone()]); + assert_eq!(data.peaks.len(), 1); + let metadata = e.session().source(mono_source).unwrap(); + assert_eq!((metadata.channels, metadata.time_reference), (1, 123_456)); + assert!(metadata.unsaved); + for (clip, original) in mono.clips().iter().zip(original.clips()) { + let mut expected_clip = original.clone(); + expected_clip.id = clip.id; + expected_clip.name = clip.name.clone(); + expected_clip.content = soundcraft_model::ClipContent::Audio { source: mono_source, offset: original.source_offset() }; + assert_eq!(clip, &expected_clip); + } + } + } +} + +#[test] +fn split_stereo_matches_the_original_mix_in_playback_and_bounce_blocks() { + let (mut e, track, _) = fixture(ChannelFormat::Stereo, 2); + let original = e.session().clone(); + let tracks = split(&mut e, track); + assert_eq!(e.session().track(tracks[0]).unwrap().name, "Original.L"); + assert_eq!(e.session().track(tracks[1]).unwrap().name, "Original.R"); + e.session_mut().track_mut(track).unwrap().inactive = true; + for block in [37, 512, 1024] { + let expected = soundcraft_mix::render_range(&original, Range::new(0, 192), block); + let actual = soundcraft_mix::render_range(e.session(), Range::new(0, 192), block); + assert_eq!(actual, expected, "block {block}"); + } +} + +#[test] +fn split_stereo_preserves_distinct_left_and_right_levels() { + let (mut e, track, source) = fixture(ChannelFormat::Stereo, 2); + let s = e.session_mut(); + s.pool.insert(source, Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: vec![vec![0.2; 256], vec![0.7; 256]] }))); + let clip = Clip::audio(s.new_clip_id(), "Distinct channels", source, 0, 0, 256); + s.track_mut(track).unwrap().playlist_mut().unwrap().clips = vec![clip]; + split(&mut e, track); + e.session_mut().track_mut(track).unwrap().inactive = true; + let audio = soundcraft_mix::render_range(e.session(), Range::new(0, 128), 64); + eprintln!("Split into Mono output: L={}, R={}", audio[0][64], audio[1][64]); + assert_eq!(audio[0][64], 0.2); + assert_eq!(audio[1][64], 0.7); +} + +#[test] +fn split_sources_survive_save_and_reopen_with_distinct_audio_files() { + let (mut e, track, _) = fixture(ChannelFormat::Stereo, 2); + let tracks = split(&mut e, track); + let (bytes, saved) = io::session_bundle(e.session()).unwrap(); + let paths: std::collections::BTreeSet<_> = saved.sources.iter().map(|source| &source.path).collect(); + assert_eq!(paths.len(), 3); + let mut reopened = Engine::default(); + assert!(io::open_session_bytes(&mut reopened, "split.scraftz", &bytes).unwrap().is_empty()); + for id in tracks { + let expected = soundcraft_mix::render_clips(e.session(), id, Range::new(0, 192)); + let actual = soundcraft_mix::render_clips(reopened.session(), id, Range::new(0, 192)); + assert_eq!(actual, expected); + } +} + +#[test] +fn split_tracks_and_sources_undo_and_redo_together() { + let (mut e, track, _) = fixture(ChannelFormat::Stereo, 2); + let before = e.session().clone(); + split(&mut e, track); + let after = e.session().clone(); + assert_eq!(e.undo_history().len(), 1); + assert!(e.undo()); + assert_eq!(e.session(), &before); + assert!(e.redo()); + assert_eq!(e.session(), &after); +} + +#[test] +fn split_reuses_a_mono_source_on_a_stereo_track() { + let (mut e, track, source) = fixture(ChannelFormat::Stereo, 1); + let expected = soundcraft_mix::render_clips(e.session(), track, Range::new(0, 192)); + for id in split(&mut e, track) { + assert!(e.session().track(id).unwrap().clips().iter().all(|clip| clip.source() == Some(source))); + assert_eq!(soundcraft_mix::render_clips(e.session(), id, Range::new(0, 192))[0], expected[0]); + } + assert_eq!(e.session().sources.len(), 1); +} + +#[test] +fn missing_or_empty_media_refuses_the_split_without_partial_changes() { + for empty in [false, true] { + let (mut e, track, _) = fixture(ChannelFormat::Stereo, 2); + let missing = SourceId(9999); + if empty { + e.session_mut().pool.insert(missing, Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: vec![] }))); + } + let clip = Clip::audio(e.session_mut().new_clip_id(), "Unavailable", missing, 0, 160, 16); + e.session_mut().track_mut(track).unwrap().playlist_mut().unwrap().clips.push(clip); + let before = e.session().clone(); + let error = e.execute("track.split_into_mono", &json!({"track": track.0})).unwrap_err(); + assert!(matches!(error, soundcraft_engine::EngineError::BadParams(..)), "{error}"); + assert_eq!(e.session(), &before); + assert!(e.undo_history().is_empty()); + } +} diff --git a/docs/gaps.md b/docs/gaps.md index f8c39b8a..21420705 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -1,6 +1,6 @@ # Where SoundCraft falls short of Pro Tools -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (G-01: audio device settings and opt-in ASIO) · **Target:** Avid Pro Tools Ultimate 2026.4.1 +> **Last reviewed:** 2026-10-16 · **Last updated:** 2026-10-16 · **Change:** trivial (G-04: Split into Mono channel fix) · **Target:** Avid Pro Tools Ultimate 2026.4.1 Every known shortfall, one entry each, ranked by how much it stops a Pro Tools user from doing real work in SoundCraft. This is the work list: pick from the top. Rows marked **alpha blocker** @@ -80,6 +80,10 @@ When you close a gap, delete its entry (or shrink it) in the same PR, and bump t ### G-04. Correctness bugs in "done" features +**Fixed (2026-10-16):** Split into Mono now gives each output track its own source channel, +including surround channels, instead of repeating channel zero. Clip edits, source timestamps, +Undo/Redo and save/reopen are covered by regression tests; missing or empty media fails atomically. + Open on 2026-10-10 (several have PRs open): editing #3, #5, #140, #144; clip/session #86 (PR #123), #88 (PR #130), #91 (PR #124), #92 (PR #132); automation #104 (PR #134); mix/bounce #59 (PR #131), #103 (PR #133), #152; playback #101 (PR #129); @@ -199,6 +203,7 @@ missing. Out of scope unless the owner decides otherwise. | Date | Change | Summary | |---|---|---| +| 2026-10-16 | trivial | G-04: Split into Mono channel preservation fixed and regression-tested; estimates unchanged | | 2026-10-12 | minor | G-01 shrunk: audio device, rate and buffer choice; opt-in ASIO | | 2026-10-10 | minor | Marked the alpha blockers (G-01, G-02, G-03; parts of G-05 and G-06) from the core-workflow gate | | 2026-10-10 | major | Created from the full re-measure against Pro Tools Ultimate 2026.4.1: 22 ranked gaps with evidence and estimates | From 4110f5ff10b6ddf35e9588ad251e958745d0920d Mon Sep 17 00:00:00 2001 From: Derek Wright Date: Sun, 18 Oct 2026 13:07:27 -0400 Subject: [PATCH 13/19] Mix tests: never load real plug-ins stored_state_comes_first_then_session_params ends with an offline render_range over a vst3: insert. That reached create_plugin and the real VST3 host, which scans the machine's plug-in folders and loads every installed plug-in in-process; some (Native Instruments) hang on unload, so the test binary never exited on a developer machine. CI has no plug-ins installed, so it stayed green. Under cfg(test), create_plugin now returns None for third-party ids, so a test reaching the real hosts sees an absent plug-in instead of hanging. The rule, stated in the tests module doc: tests adopt fakes under clap:test.* ids and never call the real hosts. --- crates/mix/src/lib.rs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/crates/mix/src/lib.rs b/crates/mix/src/lib.rs index e8c4fbad..c7c2a592 100644 --- a/crates/mix/src/lib.rs +++ b/crates/mix/src/lib.rs @@ -2220,6 +2220,13 @@ pub fn render_track_pre_fader(s: &Session, track: TrackId, range: Range) -> Vec< /// A built-in plugin, else a hosted CLAP plugin (`clap:`). fn create_plugin(id: &str) -> Option> { + // Tests never load real plug-ins; adopt a fake instead. Scanning the machine's plug-in folders + // loads every installed plug-in in-process, and some never unload, so a test that reached the + // real hosts would hang on a developer machine (CI has none installed). + #[cfg(test)] + if is_third_party(id) { + return None; + } soundcraft_dsp::create(id) .or_else(|| soundcraft_clap_host::create(id)) .or_else(|| soundcraft_vst3_host::create(id)) @@ -2272,6 +2279,10 @@ mod audio_thread_tests { #[cfg(test)] mod tests { + //! Rule: tests never call the real plug-in hosts. Third-party ids are not created here + //! (create_plugin returns None under cfg(test)); a test that needs a hosted plug-in + //! adopts a fake under a clap:test.* id via MixEngine::adopt. + use super::*; use soundcraft_audio_io::AudioBuffer; use soundcraft_model::{Insert, SourceAudio, SourceId}; @@ -2832,7 +2843,7 @@ mod tests { s.track_mut(t).unwrap().mixer.inserts[0].as_mut().unwrap().params.insert("gain".into(), -12.0); render_block(&mut eng, &s, 1024); assert_eq!(sets.load(std::sync::atomic::Ordering::Relaxed), 2, "later session edits apply"); - // Offline (not external): unknown third-party plugins are simply absent. + // Offline (not external): third-party plugins are simply absent (tests never load real ones). let out = render_range(&s, Range::new(0, 1024), 512); assert!(out[0][100] > 0.3); } From 3c04a3c36fe841c3e0d4e07f72a6999bcf33289f Mon Sep 17 00:00:00 2001 From: NetterSilver <133535268+Silvertree2010@users.noreply.github.com> Date: Mon, 19 Oct 2026 11:04:51 +0000 Subject: [PATCH 14/19] Fix empty SMF export re-importing as one phantom empty track Found while testing crates/midi/src/smf.rs:207 Co-Authored-By: Claude Haiku 5.5 Co-Authored-By: Claude Sonnet 5.5 --- crates/midi/src/smf.rs | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/crates/midi/src/smf.rs b/crates/midi/src/smf.rs index 7747a061..3fe84678 100644 --- a/crates/midi/src/smf.rs +++ b/crates/midi/src/smf.rs @@ -204,7 +204,12 @@ pub fn read_smf(bytes: &[u8]) -> Result { tracks.push(track); } - if format == 1 && tracks.len() > 1 && tracks.first().is_some_and(|t| t.sequence.notes.is_empty() && t.sequence.ctrls.is_empty()) { + // A lone track is only a conductor track if it carried global data and has no name; otherwise it is kept. + let globals_present = !(globals.tempos.is_empty() && globals.meters.is_empty() && globals.markers.is_empty() && globals.key_sigs.is_empty()); + if format == 1 + && (tracks.len() > 1 || globals_present) + && tracks.first().is_some_and(|t| t.sequence.notes.is_empty() && t.sequence.ctrls.is_empty() && (tracks.len() > 1 || t.name.is_empty())) + { tracks.remove(0); } @@ -444,7 +449,12 @@ fn write_track(out: &mut Vec, mut events: Vec) -> Result<(), MidiErr /// Errors: invalid tempo (non-finite or <= 0 bpm), meter denominator that is not a power of two /// (1..=128), more than 65535 tracks, or a gap between events beyond the 28-bit delta limit. pub fn write_smf(smf: &Smf) -> Result, MidiError> { - let ntrks = u16::try_from(smf.tracks.len().saturating_add(1)).map_err(|_| MidiError::Write("more than 65535 tracks".into()))?; + // The conductor track is omitted when there is nothing to put in it and no content tracks, so an + // empty `Smf` is written as a file with zero tracks and reads back as zero tracks. + let has_conductor = + !(smf.tempos.is_empty() && smf.meters.is_empty() && smf.key_sigs.is_empty() && smf.markers.is_empty() && smf.tracks.is_empty()); + let ntrks = + u16::try_from(smf.tracks.len().saturating_add(usize::from(has_conductor))).map_err(|_| MidiError::Write("more than 65535 tracks".into()))?; let mut out = Vec::new(); out.extend_from_slice(b"MThd"); out.extend_from_slice(&6u32.to_be_bytes()); @@ -476,7 +486,9 @@ pub fn write_smf(smf: &Smf) -> Result, MidiError> { for (t, text) in &smf.markers { ev.push(WEvent { tick: clamp_tick(*t), order: 3, bytes: meta(0x06, text.as_bytes())? }); } - write_track(&mut out, ev)?; + if has_conductor { + write_track(&mut out, ev)?; + } for track in &smf.tracks { let mut ev = Vec::new(); @@ -527,6 +539,19 @@ mod tests { assert!(push_vlq(&mut Vec::new(), MAX_VLQ + 1).is_err()); } + #[test] + fn empty_smf_round_trips_with_no_tracks() { + let r = read_smf(&write_smf(&Smf::default()).unwrap()).unwrap(); + assert_eq!(r.tracks.len(), 0); + let one = Smf { tracks: vec![SmfTrack::default()], ..Smf::default() }; + let r = read_smf(&write_smf(&one).unwrap()).unwrap(); + assert_eq!(r.tracks.len(), 1); + let cond = Smf { tempos: vec![(0, 90.0)], ..Smf::default() }; + let r = read_smf(&write_smf(&cond).unwrap()).unwrap(); + assert_eq!(r.tracks.len(), 0); + assert_eq!(r.tempos.len(), 1); + } + #[test] fn spec_vlq_examples() { let mut b = Vec::new(); From 82616dcfb800d2cb8f768281dfcb380bdbbb47f9 Mon Sep 17 00:00:00 2001 From: Limestudio90 Date: Mon, 19 Oct 2026 18:01:38 +0200 Subject: [PATCH 15/19] vst3-host: restore "crate" in the ffi module doc Co-Authored-By: Claude Opus 5.5 --- crates/vst3-host/src/ffi.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/vst3-host/src/ffi.rs b/crates/vst3-host/src/ffi.rs index 0e7acdc2..8b20e4ef 100644 --- a/crates/vst3-host/src/ffi.rs +++ b/crates/vst3-host/src/ffi.rs @@ -1,4 +1,4 @@ -//! The FFI boundary: the only module of this rate allowed to use `unsafe`. +//! The FFI boundary: the only module of this crate allowed to use `unsafe`. //! //! It loads VST3 binaries (`libloading`), runs the platform module entry, calls the COM //! interfaces of the factory, component, audio processor and edit controller (`vst3` raw From b5bcf577b213fd6844bbf6f60e771a60f058adc1 Mon Sep 17 00:00:00 2001 From: MarekSpodBiedry <73122968+MarekSpodBiedry@users.noreply.github.com> Date: Mon, 19 Oct 2026 22:27:44 +0200 Subject: [PATCH 16/19] Fix saved audio trust test on Windows by joining path parts separately (#789) --- crates/engine/src/io.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index eff105ec..bc60fd03 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -1710,7 +1710,7 @@ mod save_tests { let mut r = Engine::default(); assert_eq!( open_session(&mut r, &path("B/Moved.scraft")).unwrap(), - vec![dir.join("A").join("Audio Files/Audio 1_02.wav").display().to_string()] + vec![dir.join("A").join("Audio Files").join("Audio 1_02.wav").display().to_string()] ); let _ = std::fs::remove_dir_all(&dir); } From 24fa4668ef968b78ae0c902fa104ee4dbdcab783 Mon Sep 17 00:00:00 2001 From: lucasegen <281051305+lucasegen@users.noreply.github.com> Date: Tue, 20 Oct 2026 11:37:35 +0200 Subject: [PATCH 17/19] Name F12 in the Record button's tooltip The tooltip only offered Cmd+Space, which macOS gives to Spotlight unless the user frees it, so on a stock Mac the advertised shortcut opens Spotlight. F12 already records (shortcuts.rs), as on the incumbent; the tooltip now names it first. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/toolbar.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index 41d83ac4..0dd217b6 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -338,7 +338,8 @@ fn transport(app: &mut SoundApp, ui: &mut Ui) { let (r, resp) = ui.allocate_exact_size(vec2(38.0, 28.0), Sense::click()); key(ui.painter(), r, &resp, if recording { Color32::from_rgb(110, 30, 30) } else { key_fill(&resp) }); icons::draw(ui.painter(), r.shrink(5.0), "record", t.rec); - let resp = resp.on_hover_text("Record (Cmd+Space)"); + // macOS gives Cmd+Space to Spotlight unless the user frees it, so name F12 first. + let resp = resp.on_hover_text("Record (F12 or Cmd+Space)"); if let Some(why) = app.record_hint() { // Below the whole group, so the hint covers none of its buttons. let below = Rect::from_min_max(r.min, pos2(r.max.x, g.max.y)); From 1f72dc30be7fac44b874ee1b60fca2ccf5a6c7fa Mon Sep 17 00:00:00 2001 From: lucasegen <281051305+lucasegen@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:29:51 +0200 Subject: [PATCH 18/19] Import registry in au-host's macOS api module #988 replaced `use super::*;` in the macOS `api` module with an explicit list that leaves `registry` out, so soundcraft-au-host, and with it the app, no longer builds on macOS: four E0433 errors. Linux CI compiles this module out, so it stayed green. Co-Authored-By: Claude Opus 5.5 --- crates/au-host/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/au-host/src/lib.rs b/crates/au-host/src/lib.rs index 3a664a4d..7aa3b2eb 100644 --- a/crates/au-host/src/lib.rs +++ b/crates/au-host/src/lib.rs @@ -192,7 +192,7 @@ pub enum AuError { #[cfg(target_os = "macos")] mod api { - use super::{AuDescriptor, AuError, Plugin, PluginInfo}; + use super::{AuDescriptor, AuError, Plugin, PluginInfo, registry}; pub fn scan() -> Vec { registry::scan() From 6c03d7e8deae8c3c30f4ed2509ccbe1ea4b206c5 Mon Sep 17 00:00:00 2001 From: SusieeTheLinuxUser <96988330+SusieeTheLinuxUser@users.noreply.github.com> Date: Sat, 24 Oct 2026 06:30:31 +0200 Subject: [PATCH 19/19] Tracks: clip track and group names to their rows in the side lists (fixes #990) Co-Authored-By: GLM-5.3-Flash --- crates/ui-egui/src/panels.rs | 10 +++- crates/ui-egui/tests/it/main.rs | 1 + crates/ui-egui/tests/it/side_lists_text.rs | 57 ++++++++++++++++++++++ 3 files changed, 66 insertions(+), 2 deletions(-) create mode 100644 crates/ui-egui/tests/it/side_lists_text.rs diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs index 5522e4cf..778af47b 100644 --- a/crates/ui-egui/src/panels.rs +++ b/crates/ui-egui/src/panels.rs @@ -77,7 +77,13 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) { let _ = app.run("track.hide", json!({"tracks": [id], "hidden": shown})); } ui.painter().rect_filled(Rect::from_min_size(pos2(r.min.x + 20.0, r.min.y + 3.0), vec2(4.0, 11.0)), 0.0, rgb(color)); - ui.painter().text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, &name, regular(11.5), if shown { t.text } else { t.text_dim }); + ui.painter().with_clip_rect(r).text( + pos2(r.min.x + 30.0, r.center().y), + Align2::LEFT_CENTER, + &name, + regular(11.5), + if shown { t.text } else { t.text_dim }, + ); if resp.clicked() { crate::edit_window::click_track(app, soundcraft_model::TrackId(id), ui.input(|i| i.modifiers), |_, _| true); } @@ -118,7 +124,7 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) { bold(10.0), if active { t.text_dark } else { t.text_dim }, ); - ui.painter().text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, &name, regular(11.5), t.text); + ui.painter().with_clip_rect(r).text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, &name, regular(11.5), t.text); if resp.clicked() { let _ = app.run("track.group_toggle", json!({"group": id})); } diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index eb09a58b..df71ff82 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -43,6 +43,7 @@ mod send_window; mod shared_controls; mod shortcuts; mod side_lists_access; +mod side_lists_text; mod toolbar_scroll; mod toolbar_tempo; mod track_height; diff --git a/crates/ui-egui/tests/it/side_lists_text.rs b/crates/ui-egui/tests/it/side_lists_text.rs new file mode 100644 index 00000000..a99929a8 --- /dev/null +++ b/crates/ui-egui/tests/it/side_lists_text.rs @@ -0,0 +1,57 @@ +//! #990: track and group names in the side lists are clipped to their row, so a long name cannot +//! paint across the scrollbar gutter and over the panel's edge. + +use egui::{Shape, vec2}; +use egui_kittest::{Harness, kittest::Queryable}; +use serde_json::json; +use soundcraft_ui_egui::{Services, SoundApp}; + +fn harness() -> Harness<'static, SoundApp> { + let mut app = SoundApp::new(soundcraft_engine::demo::demo_engine(), None, Services::default()); + let first = app.engine.session().tracks.first().map(|t| t.id.0).unwrap_or_default(); + app.run("track.rename", json!({"track": first, "name": LONG_TRACK})).unwrap(); + app.run("track.group", json!({"name": LONG_GROUP, "tracks": [first]})).unwrap(); + app.engine.session_mut().edit.selected_tracks.clear(); + let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state( + |ui, app: &mut SoundApp| { + let ctx = ui.ctx().clone(); + app.logic(&ctx); + app.ui(ui); + }, + app, + ); + h.run_steps(3); + h +} + +const LONG_TRACK: &str = "24H2026_27_JANVIER_SESSION_AUDIO_BED_A"; +const LONG_GROUP: &str = "Rhythm section drums bass and percussion group"; + +/// The name's paint must not be clipped any further right than its row: a wider clip lets the text +/// run over the lists' scrollbar gutter and across the panel's edge. Only the paint inside the row +/// counts — the name is drawn in its own clipped column in the edit window's headers, too. +fn name_is_clipped_to_its_row(h: &Harness<'_, SoundApp>, name: &str) { + let row = h.get_by_label(name).rect(); + let painted = h.output().shapes.iter().filter_map(|s| match &s.shape { + Shape::Text(t) if t.galley.text().contains(name) && s.clip_rect.intersects(row) => Some(s.clip_rect), + _ => None, + }); + let mut count = 0; + for clip in painted { + count += 1; + assert!(clip.right() <= row.right() + 0.5, "the name's paint is clipped at x {}, past its row's right edge {}", clip.right(), row.right()); + } + assert!(count > 0, "no painted text found for {name:?}"); +} + +#[test] +fn a_long_track_name_stays_inside_its_row() { + let h = harness(); + name_is_clipped_to_its_row(&h, LONG_TRACK); +} + +#[test] +fn a_long_group_name_stays_inside_its_row() { + let h = harness(); + name_is_clipped_to_its_row(&h, LONG_GROUP); +}