Consolidate: run clip effects over the clip and a bounded tail

render_clips allocated and ran a clip-effects workspace spanning the
whole selection for every clip with effects, however short the clip.
Many tiny effect clips in a long selection multiplied allocation and
effect processing by the selection length.

Process each clip's effects in reused 4096-frame blocks from the clip's
start (the effects start from silence, so nothing comes out before it)
through its end, then keep rendering the tail until a block falls below
-180 dBFS or 10 s past the clip's end.

crates/clap-host/src/lib.rs

@@ -222,33 +222,10 @@ mod tests {
         assert!(plugin_info("reverb").is_none());
     }
 
-    /// A new directory that this test alone created, readable only by its user on Unix. Creation
-    /// fails if the path already exists: the test then loads native libraries from it, so it must
-    /// never reuse a directory someone else could have put a library in. It lives next to the test
-    /// binary (in the build directory), not under the temp dir: `TMPDIR`/`TEMP` can name a shared
-    /// directory without a sticky bit or with inheritable write access, where another user could
-    /// rename or populate it. Anyone who can write to the build directory can already replace the
-    /// test binary itself, so this parent adds no new trust.
-    fn fresh_private_dir(prefix: &str) -> std::path::PathBuf {
-        let exe = std::env::current_exe().expect("test binary path");
-        let parent = exe.parent().expect("test binary has a parent directory");
-        let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |t| t.as_nanos());
-        let d = parent.join(format!("{prefix}-{}-{nanos}", std::process::id()));
-        #[cfg(unix)]
-        let builder = {
-            let mut b = std::fs::DirBuilder::new();
-            std::os::unix::fs::DirBuilderExt::mode(&mut b, 0o700);
-            b
-        };
-        #[cfg(not(unix))]
-        let builder = std::fs::DirBuilder::new();
-        builder.create(&d).unwrap_or_else(|e| panic!("cannot create a fresh test directory {}: {e}", d.display()));
-        d
-    }
-
     #[test]
     fn garbage_files_are_errors_not_crashes() {
-        let d = fresh_private_dir("soundcraft-clap-garbage");
+        let d = std::env::temp_dir().join(format!("soundcraft-clap-garbage-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
         std::fs::create_dir_all(d.join("Bundle.clap/Contents/MacOS")).unwrap();
         std::fs::write(d.join("garbage.clap"), b"\x7fELF this is not a plugin \x00\x01\x02").unwrap();
         std::fs::write(d.join("empty.clap"), b"").unwrap();

crates/engine/src/io.rs

@@ -734,12 +734,6 @@ fn read_bundle(bytes: &[u8], limits: BundleLimits) -> Result<(String, std::colle
     if z.len() > limits.entries {
         return Err(EngineError::Io("bundle: too many files".into()));
     }
-    // Entries are stored, so the files we keep can only outgrow the bundle when several entries
-    // point at the same bytes: a small bundle naming one payload thousands of times would be
-    // copied out once per name.
-    if z.has_overlapping_files().map_err(zerr)? {
-        return Err(EngineError::Io("bundle: files share data".into()));
-    }
     let (mut text, mut files, mut total) = (None, std::collections::HashMap::new(), 0u64);
     for i in 0..z.len() {
         let mut f = z.by_index(i).map_err(zerr)?;

crates/engine/src/io/bundle.rs

@@ -194,23 +194,6 @@ mod bundle_tests {
         }
     }
 
-    #[test]
-    fn entries_sharing_one_payload_are_refused() {
-        use std::io::Write as _;
-        let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
-        let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
-        w.start_file("Song.scraft", opts).unwrap();
-        w.write_all(Session::default().to_json().unwrap().as_bytes()).unwrap();
-        w.start_file("Audio Files/a.wav", opts).unwrap();
-        w.write_all(&[7u8; 4096]).unwrap();
-        for i in 0..100 {
-            w.shallow_copy_file("Audio Files/a.wav", &format!("Audio Files/copy{i}.wav")).unwrap();
-        }
-        let bundle = w.finish().unwrap().into_inner();
-        let err = read_bundle(&bundle, BUNDLE_LIMITS).unwrap_err();
-        assert!(err.to_string().contains("share data"), "{err}");
-    }
-
     #[test]
     fn a_bundle_is_saved_only_if_it_opens_again() {
         // #433: the writer keeps to the reader's limits.

crates/midi/src/sequence.rs

@@ -1,6 +1,4 @@
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
 
 /// A MIDI note. Times are in model ticks ([`crate::PPQ`] per quarter note).
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
@@ -110,28 +108,14 @@ impl Sequence {
 
         self.ctrls.sort_by_key(|c| c.tick);
         let mut kept: Vec<CtrlEvent> = Vec::with_capacity(self.ctrls.len());
-        // The latest tick and `kept` index of each channel+kind, so a same-tick repeat is found
-        // without rescanning the tick's events (a tick can hold many thousands of distinct keys).
-        // An entry from an earlier tick counts as absent; keeping the tick instead of clearing the
-        // map per tick keeps the work per event constant after a dense tick.
-        let mut last_at: HashMap<(u8, (u8, u8)), (i64, usize)> = HashMap::new();
         for c in self.ctrls.drain(..) {
             // Within a tick, replace an earlier event of the same channel+kind.
-            match last_at.entry((c.channel, kind_key(c.kind))) {
-                Entry::Occupied(mut e) => {
-                    let (tick, idx) = *e.get();
-                    match kept.get_mut(idx) {
-                        Some(slot) if tick == c.tick => *slot = c,
-                        _ => {
-                            e.insert((c.tick, kept.len()));
-                            kept.push(c);
-                        }
-                    }
-                }
-                Entry::Vacant(e) => {
-                    e.insert((c.tick, kept.len()));
-                    kept.push(c);
-                }
+            // Only events at the same tick (the tail of `kept`) can match.
+            let slot =
+                kept.iter_mut().rev().take_while(|k| k.tick == c.tick).find(|k| k.channel == c.channel && kind_key(k.kind) == kind_key(c.kind));
+            match slot {
+                Some(slot) => *slot = c,
+                None => kept.push(c),
             }
         }
         self.ctrls = kept;

crates/midi/tests/it/ops.rs

@@ -222,72 +222,3 @@ fn sequence_serde_round_trip() {
     let json = serde_json::to_string(&seq).unwrap();
     assert_eq!(serde_json::from_str::<Sequence>(&json).unwrap(), seq);
 }
-
-#[test]
-fn remove_duplicates_handles_a_large_same_tick_controller_group() {
-    // Every channel x controller number at one tick, twice: the second copy of each wins. A
-    // rescan of the tick's kept events per incoming event would make this quadratic.
-    let keys: Vec<(u8, u8)> = (0..=255u8).flat_map(|ch| (0..=255u8).map(move |cc| (ch, cc))).collect();
-    let ctrls = [0, 1]
-        .iter()
-        .flat_map(|&pass| keys.iter().map(move |&(channel, cc)| CtrlEvent { tick: 7, channel, kind: CtrlKind::Cc(cc), value: pass }))
-        .collect();
-    let mut seq = Sequence { notes: Vec::new(), ctrls };
-    let start = std::time::Instant::now();
-    assert_eq!(seq.remove_duplicates(), keys.len());
-    assert!(start.elapsed() < std::time::Duration::from_secs(10), "{:?}", start.elapsed());
-    assert_eq!(seq.ctrls.len(), keys.len());
-    assert!(seq.ctrls.iter().all(|c| c.value == 1));
-}
-
-#[test]
-fn remove_duplicates_matches_a_per_tick_rescan_on_mixed_ticks() {
-    // The straightforward per-tick rescan the indexed version replaced, kept as an oracle.
-    fn reference(mut ctrls: Vec<CtrlEvent>) -> Vec<CtrlEvent> {
-        ctrls.sort_by_key(|c| c.tick);
-        let key = |k: CtrlKind| match k {
-            CtrlKind::Cc(n) => (0, n),
-            CtrlKind::PitchBend => (1, 0),
-            CtrlKind::ChannelPressure => (2, 0),
-            CtrlKind::PolyPressure(p) => (3, p),
-            CtrlKind::Program => (4, 0),
-        };
-        let mut kept: Vec<CtrlEvent> = Vec::new();
-        for c in ctrls {
-            match kept.iter_mut().rev().take_while(|k| k.tick == c.tick).find(|k| k.channel == c.channel && key(k.kind) == key(c.kind)) {
-                Some(slot) => *slot = c,
-                None => kept.push(c),
-            }
-        }
-        kept
-    }
-
-    // Few ticks, channels and kinds, so the same key recurs both within a tick (interleaved with
-    // other keys) and across ticks; unsorted input from a fixed xorshift stream.
-    let mut state = 0x9E37_79B9_7F4A_7C15u64;
-    let mut next = move || {
-        state ^= state << 13;
-        state ^= state >> 7;
-        state ^= state << 17;
-        state
-    };
-    let kinds = |r: u64| match r % 5 {
-        0 => CtrlKind::Cc((r >> 8) as u8 % 4),
-        1 => CtrlKind::PitchBend,
-        2 => CtrlKind::ChannelPressure,
-        3 => CtrlKind::PolyPressure((r >> 8) as u8 % 4),
-        _ => CtrlKind::Program,
-    };
-    for round in 0..200 {
-        let mut ctrls = Vec::new();
-        for i in 0..(next() % 64) {
-            let r = next();
-            ctrls.push(CtrlEvent { tick: (r % 6) as i64 - 2, channel: (r >> 16) as u8 % 3, kind: kinds(r >> 24), value: (round * 100 + i) as i32 });
-        }
-        let mut seq = Sequence { notes: Vec::new(), ctrls: ctrls.clone() };
-        let removed = seq.remove_duplicates();
-        let expected = reference(ctrls.clone());
-        assert_eq!(seq.ctrls, expected, "round {round}");
-        assert_eq!(removed, ctrls.len() - expected.len(), "round {round}");
-    }
-}

crates/mix/src/offline.rs

@@ -131,33 +131,60 @@ pub fn fold_down_stereo(fmt: ChannelFormat, ch: &[Vec<f32>]) -> Vec<Vec<f32>> {
     out
 }
 
+/// Block size for clip effects in [`render_clips`].
+const CLIP_FX_BLOCK: usize = 4096;
+/// Most a clip effect keeps rendering past its clip's end in [`render_clips`], in seconds.
+const MAX_CLIP_FX_TAIL_SECONDS: f64 = 10.0;
+/// A tail block whose peak is below this (-180 dBFS) ends a clip effect's tail.
+const CLIP_FX_TAIL_FLOOR: f32 = 1e-9;
+
 /// Render only one track's clips (no mixer processing) — Consolidate.
 pub fn render_clips(s: &Session, track: TrackId, range: Range) -> Vec<Vec<f32>> {
     let Some(t) = s.track(track) else { return Vec::new() };
     let len = usize::try_from(range.len().max(0)).unwrap_or(0).min(MAX_RENDER_SAMPLES / t.channels().max(1));
     let mut out = vec![vec![0.0f32; len]; t.channels().max(1)];
     let mut scratch = Vec::new();
+    // One reusable block for every clip with effects.
+    let mut block: Vec<Vec<f32>> = Vec::new();
+    let max_tail = s.sample_rate.samples(MAX_CLIP_FX_TAIL_SECONDS).max(0);
     for c in t.clips().iter().filter(|c| !c.muted && c.range().overlaps(&range)) {
         match clip_fx_params(s, c.id.0) {
             None => render_clip(s, c, range.start, len, &mut out, &mut scratch),
             Some(params) => {
-                let mut tmp = vec![vec![0.0f32; len]; out.len()];
-                render_clip(s, c, range.start, len, &mut tmp, &mut scratch);
-                let mut fx = ClipFx::new(s.sample_rate.as_f64() as f32, tmp.len());
+                if block.len() != out.len() {
+                    block = vec![vec![0.0f32; CLIP_FX_BLOCK]; out.len()];
+                }
+                let mut fx = ClipFx::new(s.sample_rate.as_f64() as f32, out.len());
                 fx.configure(params);
-                let mut done = 0;
+                // The effects start from silence, so nothing comes out before the clip starts:
+                // process from there through the clip and a bounded tail, not the whole selection.
+                let offset = |at: Samples| usize::try_from(at.saturating_sub(range.start).max(0)).unwrap_or(usize::MAX).min(len);
+                let first = offset(c.start);
+                let clip_end = offset(c.end());
+                let tail_end = offset(c.end().saturating_add(max_tail));
+                let mut done = first;
                 while done < len {
-                    let n = (len - done).min(4096);
-                    let mut block: Vec<Vec<f32>> = tmp.iter().map(|ch| ch.get(done..done + n).map(<[f32]>::to_vec).unwrap_or_default()).collect();
+                    let n = (len - done).min(CLIP_FX_BLOCK);
+                    for ch in &mut block {
+                        ch.fill(0.0);
+                    }
+                    if done < clip_end {
+                        render_clip(s, c, range.start.saturating_add(done as i64), n, &mut block, &mut scratch);
+                    }
                     fx.process(&mut block, n);
+                    let mut peak = 0.0f32;
                     for (o, b) in out.iter_mut().zip(block.iter()) {
                         if let Some(dst) = o.get_mut(done..done + n) {
                             for (x, y) in dst.iter_mut().zip(b.iter()) {
                                 *x += *y;
+                                peak = peak.max(y.abs());
                             }
                         }
                     }
                     done += n;
+                    if done >= clip_end && (done >= tail_end || peak < CLIP_FX_TAIL_FLOOR) {
+                        break;
+                    }
                 }
             }
         }

crates/mix/src/routing.rs

@@ -46,8 +46,7 @@ pub(crate) fn processing_order(s: &Session) -> Vec<usize> {
     } 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.
-        let depths = bounded_aux_depths(s);
-        auxes.sort_by_key(|&i| depths.get(i).copied().unwrap_or(0));
+        auxes.sort_by_key(|&i| bounded_aux_depth(s, i));
     }
     order.extend(auxes);
     order
@@ -116,38 +115,32 @@ fn aux_output_busses(t: &Track) -> impl Iterator<Item = BusId> + '_ {
         .filter_map(|route| if let Route::Bus(bus) = route { Some(*bus) } else { None })
 }
 
-/// Hop cap for the bounded depth used when the aux graph has a cycle.
-const MAX_BOUNDED_DEPTH: usize = 8;
-
-/// For each track, the bounded depth used for a cyclic graph: the length of the longest chain of
-/// Aux/Folder feeders into it (through a bus its input reads and the feeder's output or a send
-/// writes), capped at [`MAX_BOUNDED_DEPTH`] hops. One pass per hop over the tracks and their bus
-/// writes, so the cost is linear in the routing, not a fresh feeder search per track per
-/// sort comparison.
-fn bounded_aux_depths(s: &Session) -> Vec<usize> {
-    let is_aux = |t: &Track| matches!(t.kind, TrackKind::Aux | TrackKind::Folder);
-    // Tracks with a feeder chain of the current length ending at them (length 0: every aux).
-    let mut reached: Vec<bool> = s.tracks.iter().map(is_aux).collect();
-    let mut depths = vec![0usize; s.tracks.len()];
-    let mut fed = std::collections::HashSet::<BusId>::new();
-    for hop in 1..=MAX_BOUNDED_DEPTH {
-        fed.clear();
-        for (t, _) in s.tracks.iter().zip(&reached).filter(|(t, r)| **r && is_aux(t)) {
-            fed.extend(aux_output_busses(t));
-        }
-        let mut any = false;
-        for ((t, r), d) in s.tracks.iter().zip(reached.iter_mut()).zip(depths.iter_mut()) {
-            *r = matches!(&t.mixer.input, Route::Bus(b) if fed.contains(b));
-            if *r {
-                *d = hop;
-                any = true;
-            }
-        }
-        if !any {
+/// 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<usize> = auxes_feeding(s, &inputs);
+        if feeders.is_empty() {
             break;
         }
+        d += 1;
+        cur = feeders;
     }
-    depths
+    d
+}
+
+fn auxes_feeding(s: &Session, inputs: &[&Route]) -> Vec<usize> {
+    s.tracks
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| matches!(t.kind, TrackKind::Aux | TrackKind::Folder))
+        .filter(|(_, t)| {
+            inputs.iter().any(|r| matches!(r, Route::Bus(_)) && (&&t.mixer.output == r || t.mixer.sends.iter().flatten().any(|sn| &&sn.target == r)))
+        })
+        .map(|(i, _)| i)
+        .collect()
 }
 
 /// Implicit solo: an aux is not muted when a soloed track feeds its input bus.
@@ -211,81 +204,4 @@ mod processing_order_tests {
         // 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]);
     }
-
-    /// The per-track feeder search `bounded_aux_depths` replaced, kept as its reference.
-    fn reference_depth(s: &Session, i: usize) -> usize {
-        let mut d = 0;
-        let mut cur = vec![i];
-        for _ in 0..MAX_BOUNDED_DEPTH {
-            let inputs: Vec<&Route> = cur.iter().filter_map(|&k| s.tracks.get(k)).map(|t| &t.mixer.input).collect();
-            let feeders: Vec<usize> = s
-                .tracks
-                .iter()
-                .enumerate()
-                .filter(|(_, t)| matches!(t.kind, TrackKind::Aux | TrackKind::Folder))
-                .filter(|(_, t)| {
-                    inputs
-                        .iter()
-                        .any(|r| matches!(r, Route::Bus(_)) && (&&t.mixer.output == r || t.mixer.sends.iter().flatten().any(|sn| &&sn.target == r)))
-                })
-                .map(|(i, _)| i)
-                .collect();
-            if feeders.is_empty() {
-                break;
-            }
-            d += 1;
-            cur = feeders;
-        }
-        d
-    }
-
-    #[test]
-    fn bounded_depths_match_the_per_track_feeder_search() {
-        // A small pseudo-random graph of auxes, folders and audio tracks with cycles, joins,
-        // sends and unrouted inputs.
-        let mut s = Session::default();
-        let busses: Vec<_> = (0..6).map(|i| s.add_bus(&format!("B{i}"), ChannelFormat::Stereo)).collect();
-        let mut x = 12345u32;
-        let mut next = |m: usize| {
-            x = x.wrapping_mul(1_103_515_245).wrapping_add(12_345);
-            (x >> 16) as usize % m
-        };
-        for i in 0..30 {
-            let kind = [TrackKind::Aux, TrackKind::Folder, TrackKind::Audio][next(3)];
-            let id = s.add_track(kind, ChannelFormat::Stereo, None);
-            let pick = |n: usize| if n < busses.len() { Route::Bus(busses[n]) } else { Route::Main };
-            let (input, output, send) = (pick(next(8)), pick(next(8)), pick(next(8)));
-            let t = s.track_mut(id).unwrap();
-            t.mixer.input = input;
-            t.mixer.output = output;
-            if i % 2 == 0 {
-                t.mixer.sends[0] = Some(SendSlot::new(send));
-            }
-        }
-        let depths = bounded_aux_depths(&s);
-        for (i, (t, depth)) in s.tracks.iter().zip(&depths).enumerate() {
-            if matches!(t.kind, TrackKind::Aux | TrackKind::Folder) {
-                assert_eq!(*depth, reference_depth(&s, i), "track {i}");
-            }
-        }
-        assert!(depths.contains(&MAX_BOUNDED_DEPTH));
-    }
-
-    #[test]
-    fn a_large_cyclic_graph_orders_quickly() {
-        // Thousands of auxes all reading and writing one bus: every aux feeds every other.
-        let mut s = Session::default();
-        let bus = s.add_bus("Loop", ChannelFormat::Stereo);
-        for _ in 0..3000 {
-            let id = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None);
-            let t = s.track_mut(id).unwrap();
-            t.mixer.input = Route::Bus(bus);
-            t.mixer.output = Route::Bus(bus);
-            t.mixer.sends[0] = Some(SendSlot::new(Route::Bus(bus)));
-        }
-        let start = std::time::Instant::now();
-        let order = processing_order(&s);
-        assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
-        assert_eq!(order, (0..3000).collect::<Vec<_>>());
-    }
 }

crates/mix/src/strip.rs

@@ -24,9 +24,6 @@ pub(crate) struct PluginSlot {
     pub(crate) plugin: Box<dyn Plugin>,
     /// Last values pushed to the plugin, in the insert's parameter-map order.
     applied: Vec<f32>,
-    /// Scratch for `apply_params`: indexes of the track's automation lanes for this slot, kept
-    /// so the audio thread reuses its allocation.
-    lanes: Vec<usize>,
     pub(crate) failed: bool,
 }
 
@@ -194,7 +191,7 @@ impl SlotCtx<'_> {
             let state = if third { ins.state_bytes() } else { None };
             create_instance(&ins.plugin, state.as_deref(), self.sr, self.mb, ch).map(|n| n.plugin)
         }?;
-        Some(PluginSlot { id: ins.plugin.clone(), ch, plugin, applied: Vec::new(), lanes: Vec::new(), failed: false })
+        Some(PluginSlot { id: ins.plugin.clone(), ch, plugin, applied: Vec::new(), failed: false })
     }
 }
 
@@ -494,40 +491,21 @@ pub(crate) fn apply_params(slot: &mut PluginSlot, ins: &soundcraft_model::Insert
     let Ok(slot_u8) = u8::try_from(i) else {
         return apply_values(slot, ins, |_, v| v);
     };
-    let lanes = &t.automation;
-    let name = |j: usize| match lanes.get(j).map(|l| &l.param) {
-        Some(AutoParam::Plugin { param, .. }) => param.as_str(),
-        _ => "",
-    };
-    // This slot's lanes, ordered by parameter name (the parameter map's order) and keeping only
-    // the first lane per name (the one a lookup by name finds). Matching them to the parameters
-    // in one merge costs O(lanes log lanes + params) per block, not O(lanes x params).
-    let mut order = std::mem::take(&mut slot.lanes);
-    order.clear();
-    if t.mixer.automation_mode.reads() {
-        order
-            .extend(lanes.iter().enumerate().filter(|(_, l)| matches!(&l.param, AutoParam::Plugin { slot, .. } if *slot == slot_u8)).map(|(j, _)| j));
-        if !order.iter().any(|&j| lanes.get(j).is_some_and(|l| !l.points.is_empty())) {
-            order.clear();
-        }
-        order.sort_unstable_by(|&a, &b| name(a).cmp(name(b)).then(a.cmp(&b)));
-        order.dedup_by(|later, kept| name(*later) == name(*kept));
-    }
-    let mut next = order.iter().copied().peekable();
+    let automated = t.mixer.automation_mode.reads()
+        && t.automation.iter().any(|l| matches!(&l.param, AutoParam::Plugin { slot, .. } if *slot == slot_u8) && !l.points.is_empty());
     apply_values(slot, ins, |k, val| {
-        while next.next_if(|&j| name(j) < k).is_some() {}
-        if let Some(l) = next.peek().filter(|&&j| name(j) == k).and_then(|&j| lanes.get(j))
+        if automated
+            && let Some(l) = t.automation.iter().find(|l| matches!(&l.param, AutoParam::Plugin { slot, param } if *slot == slot_u8 && param == k))
             && !l.points.is_empty()
         {
             return l.value_at(pos, val);
         }
         val
     });
-    slot.lanes = order;
 }
 
 /// Sends each stored param (as mapped by `value`) to the plugin when it changed since last time.
-fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, mut value: impl FnMut(&str, f32) -> f32) {
+fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, value: impl Fn(&str, f32) -> f32) {
     if slot.applied.len() != ins.params.len() {
         slot.applied = vec![f32::NAN; ins.params.len()];
     }
@@ -539,99 +517,3 @@ fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, mut value
         }
     }
 }
-
-#[cfg(test)]
-mod apply_params_tests {
-    use super::*;
-    use soundcraft_model::{AutomationLane, Insert};
-    use std::sync::Mutex;
-
-    /// A built-in gain that logs every parameter set.
-    struct Recorder {
-        inner: Box<dyn Plugin>,
-        sets: Arc<Mutex<Vec<(String, f32)>>>,
-    }
-
-    impl Plugin for Recorder {
-        fn info(&self) -> &'static soundcraft_dsp::PluginInfo {
-            self.inner.info()
-        }
-        fn prepare(&mut self, sr: f32, mb: usize, ch: usize) {
-            self.inner.prepare(sr, mb, ch);
-        }
-        fn reset(&mut self) {
-            self.inner.reset();
-        }
-        fn set_param(&mut self, id: &str, v: f32) -> bool {
-            self.sets.lock().unwrap().push((id.to_string(), v));
-            true
-        }
-        fn param(&self, id: &str) -> Option<f32> {
-            self.inner.param(id)
-        }
-        fn process(&mut self, io: &mut [Vec<f32>], frames: usize) {
-            self.inner.process(io, frames);
-        }
-    }
-
-    fn recorder() -> (PluginSlot, Arc<Mutex<Vec<(String, f32)>>>) {
-        let sets = Arc::new(Mutex::new(Vec::new()));
-        let plugin = Box::new(Recorder { inner: soundcraft_dsp::create("gain").unwrap(), sets: Arc::clone(&sets) });
-        (PluginSlot { id: "gain".into(), ch: 2, plugin, applied: Vec::new(), lanes: Vec::new(), failed: false }, sets)
-    }
-
-    fn lane(slot: u8, param: &str, point: Option<f32>) -> AutomationLane {
-        let mut l = AutomationLane::new(AutoParam::Plugin { slot, param: param.into() });
-        if let Some(v) = point {
-            l.set_point(0, v);
-        }
-        l
-    }
-
-    #[test]
-    fn first_lane_per_param_of_this_slot_drives_it() {
-        let mut s = Session::default();
-        let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None);
-        let tr = s.track_mut(t).unwrap();
-        tr.automation = vec![
-            lane(0, "c", None),
-            lane(1, "a", Some(5.0)),
-            lane(0, "b", Some(9.0)),
-            lane(0, "c", Some(7.0)),
-            lane(0, "zz", Some(1.0)),
-            lane(0, "b", Some(8.0)),
-        ];
-        let mut ins = Insert::new("gain");
-        for (k, v) in [("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0)] {
-            ins.params.insert(k.into(), v);
-        }
-        let (mut slot, sets) = recorder();
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        let got = sets.lock().unwrap().clone();
-        let want: Vec<(String, f32)> = [("a", 1.0), ("b", 9.0), ("c", 3.0), ("d", 4.0)].iter().map(|(k, v)| (k.to_string(), *v)).collect();
-        assert_eq!(got, want);
-        // Unchanged values are not sent again.
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        assert_eq!(sets.lock().unwrap().len(), 4);
-    }
-
-    #[test]
-    fn many_params_and_lanes_apply_without_a_quadratic_search() {
-        let n = 40_000;
-        let mut s = Session::default();
-        let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None);
-        let tr = s.track_mut(t).unwrap();
-        tr.automation = (0..n).rev().map(|i| lane(0, &format!("p{i:06}"), Some(i as f32))).collect();
-        let mut ins = Insert::new("gain");
-        for i in 0..n {
-            ins.params.insert(format!("p{i:06}"), -1.0);
-        }
-        let (mut slot, sets) = recorder();
-        let start = std::time::Instant::now();
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
-        let got = sets.lock().unwrap();
-        assert_eq!(got.len(), n);
-        assert!(got.iter().all(|(k, v)| k == &format!("p{:06}", *v as usize)));
-    }
-}

crates/mix/src/tests.rs

@@ -1208,3 +1208,74 @@ fn gain_ramp_matches_converting_both_ends_every_sample() {
         }
     }
 }
+
+/// Consolidate's clip-effect pass, processing every clip's effects across the whole selection
+/// (what `render_clips` did before it limited them to the clip and its tail).
+fn render_clips_full_span(s: &Session, track: TrackId, range: Range) -> Vec<Vec<f32>> {
+    let t = s.track(track).unwrap();
+    let len = range.len() as usize;
+    let mut out = vec![vec![0.0f32; len]; t.channels().max(1)];
+    let mut scratch = Vec::new();
+    for c in t.clips().iter().filter(|c| !c.muted && c.range().overlaps(&range)) {
+        let params = crate::clips::clip_fx_params(s, c.id.0).unwrap();
+        let mut tmp = vec![vec![0.0f32; len]; out.len()];
+        crate::clips::render_clip(s, c, range.start, len, &mut tmp, &mut scratch);
+        let mut fx = crate::clips::ClipFx::new(48_000.0, tmp.len());
+        fx.configure(params);
+        for done in (0..len).step_by(4096) {
+            let n = (len - done).min(4096);
+            let mut block: Vec<Vec<f32>> = tmp.iter().map(|ch| ch[done..done + n].to_vec()).collect();
+            fx.process(&mut block, n);
+            for (o, b) in out.iter_mut().zip(&block) {
+                o[done..done + n].iter_mut().zip(b).for_each(|(x, y)| *x += y);
+            }
+        }
+    }
+    out
+}
+
+#[test]
+fn consolidate_clip_effects_cover_the_clip_and_its_tail() {
+    let fx_sets: [&[(&str, f64)]; 2] = [&[("comp.lookahead", 5.0), ("comp.threshold", -20.0), ("gain", -6.0)], &[("eq.hpf_on", 1.0), ("gain", 3.0)]];
+    for (k, params) in fx_sets.iter().enumerate() {
+        let mut s = Session::default();
+        let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None);
+        s.pool.insert(SourceId(900), Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: vec![vec![0.5; 4800]] })));
+        let cid = s.new_clip_id();
+        s.track_mut(t).unwrap().playlist_mut().unwrap().clips.push(Clip::audio(cid, "dc", SourceId(900), 0, 20_000, 4800));
+        for (param, value) in params.iter() {
+            s.edit.values.insert(format!("clip_fx.{}.{param}", cid.0), *value);
+        }
+        let range = Range::new(5_000, 100_000);
+        let got = render_clips(&s, t, range);
+        let want = render_clips_full_span(&s, t, range);
+        assert_eq!(got.len(), want.len());
+        assert!(want[0].iter().any(|x| x.abs() > 0.05), "the fixture should sound");
+        if k == 0 {
+            // The compressor's lookahead output after the clip's end is kept.
+            assert!(got[0][20_000 + 4800 - 5_000 + 10].abs() > 1e-3);
+        }
+        for (i, (a, b)) in got[0].iter().zip(&want[0]).enumerate() {
+            assert!((a - b).abs() < 1e-5, "set {k}, sample {i}: {a} vs {b}");
+        }
+    }
+}
+
+#[test]
+fn consolidate_many_tiny_effect_clips_stays_fast() {
+    // Thousands of one-sample clips with effects across a long selection: each one is processed
+    // over its own span, not the whole selection.
+    let mut s = Session::default();
+    let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None);
+    s.pool.insert(SourceId(900), Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: vec![vec![0.5; 1]] })));
+    for i in 0..2000i64 {
+        let cid = s.new_clip_id();
+        s.track_mut(t).unwrap().playlist_mut().unwrap().clips.push(Clip::audio(cid, "x", SourceId(900), 0, i * 1000, 1));
+        s.edit.values.insert(format!("clip_fx.{}.gain", cid.0), -6.0);
+    }
+    let start = std::time::Instant::now();
+    let out = render_clips(&s, t, Range::new(0, 4_000_000));
+    assert!(start.elapsed() < std::time::Duration::from_secs(10), "{:?}", start.elapsed());
+    assert!((out[0][1000] - 0.5 * db_to_gain(-6.0)).abs() < 1e-6);
+    assert_eq!(out[0][1001], 0.0);
+}