a02d892f831f
strip_mute_automation.rs
//! Ordinary strip mute changes sample gates without splitting processor blocks.
use craft_audio::AudioBuffer;
use soundcraft_dsp::Plugin;
use soundcraft_mix::{MixEngine, PreparedInstance, render_range};
use soundcraft_model::{
AutoParam, AutomationLane, AutomationMode, ChannelFormat, Clip, Insert, Route, SendSlot, Session, SourceAudio, SourceId, TrackId, TrackKind,
};
use soundcraft_time::Range;
use std::sync::{Arc, Mutex};
const LEN: usize = 768;
fn fixture() -> (Session, TrackId) {
let mut s = Session::default();
s.pool.insert(SourceId(901), Arc::new(SourceAudio::new(AudioBuffer { sample_rate: 48_000, channels: vec![vec![0.25; LEN]; 2] })));
let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, Some("Source"));
let clip = s.new_clip_id();
let tr = s.track_mut(t).unwrap();
tr.playlist_mut().unwrap().clips.push(Clip::audio(clip, "tone", SourceId(901), 0, 0, LEN as i64));
tr.mixer.pan = vec![-1.0, 1.0];
tr.mixer.output = Route::Main;
(s, t)
}
fn mute(s: &mut Session, t: TrackId, start: i64, end: i64) {
let lane = s.track_mut(t).unwrap().lane_mut(&AutoParam::Mute);
for (at, value) in [(0, 0.0), (start - 1, 0.0), (start, 1.0), (end - 1, 1.0), (end, 0.0)] {
lane.set_point(at, value);
}
}
fn rendered(s: &Session, block: usize) -> Vec<Vec<f32>> {
render_range(s, Range::new(0, LEN as i64), block)
}
fn gated(actual: &[Vec<f32>], reference: &[Vec<f32>], start: usize, end: usize) {
assert_eq!(actual.len(), reference.len());
assert!(reference.iter().flatten().any(|x| x.abs() > 0.01));
for (got, want) in actual.iter().zip(reference) {
assert_eq!(got.len(), LEN);
for i in 0..LEN {
assert_eq!(got[i], if (start..end).contains(&i) { 0.0 } else { want[i] }, "frame {i}");
}
}
}
#[test]
fn internal_and_exact_block_edges_are_partition_independent() {
for (start, end) in [(101, 200), (128, 256), (1, 767)] {
let (mut s, t) = fixture();
let reference = rendered(&s, 512);
mute(&mut s, t, start, end);
for block in [16, 63, 128, 512, 1024] {
gated(&rendered(&s, block), &reference, start as usize, end as usize);
}
}
}
#[test]
fn existing_held_mute_curve_and_threshold_are_preserved() {
let (mut s, t) = fixture();
let reference = rendered(&s, 512);
let lane = s.track_mut(t).unwrap().lane_mut(&AutoParam::Mute);
lane.set_point(0, 0.49);
lane.set_point(200, 0.5);
gated(&rendered(&s, 512), &reference, 200, LEN);
}
#[test]
fn pre_and_post_fader_send_audio_share_the_track_mute_gate() {
for pre in [false, true] {
let (mut s, t) = fixture();
let bus = s.add_bus("Send", ChannelFormat::Stereo);
let aux = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, Some("Return"));
s.track_mut(aux).unwrap().mixer.input = Route::Bus(bus);
s.track_mut(aux).unwrap().mixer.output = Route::Main;
let tr = s.track_mut(t).unwrap();
tr.mixer.output = Route::None;
tr.mixer.volume_db = -9.0;
let mut send = SendSlot::new(Route::Bus(bus));
send.pre_fader = pre;
send.level_db = -3.0;
tr.mixer.sends[0] = Some(send);
let reference = rendered(&s, 512);
mute(&mut s, t, 101, 200);
for block in [63, 512] {
gated(&rendered(&s, block), &reference, 101, 200);
}
}
}
#[test]
fn off_empty_and_first_empty_lane_keep_exact_unautomated_pcm() {
let (mut s, t) = fixture();
let reference = rendered(&s, 512);
s.track_mut(t).unwrap().lane_mut(&AutoParam::Mute);
assert_eq!(rendered(&s, 512), reference);
let mut second = AutomationLane::new(AutoParam::Mute);
second.set_point(0, 1.0);
s.track_mut(t).unwrap().automation.push(second);
assert_eq!(rendered(&s, 512), reference, "first empty lane remains authoritative");
s.track_mut(t).unwrap().automation.clear();
mute(&mut s, t, 101, 200);
s.track_mut(t).unwrap().mixer.automation_mode = AutomationMode::Off;
assert_eq!(rendered(&s, 512), reference);
}
#[test]
fn reading_modes_retain_existing_policy() {
for mode in AutomationMode::ALL.into_iter().filter(|mode| mode.reads()) {
let (mut s, t) = fixture();
let reference = rendered(&s, 512);
mute(&mut s, t, 101, 200);
s.track_mut(t).unwrap().mixer.automation_mode = mode;
gated(&rendered(&s, 512), &reference, 101, 200);
}
}
#[test]
fn static_mute_and_solo_suppression_cannot_be_reopened_by_automation() {
for solo in [false, true] {
let (mut s, t) = fixture();
if solo {
let other = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None);
s.track_mut(other).unwrap().mixer.solo = true;
} else {
s.track_mut(t).unwrap().mixer.mute = true;
}
let reference = rendered(&s, 512);
assert!(reference.iter().flatten().all(|x| x.abs() < 1e-6));
mute(&mut s, t, 101, 200);
gated_silent(&rendered(&s, 512));
}
}
fn gated_silent(output: &[Vec<f32>]) {
assert!(output.iter().flatten().all(|x| x.abs() < 1e-6));
}
#[test]
fn aux_and_folder_inputs_gate_their_audio_inside_the_block() {
for kind in [TrackKind::Aux, TrackKind::Folder] {
let (mut s, source) = fixture();
let bus = s.add_bus("Input", ChannelFormat::Stereo);
s.track_mut(source).unwrap().mixer.output = Route::Bus(bus);
let target = s.add_track(kind, ChannelFormat::Stereo, Some("Return"));
s.track_mut(target).unwrap().mixer.input = Route::Bus(bus);
s.track_mut(target).unwrap().mixer.output = Route::Main;
let reference = rendered(&s, 512);
mute(&mut s, target, 101, 200);
gated(&rendered(&s, 512), &reference, 101, 200);
}
}
#[test]
fn no_active_mute_lane_preserves_fader_and_pan_schedules_exactly() {
let (mut s, t) = fixture();
for (param, a, b) in [(AutoParam::Volume, -12.0, -3.0), (AutoParam::Pan(0), -1.0, 0.5)] {
let lane = s.track_mut(t).unwrap().lane_mut(¶m);
lane.set_point(0, a);
lane.set_point(LEN as i64, b);
}
for block in [63, 256, 512] {
let reference = rendered(&s, block);
let mut with_lane = s.clone();
with_lane.track_mut(t).unwrap().lane_mut(&AutoParam::Mute).set_point(0, 0.0);
assert_eq!(rendered(&with_lane, block), reference);
with_lane.track_mut(t).unwrap().mixer.automation_mode = AutomationMode::Off;
let mut no_lane = with_lane.clone();
no_lane.track_mut(t).unwrap().automation.retain(|lane| lane.param != AutoParam::Mute);
assert_eq!(rendered(&with_lane, block), rendered(&no_lane, block));
}
}
#[test]
fn static_vca_mute_remains_dominant_over_member_mute_automation() {
let (mut s, t) = fixture();
let vca = s.add_track(TrackKind::Vca, ChannelFormat::Stereo, Some("VCA"));
s.track_mut(vca).unwrap().mixer.mute = true;
s.track_mut(t).unwrap().mixer.vca = Some(vca.0);
let reference = rendered(&s, 512);
gated_silent(&reference);
mute(&mut s, t, 101, 200);
gated_silent(&rendered(&s, 512));
}
struct Counted {
inner: Box<dyn Plugin>,
calls: Arc<Mutex<Vec<usize>>>,
instrument: bool,
}
impl Plugin for Counted {
fn info(&self) -> &'static soundcraft_dsp::PluginInfo {
self.inner.info()
}
fn prepare(&mut self, sr: f32, block: usize, ch: usize) {
self.inner.prepare(sr, block, ch);
}
fn reset(&mut self) {
self.inner.reset();
}
fn set_param(&mut self, id: &str, value: f32) -> bool {
self.inner.set_param(id, value)
}
fn param(&self, id: &str) -> Option<f32> {
self.inner.param(id)
}
fn process(&mut self, io: &mut [Vec<f32>], frames: usize) {
self.calls.lock().unwrap().push(frames);
if self.instrument {
for channel in io {
channel.iter_mut().take(frames).for_each(|sample| *sample = 0.25);
}
} else {
self.inner.process(io, frames);
}
}
}
#[test]
fn hosted_processing_keeps_the_callers_blocks_and_unmuted_pcm() {
for instrument in [false, true] {
let (mut s, t) = fixture();
let reference = rendered(&s, 256);
mute(&mut s, t, 101, 200);
let slot = if instrument {
s.track_mut(t).unwrap().kind = TrackKind::Instrument;
s.track_mut(t).unwrap().instrument = Some(Insert::new("clap:test.mute-cadence"));
soundcraft_mix::INSTRUMENT_SLOT
} else {
s.track_mut(t).unwrap().mixer.inserts[0] = Some(Insert::new("clap:test.mute-cadence"));
0
};
let calls = Arc::new(Mutex::new(Vec::with_capacity(4)));
let mut plugin = soundcraft_dsp::create("gain").unwrap();
plugin.prepare(48_000.0, 256, 2);
let mut mix = MixEngine::new(48_000.0, 256);
mix.set_external_instances(true);
mix.adopt(vec![PreparedInstance {
track: t,
slot,
id: "clap:test.mute-cadence".into(),
ch: 2,
plugin: Box::new(Counted { inner: plugin, calls: Arc::clone(&calls), instrument }),
}]);
let mut output = vec![Vec::new(); 2];
for (pos, frames) in [(0, 256), (256, 128), (384, 256), (640, 128)] {
let mut block = vec![vec![0.0; frames]; 2];
mix.render(&s, pos, frames, &mut block);
for (out, channel) in output.iter_mut().zip(block) {
out.extend(channel);
}
}
assert_eq!(*calls.lock().unwrap(), vec![256, 128, 256, 128]);
gated(&output, &reference, 101, 200);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.