a02d892f831f
edit_more.rs
//! More Edit menu commands: Cut/Copy/Clear Special variants, Paste Special, selection helpers,
//! Space Clips, Snap to, Copy/Move Selection to playlists, TCE, and automation coalesce/trim/glide.
use super::{
CommandSpec, always, bad, clip_ids_param, has_clipboard, has_range, has_selection, position_param, range_param, str_param, tracks_required,
};
use super::more_util::{clip_db, render_stretched, replace_clip, set_clip_env, target_playlist};
use crate::edit as ops;
use crate::{Clipboard, Engine, Result, TransportRequest, cmd};
use serde_json::{Value, json};
use soundcraft_model::{AutoParam, AutomationLane, Clip, ClipContent, ClipId, EditMode, Playlist, Session};
use soundcraft_time::{Range, Samples};
#[derive(Clone, Copy, PartialEq)]
enum Lanes {
All,
Pan,
Plugin,
}
impl Lanes {
fn hit(self, p: &AutoParam) -> bool {
match self {
Lanes::All => true,
Lanes::Pan => matches!(p, AutoParam::Pan(_)),
Lanes::Plugin => matches!(p, AutoParam::Plugin { .. }),
}
}
}
#[derive(Clone, Copy, PartialEq)]
enum Dest {
Target,
New,
Duplicate,
}
fn has_clip_gain_clipboard(e: &Engine) -> std::result::Result<(), String> {
if e.clipboard.clip_gain.is_empty() { Err("no clip gain has been copied".into()) } else { Ok(()) }
}
fn has_clip_effects_clipboard(e: &Engine) -> std::result::Result<(), String> {
if e.clipboard.clip_effects.is_empty() { Err("no clip effects have been copied".into()) } else { Ok(()) }
}
fn has_automation_clipboard(e: &Engine) -> std::result::Result<(), String> {
if e.clipboard.automation.iter().flatten().any(|l| !l.points.is_empty()) { Ok(()) } else { Err("no automation has been copied".into()) }
}
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"edit.cut_pan_automation",
"Pan Automation",
["Edit", "Cut Special"],
None,
"{tracks?, start?, end?} β cuts pan automation only to the clipboard",
has_range,
|e, p| auto_copy(e, p, Lanes::Pan, true, "edit.cut_pan_automation")
),
cmd!(
"edit.cut_plugin_automation",
"Plugin Automation",
["Edit", "Cut Special"],
None,
"{tracks?, start?, end?} β cuts plug-in automation only",
has_range,
|e, p| auto_copy(e, p, Lanes::Plugin, true, "edit.cut_plugin_automation")
),
cmd!(noundo "edit.copy_all_automation", "All Automation", ["Edit", "Copy Special"], None, "{tracks?, start?, end?} β copies automation only (no clips)", has_range, |e, p| auto_copy(e, p, Lanes::All, false, "edit.copy_all_automation")),
cmd!(noundo "edit.copy_pan_automation", "Pan Automation", ["Edit", "Copy Special"], None, "{tracks?, start?, end?}", has_range, |e, p| auto_copy(e, p, Lanes::Pan, false, "edit.copy_pan_automation")),
cmd!(noundo "edit.copy_plugin_automation", "Plugin Automation", ["Edit", "Copy Special"], None, "{tracks?, start?, end?}", has_range, |e, p| auto_copy(e, p, Lanes::Plugin, false, "edit.copy_plugin_automation")),
cmd!(noundo "edit.copy_clip_gain", "Clip Gain", ["Edit", "Copy Special"], None, "{tracks?, start?, end?} β copies the clip gain curve under the selection", has_range, copy_clip_gain),
cmd!(
"edit.paste_clip_gain",
"Paste Clip Gain",
[],
None,
"{tracks?, at?} β pastes copied clip gain onto the clips under the paste range",
has_clip_gain_clipboard,
paste_clip_gain
),
cmd!(noundo "edit.copy_clip_effects", "Clip Effects", ["Edit", "Copy Special"], None, "{clips?} β copies the first clip's clip-effect settings", has_selection, |e, p| clip_effects(e, p, true, false, "edit.copy_clip_effects")),
cmd!(
"edit.cut_clip_effects",
"Clip Effects",
["Edit", "Cut Special"],
None,
"{clips?} β copies then removes clip-effect settings",
has_selection,
|e, p| clip_effects(e, p, true, true, "edit.cut_clip_effects")
),
cmd!(
"edit.clear_clip_effects",
"Clip Effects",
["Edit", "Clear Special"],
None,
"{clips?} β removes clip-effect settings (and bypass)",
has_selection,
|e, p| clip_effects(e, p, false, true, "edit.clear_clip_effects")
),
cmd!("edit.paste_clip_effects", "Paste Clip Effects", [], None, "{clips?}", has_clip_effects_clipboard, paste_clip_effects),
cmd!(
"edit.paste_merge_midi",
"Merge MIDI",
["Edit", "Paste Special"],
None,
"{tracks?, at?} β merges copied MIDI notes into existing MIDI clips instead of replacing them",
has_clipboard,
paste_merge_midi
),
cmd!(
"edit.paste_merge_markers",
"Merge Markers",
["Edit", "Paste Special"],
None,
"{at?} β adds the copied markers at the insertion point, skipping any that already exist there",
has_marker_clipboard,
paste_merge_markers
),
cmd!(
"edit.paste_to_current_automation",
"To Current Automation Type",
["Edit", "Paste Special"],
None,
"{tracks?, at?, param?} β pastes copied automation into the shown lane (track view) or `param`, rescaled to its range",
has_automation_clipboard,
paste_to_current_automation
),
cmd!(noundo "edit.play_timeline", "Play Timeline", ["Edit", "Selection"], None, "{} β plays the timeline selection", always, |e, _| {
let s = e.session();
let r = if s.edit.timeline_selection.is_empty() { s.edit.selection } else { s.edit.timeline_selection };
e.transport_requests.push(TransportRequest::Locate(r.start));
e.transport_requests.push(TransportRequest::Play);
Ok(json!({"start": r.start, "end": r.end}))
}),
cmd!(
"edit.duplicate_extend",
"Duplicate and Extend Edit",
["Edit", "Selection"],
None,
"{tracks?, start?, end?} β duplicates the selection and extends the selection over the copy",
has_range,
duplicate_extend
),
cmd!(noundo "edit.extend_up_to_members", "Extend Edit Up to Members", ["Edit", "Selection"], None, "{} β adds the parent folder of each selected member and its members", has_selection, |e, _| extend_members(e, true)),
cmd!(noundo "edit.extend_down_to_members", "Extend Edit Down to Members", ["Edit", "Selection"], None, "{} β adds the members of selected folder tracks (recursively)", has_selection, |e, _| extend_members(e, false)),
cmd!(noundo "edit.marker_lane_move_up", "Move Edit Selection To Marker Lane Above", ["Edit", "Selection"], None, "{} β the selection's marker ruler lane (1..5) moves up", always, |e, _| marker_lane(e, -1, false)),
cmd!(noundo "edit.marker_lane_move_down", "Move Edit Selection To Marker Lane Below", ["Edit", "Selection"], None, "{}", always, |e, _| marker_lane(e, 1, false)),
cmd!(noundo "edit.marker_lane_extend_up", "Extend Edit Selection To Marker Lane Above", ["Edit", "Selection"], None, "{} β adds the marker ruler lane above to the selection", always, |e, _| marker_lane(e, -1, true)),
cmd!(noundo "edit.marker_lane_extend_down", "Extend Edit Selection To Marker Lane Below", ["Edit", "Selection"], None, "{}", always, |e, _| marker_lane(e, 1, true)),
cmd!(
"edit.space_clips",
"Space Clipsβ¦",
["Edit"],
None,
"{clips?, gap?: samples|{seconds} (default 0), mode?: end_to_start|start_to_start}",
has_selection,
space_clips
),
cmd!(
"edit.snap_next",
"Next",
["Edit", "Snap to"],
None,
"{clips?} β moves each clip so its end meets the start of the next clip",
has_selection,
|e, p| snap(e, p, true)
),
cmd!(
"edit.snap_previous",
"Previous",
["Edit", "Snap to"],
None,
"{clips?} β moves each clip so its start meets the end of the previous clip",
has_selection,
|e, p| snap(e, p, false)
),
cmd!(
"edit.copy_to_target_playlist",
"Target Playlist",
["Edit", "Copy Selection to..."],
Some("Alt+Shift+Up"),
"{tracks?, start?, end?} β copies the selection into each track's target playlist",
has_range,
|e, p| to_playlist(e, p, Dest::Target, false, "edit.copy_to_target_playlist")
),
cmd!(
"edit.copy_to_duplicate_playlist",
"Duplicate of Main Playlist",
["Edit", "Copy Selection to..."],
None,
"{tracks?, start?, end?}",
has_range,
|e, p| to_playlist(e, p, Dest::Duplicate, false, "edit.copy_to_duplicate_playlist")
),
cmd!(
"edit.move_to_target_playlist",
"Target Playlist",
["Edit", "Move Selection to..."],
Some("Alt+Shift+T"),
"{tracks?, start?, end?} β copies to the target playlist and clears it from the main",
has_range,
|e, p| to_playlist(e, p, Dest::Target, true, "edit.move_to_target_playlist")
),
cmd!(
"edit.move_to_new_playlist",
"New Playlist",
["Edit", "Move Selection to..."],
Some("Alt+Shift+N"),
"{tracks?, start?, end?}",
has_range,
|e, p| to_playlist(e, p, Dest::New, true, "edit.move_to_new_playlist")
),
cmd!(
"edit.move_to_duplicate_playlist",
"Duplicate of Main Playlist",
["Edit", "Move Selection to..."],
None,
"{tracks?, start?, end?}",
has_range,
|e, p| to_playlist(e, p, Dest::Duplicate, true, "edit.move_to_duplicate_playlist")
),
cmd!(
"edit.tce_to_timeline",
"TCE Edit to Timeline Selection",
["Edit"],
None,
"{clip?, start?, end?} β time-stretches the clip to fill the timeline selection (pitch preserved)",
has_selection,
tce
),
cmd!(
"edit.automation_coalesce_volume_to_clip_gain",
"Coalesce Volume Automation to Clip Gain",
["Edit", "Automation"],
None,
"{tracks?} β folds the whole volume curve into clip gain; the fader goes to 0 dB",
has_selection,
coalesce_volume_to_clip_gain
),
cmd!(
"edit.automation_coalesce_clip_gain_to_volume",
"Coalesce Clip Gain to Volume Automation",
["Edit", "Automation"],
None,
"{tracks?} β folds all clip gain into volume automation",
has_selection,
coalesce_clip_gain_to_volume
),
cmd!(
"edit.automation_trim_to_all",
"Trim to All Enabled",
["Edit", "Automation"],
None,
"{tracks?, start?, end?} β offsets every enabled lane in the selection so it starts at the current control value",
has_range,
|e, p| trim_glide(e, p, false, false, "edit.automation_trim_to_all")
),
cmd!(
"edit.automation_glide_to_all",
"Glide to All Enabled",
["Edit", "Automation"],
None,
"{tracks?, start?, end?} β ramps every enabled lane from its value at the start to the current value at the end",
has_range,
|e, p| trim_glide(e, p, true, false, "edit.automation_glide_to_all")
),
cmd!("edit.automation_glide_pan", "Glide Pan Only", ["Edit", "Automation"], None, "{tracks?, start?, end?}", has_range, |e, p| trim_glide(
e,
p,
true,
true,
"edit.automation_glide_pan"
)),
]
}
fn shuffle(s: &Session) -> bool {
s.edit.edit_mode == EditMode::Shuffle
}
fn nonempty_range(e: &Engine, p: &Value, id: &str) -> Result<Range> {
let r = range_param(e, id, p)?;
if r.is_empty() { Err(bad(id, "the selection is empty")) } else { Ok(r) }
}
pub(super) fn cut_all_automation(e: &mut Engine, p: &Value) -> Result<Value> {
auto_copy(e, p, Lanes::All, true, "edit.cut_all_automation")
}
fn auto_copy(e: &mut Engine, p: &Value, which: Lanes, cut: bool, id: &str) -> Result<Value> {
let tracks = tracks_required(e, id, p)?;
let r = nonempty_range(e, p, id)?;
let mut cb = Clipboard { automation_only: true, ..Clipboard::of_range(e.session(), r) };
let mut lanes_n = 0;
for t in &tracks {
cb.tracks.push(Vec::new());
let lanes: Vec<AutomationLane> = e
.session()
.track(*t)
.map(|tr| {
tr.automation
.iter()
.filter(|l| which.hit(&l.param) && !l.points.is_empty())
.map(|l| {
let mut out = AutomationLane::new(l.param.clone());
out.enabled = l.enabled;
let (_, _, def) = l.param.range();
out.set_point(0, l.value_at(r.start, def));
for pt in l.points.iter().filter(|pt| pt.at > r.start && pt.at < r.end) {
out.set_point(pt.at - r.start, pt.value);
}
out.set_point(r.len() - 1, l.value_at(r.end - 1, def));
out
})
.collect()
})
.unwrap_or_default();
lanes_n += lanes.len();
cb.automation.push(lanes);
}
if cut {
let s = e.session_mut();
for t in &tracks {
if let Some(tr) = s.track_mut(*t) {
for l in tr.automation.iter_mut().filter(|l| which.hit(&l.param)) {
l.clear_range(r.start, r.end);
}
}
}
}
e.clipboard = cb;
Ok(json!({"lanes": lanes_n, "length": r.len()}))
}
pub(super) fn copy_clip_gain(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.copy_clip_gain";
let tracks = tracks_required(e, id, p)?;
let r = nonempty_range(e, p, id)?;
let s = e.session();
let mut out = Vec::new();
for t in &tracks {
let mut env: Vec<(Samples, f32)> = Vec::new();
for c in s.track(*t).map(|tr| tr.clips()).unwrap_or(&[]) {
let Some(i) = c.range().intersect(&r) else { continue };
env.push((i.start - r.start, clip_db(c, i.start - c.start)));
for &(o, _) in &c.gain_env {
let at = c.start + o;
if at > i.start && at < i.end - 1 {
env.push((at - r.start, clip_db(c, o)));
}
}
env.push((i.end - 1 - r.start, clip_db(c, i.end - 1 - c.start)));
}
env.sort_by_key(|x| x.0);
env.dedup_by_key(|x| x.0);
out.push(env);
}
let n = out.iter().map(Vec::len).sum::<usize>();
e.clipboard = Clipboard { length: r.len(), clip_gain: out, ..Clipboard::default() };
Ok(json!({"points": n, "length": r.len()}))
}
fn paste_clip_gain(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.paste_clip_gain";
let tracks = tracks_required(e, id, p)?;
let at = position_param(e, id, p, "at")?.unwrap_or(e.session().edit.selection.start);
let cb = e.clipboard.clone();
let paste = Range::new(at, at.saturating_add(cb.length.max(1)));
let s = e.session_mut();
let mut n = 0;
for (i, t) in tracks.iter().enumerate() {
let Some(env) = cb.clip_gain.get(i % cb.clip_gain.len().max(1)) else { continue };
let Some(pl) = s.track_mut(*t).and_then(|tr| tr.playlist_mut()) else { continue };
for c in pl.clips.iter_mut().filter(|c| c.range().overlaps(&paste)) {
let Some(ov) = c.range().intersect(&paste) else { continue };
let (a, b) = (ov.start - c.start, ov.end - c.start);
let mut pts: Vec<(Samples, f32)> = Vec::new();
// Keep the existing curve outside the paste range, anchored at its edges.
let mut old: Vec<(Samples, f32)> = c.gain_env.iter().map(|&(o, _)| (o, clip_db(c, o))).collect();
old.push((0, clip_db(c, 0)));
old.push((c.length, clip_db(c, c.length)));
pts.extend(old.into_iter().filter(|(o, _)| *o < a || *o > b));
if a > 0 {
pts.push((a - 1, clip_db(c, a - 1)));
}
if b < c.length {
pts.push((b, clip_db(c, b)));
}
for &(o, v) in env {
let rel = at + o - c.start;
if rel >= a && rel < b {
pts.push((rel, v));
}
}
set_clip_env(c, pts);
n += 1;
}
}
Ok(json!({"clips": n}))
}
fn fx_prefix(c: ClipId) -> String {
format!("clip_fx.{}.", c.0)
}
fn clip_effects(e: &mut Engine, p: &Value, copy: bool, remove: bool, id: &str) -> Result<Value> {
let ids = clip_ids_param(e, p);
let first = *ids.first().ok_or_else(|| bad(id, "select a clip"))?;
if copy {
let pre = fx_prefix(first);
let fx: Vec<(String, f64)> =
e.session().edit.values.iter().filter_map(|(k, v)| k.strip_prefix(&pre).map(|name| (name.to_string(), *v))).collect();
if fx.is_empty() {
return Err(bad(id, "the clip has no clip effects"));
}
e.clipboard = Clipboard { clip_effects: fx, ..Clipboard::default() };
}
let mut removed = 0;
if remove {
let s = e.session_mut();
for c in &ids {
let pre = fx_prefix(*c);
let before = s.edit.values.len();
s.edit.values.retain(|k, _| !k.starts_with(&pre));
removed += before - s.edit.values.len();
s.edit.set_flag(&format!("clip_fx.bypass.{}", c.0), false);
}
}
Ok(json!({"clips": ids.len(), "copied": e.clipboard.clip_effects.len(), "removed": removed}))
}
fn paste_clip_effects(e: &mut Engine, p: &Value) -> Result<Value> {
let ids = clip_ids_param(e, p);
if ids.is_empty() {
return Err(bad("edit.paste_clip_effects", "select a clip"));
}
let fx = e.clipboard.clip_effects.clone();
let s = e.session_mut();
for c in &ids {
let pre = fx_prefix(*c);
s.edit.values.retain(|k, _| !k.starts_with(&pre));
for (k, v) in &fx {
s.edit.values.insert(format!("{pre}{k}"), *v);
}
}
Ok(json!({"clips": ids.len()}))
}
fn paste_merge_midi(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.paste_merge_midi";
let tracks = tracks_required(e, id, p)?;
let at = position_param(e, id, p, "at")?.unwrap_or(e.session().edit.selection.start).max(0);
let cb = super::edit::clipboard_for_paste(e);
let s = e.session_mut();
let tempo = s.tempo.clone();
let sr = s.sample_rate;
let mut merged = 0;
let mut placed = 0;
for (i, t) in tracks.iter().enumerate() {
let Some(clips) = cb.tracks.get(i % cb.tracks.len().max(1)) else { continue };
for c in clips {
let pos = at.saturating_add(c.start);
let ClipContent::Midi { sequence } = &c.content else {
let mut nc = c.clone();
nc.id = s.new_clip_id();
nc.start = pos;
ops::place_clip(s, *t, nc);
placed += 1;
continue;
};
let target = s.track(*t).and_then(|tr| {
let host = tr.clips().iter().find(|x| matches!(x.content, ClipContent::Midi { .. }) && x.range().contains(pos))?;
let next_start = tr.clips().iter().filter(|x| x.start > host.start && x.id != host.id).map(|x| x.start).min();
Some((host.id, host.start, next_start))
});
match target {
Some((hid, hstart, next_start)) => {
let diff = tempo.samples_to_ticks(pos, sr) - tempo.samples_to_ticks(hstart, sr);
let want_end = pos.saturating_add(c.length);
let limit = next_start.unwrap_or(Samples::MAX);
if let Some(h) = s.find_clip_mut(hid)
&& let ClipContent::Midi { sequence: hs } = &mut h.content
{
for n in &sequence.notes {
let mut n = *n;
n.start = n.start.saturating_add(diff);
hs.notes.push(n);
}
for cc in &sequence.ctrls {
let mut cc = *cc;
cc.tick = cc.tick.saturating_add(diff);
hs.ctrls.push(cc);
}
hs.sort();
if want_end > h.end() {
h.trim_end_to(want_end.min(limit));
}
merged += 1;
}
}
None => {
let mut nc = c.clone();
nc.id = s.new_clip_id();
nc.start = pos;
ops::place_clip(s, *t, nc);
placed += 1;
}
}
}
}
e.clipboard = cb;
Ok(json!({"merged": merged, "placed": placed}))
}
fn map_value(v: f32, from: &AutoParam, to: &AutoParam) -> f32 {
let (a0, a1, _) = from.range();
let (b0, b1, _) = to.range();
let finite = |x: f32, y: f32| x > f32::MIN && y < f32::MAX && y > x;
if from == to || !finite(a0, a1) || !finite(b0, b1) {
return v;
}
b0 + (v - a0) / (a1 - a0) * (b1 - b0)
}
fn paste_to_current_automation(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.paste_to_current_automation";
let tracks = tracks_required(e, id, p)?;
let at = position_param(e, id, p, "at")?.unwrap_or(e.session().edit.selection.start).max(0);
let forced = match str_param(p, "param") {
Some(x) => Some(AutoParam::parse(x).ok_or_else(|| bad(id, format!("unknown automation param `{x}`")))?),
None => None,
};
let cb = e.clipboard.clone();
let s = e.session_mut();
let mut written = 0;
for (i, t) in tracks.iter().enumerate() {
let Some(lanes) = cb.automation.get(i % cb.automation.len().max(1)) else { continue };
let Some(src) = lanes.iter().max_by_key(|l| l.points.len()).filter(|l| !l.points.is_empty()) else { continue };
let Some(tr) = s.track_mut(*t) else { continue };
let dst = forced.clone().unwrap_or_else(|| AutoParam::parse(&tr.view).unwrap_or(AutoParam::Volume));
let lane = tr.lane_mut(&dst);
lane.clear_range(at, at.saturating_add(cb.length));
for pt in &src.points {
lane.set_point(at.saturating_add(pt.at), map_value(pt.value, &src.param, &dst));
written += 1;
}
}
Ok(json!({"points": written}))
}
fn duplicate_extend(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.duplicate_extend";
let tracks = tracks_required(e, id, p)?;
let r = nonempty_range(e, p, id)?;
let (sh, follow) = (shuffle(e.session()), e.session().edit.automation_follows_edit);
let s = e.session_mut();
let mut n = 0;
for t in &tracks {
let clips = ops::copy_range(s, *t, r);
n += ops::paste(s, *t, r.end, &clips, r.len(), sh).map_err(|why| bad(id, why))?.len();
if follow && let Some(tr) = s.track_mut(*t) {
for l in &mut tr.automation {
let pts: Vec<_> = l.points.iter().filter(|pt| r.contains(pt.at)).copied().collect();
for pt in pts {
l.set_point(pt.at.saturating_add(r.len()), pt.value);
}
}
}
}
s.edit.selection = Range::new(r.start, r.end.saturating_add(r.len()));
if s.edit.link_timeline_edit {
s.edit.timeline_selection = s.edit.selection;
}
Ok(json!({"clips": n, "selection": s.edit.selection}))
}
fn extend_members(e: &mut Engine, up: bool) -> Result<Value> {
let s = e.session_mut();
let mut set: std::collections::BTreeSet<u64> = s.edit.selected_tracks.iter().map(|t| t.0).collect();
let mut roots: Vec<u64> = Vec::new();
for t in &s.edit.selected_tracks {
let Some(tr) = s.track(*t) else { continue };
if up {
if let Some(f) = tr.folder {
set.insert(f.0);
roots.push(f.0);
}
} else if tr.is_folder() {
roots.push(tr.id.0);
}
}
// Add members (recursively, bounded by the track count).
let mut guard = 0;
while let Some(f) = roots.pop() {
guard += 1;
if guard > s.tracks.len().saturating_mul(2) + 8 {
break;
}
for tr in s.tracks.iter().filter(|x| x.folder.is_some_and(|p| p.0 == f)) {
if set.insert(tr.id.0) && tr.is_folder() {
roots.push(tr.id.0);
}
}
}
s.edit.selected_tracks = s.tracks.iter().filter(|t| set.contains(&t.id.0)).map(|t| t.id).collect();
Ok(json!({"tracks": s.edit.selected_tracks}))
}
/// Marker ruler lanes (1..5) in the edit selection, kept in `selection.marker_lane.top/bottom`.
fn marker_lane(e: &mut Engine, dir: i64, extend: bool) -> Result<Value> {
let s = e.session_mut();
let top = s.edit.value("selection.marker_lane.top", 1.0).clamp(1.0, 5.0) as i64;
let bottom = (s.edit.value("selection.marker_lane.bottom", top as f64).clamp(1.0, 5.0) as i64).max(top);
let (top, bottom) = match (extend, dir < 0) {
(false, true) => ((top - 1).max(1), (top - 1).max(1)),
(false, false) => ((bottom + 1).min(5), (bottom + 1).min(5)),
(true, true) => ((top - 1).max(1), bottom),
(true, false) => (top, (bottom + 1).min(5)),
};
s.edit.values.insert("selection.marker_lane.top".into(), top as f64);
s.edit.values.insert("selection.marker_lane.bottom".into(), bottom as f64);
let r = s.edit.selection;
let markers: Vec<u32> = s
.markers
.iter()
.filter(|m| (top..=bottom).contains(&i64::from(m.ruler)) && (r.contains(m.start) || m.start == r.start))
.map(|m| m.number)
.collect();
Ok(json!({"lanes": [top, bottom], "markers": markers}))
}
fn space_clips(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.space_clips";
let ids = clip_ids_param(e, p);
let gap = position_param(e, id, p, "gap")?.unwrap_or(0);
let s2s = match str_param(p, "mode") {
None | Some("end_to_start") => false,
Some("start_to_start") => true,
Some(m) => return Err(bad(id, format!("unknown mode `{m}`"))),
};
if ids.len() < 2 {
return Err(bad(id, "select two or more clips"));
}
let s = e.session_mut();
let track_ids: Vec<_> = s.tracks.iter().map(|t| t.id).collect();
let mut moved = 0;
for t in track_ids {
let mut sel: Vec<Clip> = s
.track(t)
.map_or_else(Vec::new, |tr| tr.clips().iter().filter(|c| ids.contains(&c.id) && !c.time_locked && !c.edit_locked).cloned().collect());
if sel.len() < 2 {
continue;
}
sel.sort_by_key(|c| (c.start, c.id.0));
if let Some(pl) = s.track_mut(t).and_then(|tr| tr.playlist_mut()) {
pl.clips.retain(|c| !sel.iter().any(|x| x.id == c.id));
}
let mut cur = sel.first().map_or(0, |c| c.start);
for mut c in sel {
c.start = cur.max(0);
cur = if s2s { c.start.saturating_add(gap) } else { c.end().saturating_add(gap) };
ops::place_clip(s, t, c);
moved += 1;
}
}
Ok(json!({"clips": moved, "gap": gap}))
}
fn snap(e: &mut Engine, p: &Value, next: bool) -> Result<Value> {
let ids = clip_ids_param(e, p);
let s = e.session_mut();
let mut order: Vec<(ClipId, Samples)> = ids.iter().filter_map(|id| s.find_clip(*id).map(|(_, c)| (*id, c.start))).collect();
// Snap the clip nearest the destination first so neighbours stay put.
order.sort_by_key(|x| if next { -x.1 } else { x.1 });
let mut moved = 0;
for (id, _) in order {
let Some((t, c)) = s.find_clip(id).map(|(t, c)| (t, c.clone())) else { continue };
// Selected neighbours are real destinations. Ignoring them made Snap to Next
// pile every selected clip onto the same later clip, and Snap to Previous
// leave the gap between the selected clips in place.
let others = s.track(t).map(|tr| tr.clips().iter().filter(|x| x.id != id).cloned().collect::<Vec<_>>()).unwrap_or_default();
let delta = if next {
others.iter().filter(|x| x.start >= c.end()).map(|x| x.start).min().map(|st| st - c.end())
} else {
others.iter().filter(|x| x.end() <= c.start).map(Clip::end).max().map(|en| en - c.start)
};
if let Some(d) = delta.filter(|d| *d != 0) {
moved += ops::move_clips(s, &[id], d, &[]);
}
}
Ok(json!({"moved": moved}))
}
fn to_playlist(e: &mut Engine, p: &Value, dest: Dest, mv: bool, id: &str) -> Result<Value> {
let tracks = tracks_required(e, id, p)?;
let r = nonempty_range(e, p, id)?;
let sh = shuffle(e.session());
let s = e.session_mut();
let mut out = Vec::new();
for t in &tracks {
if s.track(*t).is_none_or(|tr| !tr.kind.has_playlist()) {
continue;
}
let idx = match dest {
Dest::Target => {
let i = target_playlist(s, *t).ok_or_else(|| bad(id, "designate a target playlist first (Track βΊ Designate as Target Playlist)"))?;
if s.track(*t).is_some_and(|tr| tr.active_playlist == i) {
return Err(bad(id, "the target playlist is the main playlist"));
}
i
}
Dest::New | Dest::Duplicate => {
let mut clips: Vec<Clip> =
if dest == Dest::Duplicate { s.track(*t).map(|tr| tr.clips().to_vec()).unwrap_or_default() } else { Vec::new() };
for c in &mut clips {
c.id = s.new_clip_id();
}
let Some(tr) = s.track_mut(*t) else { continue };
let name = format!("{}.{:02}", tr.name, tr.playlists.len() + 1);
tr.playlists.push(Playlist { name, clips });
tr.playlists.len() - 1
}
};
// A move carries only what it clears from the main playlist; locked clips stay there.
let clips = if mv { ops::take_range(s, *t, r) } else { ops::copy_range(s, *t, r) };
let main = s.track(*t).map_or(0, |tr| tr.active_playlist);
if let Some(tr) = s.track_mut(*t) {
tr.active_playlist = idx;
}
for mut c in clips {
c.id = s.new_clip_id();
c.start = c.start.saturating_add(r.start);
ops::place_clip(s, *t, c);
}
if let Some(tr) = s.track_mut(*t) {
tr.active_playlist = main;
}
if mv {
ops::clear_range(s, *t, r, sh);
}
out.push(json!({"track": t, "playlist": idx}));
}
Ok(json!({"tracks": out}))
}
fn tce(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.tce_to_timeline";
let target = {
let st = position_param(e, id, p, "start")?;
let en = position_param(e, id, p, "end")?;
match (st, en) {
(Some(a), Some(b)) => Range::new(a, b),
_ => e.session().edit.timeline_selection,
}
};
if target.is_empty() || target.start < 0 {
return Err(bad(id, "make a timeline selection first"));
}
let ids = clip_ids_param(e, p);
let Some((t, c)) = ids.iter().find_map(|cid| e.session().find_clip(*cid).filter(|(_, c)| c.is_audio()).map(|(t, c)| (t, c.clone()))) else {
return Err(bad(id, "select an audio clip"));
};
if c.time_locked || c.edit_locked {
return Err(bad(id, "the clip is locked"));
}
let s = e.session_mut();
let Some(src) = render_stretched(s, id, &c, target.len())? else { return Err(bad(id, "the clip's audio is not loaded")) };
let ratio = target.len() as f64 / c.length.max(1) as f64;
let scale = |x: Samples| soundcraft_time::to_samples(x as f64 * ratio);
let mut nc = c.clone();
nc.content = ClipContent::Audio { source: src, offset: 0 };
nc.start = target.start;
nc.length = target.len();
nc.stretch = 1.0;
nc.gain_env = c.gain_env.iter().map(|&(o, v)| (scale(o), v)).collect();
nc.fade_in.len = scale(c.fade_in.len).clamp(0, nc.length);
nc.fade_out.len = scale(c.fade_out.len).clamp(0, nc.length);
nc.sync_point = scale(c.sync_point).clamp(0, nc.length);
replace_clip(s, t, c.id, nc);
s.edit.selected_clips = vec![c.id];
Ok(json!({"clip": c.id, "source": src, "ratio": ratio}))
}
fn volume_at(lane: Option<&AutomationLane>, fader: f32, at: Samples) -> f32 {
match lane {
Some(l) if !l.points.is_empty() => l.value_at(at, fader),
_ => fader,
}
}
fn coalesce_volume_to_clip_gain(e: &mut Engine, p: &Value) -> Result<Value> {
let tracks = tracks_required(e, "edit.automation_coalesce_volume_to_clip_gain", p)?;
let s = e.session_mut();
let mut n = 0;
for t in &tracks {
let Some(tr) = s.track_mut(*t) else { continue };
if !tr.kind.has_playlist() || tr.kind.is_midi() {
continue;
}
let lane = tr.lane(&AutoParam::Volume).cloned();
let fader = tr.mixer.volume_db;
let Some(pl) = tr.playlist_mut() else { continue };
for c in pl.clips.iter_mut().filter(|c| c.is_audio()) {
let mut offs: Vec<Samples> = vec![0, c.length];
offs.extend(c.gain_env.iter().map(|x| x.0));
if let Some(l) = &lane {
offs.extend(l.points.iter().filter(|pt| c.range().contains(pt.at)).map(|pt| pt.at - c.start));
}
offs.sort_unstable();
offs.dedup();
let pts: Vec<(Samples, f32)> = offs.iter().map(|&o| (o, clip_db(c, o) + volume_at(lane.as_ref(), fader, c.start + o))).collect();
set_clip_env(c, pts);
n += 1;
}
tr.automation.retain(|l| l.param != AutoParam::Volume);
tr.mixer.volume_db = 0.0;
}
Ok(json!({"clips": n}))
}
fn coalesce_clip_gain_to_volume(e: &mut Engine, p: &Value) -> Result<Value> {
let tracks = tracks_required(e, "edit.automation_coalesce_clip_gain_to_volume", p)?;
let s = e.session_mut();
let mut n = 0;
for t in &tracks {
let Some(tr) = s.track_mut(*t) else { continue };
let clips: Vec<Clip> = tr.clips().iter().filter(|c| c.is_audio() && (c.gain_db != 0.0 || !c.gain_env.is_empty())).cloned().collect();
if clips.is_empty() {
continue;
}
let lane = tr.lane(&AutoParam::Volume).cloned();
let fader = tr.mixer.volume_db;
let mut times: Vec<Samples> = lane.as_ref().map(|l| l.points.iter().map(|pt| pt.at).collect()).unwrap_or_default();
for c in &clips {
times.push(c.start);
times.push(c.end() - 1);
times.extend(c.gain_env.iter().map(|x| c.start + x.0));
}
times.sort_unstable();
times.dedup();
let gain_at = |at: Samples| clips.iter().find(|c| c.range().contains(at)).map_or(0.0, |c| clip_db(c, at - c.start));
let pts: Vec<(Samples, f32)> = times.iter().map(|&at| (at, volume_at(lane.as_ref(), fader, at) + gain_at(at))).collect();
let l = tr.lane_mut(&AutoParam::Volume);
l.points.clear();
for (at, v) in pts {
l.set_point(at.max(0), v);
}
if let Some(pl) = tr.playlist_mut() {
for c in pl.clips.iter_mut().filter(|c| clips.iter().any(|x| x.id == c.id)) {
c.gain_db = 0.0;
c.gain_env.clear();
n += 1;
}
}
}
Ok(json!({"clips": n}))
}
/// The automation parameters a trim/glide over a range touches on `tr`.
fn trim_params(tr: &soundcraft_model::Track, pan_only: bool) -> Vec<AutoParam> {
let mut params: Vec<AutoParam> = tr
.automation
.iter()
.filter(|l| l.enabled && !matches!(l.param, AutoParam::Mute | AutoParam::SendMute(_)))
.filter(|l| !pan_only || matches!(l.param, AutoParam::Pan(_)))
.map(|l| l.param.clone())
.collect();
if pan_only {
for i in 0..tr.mixer.pan.len().min(2) {
let pp = AutoParam::Pan(i as u8);
if !params.contains(&pp) {
params.push(pp);
}
}
}
params
}
/// Trim (shift the points inside `r` by the change at its end) or glide (ramp across `r`) one lane.
fn trim_lane(tr: &mut soundcraft_model::Track, param: &AutoParam, r: Range, glide: bool) {
let cur = super::mix::current_value(tr, param);
let (lo, hi, _) = param.range();
let l = tr.lane_mut(param);
let before = l.value_at(r.start - 1, cur);
let after = l.value_at(r.end, cur);
let from = l.value_at(r.start, cur);
if glide {
l.clear_range(r.start, r.end.saturating_add(2));
if r.start > 0 {
l.set_point(r.start - 1, before);
}
l.set_point(r.start, from);
l.set_point(r.end, cur);
l.set_point(r.end.saturating_add(1), after);
} else {
let delta = cur - from;
let last = l.value_at(r.end - 1, cur);
if r.start > 0 {
l.set_point(r.start - 1, before);
}
l.set_point(r.start, from);
l.set_point(r.end - 1, last);
l.set_point(r.end, after);
for pt in l.points.iter_mut().filter(|pt| pt.at >= r.start && pt.at < r.end) {
pt.value = (pt.value + delta).clamp(lo, hi);
}
}
}
fn trim_glide(e: &mut Engine, p: &Value, glide: bool, pan_only: bool, id: &str) -> Result<Value> {
let tracks = tracks_required(e, id, p)?;
let r = nonempty_range(e, p, id)?;
let s = e.session_mut();
let mut lanes = 0;
for t in &tracks {
let Some(tr) = s.track_mut(*t) else { continue };
for param in trim_params(tr, pan_only) {
trim_lane(tr, ¶m, r, glide);
lanes += 1;
}
}
Ok(json!({"lanes": lanes}))
}
fn has_marker_clipboard(e: &Engine) -> std::result::Result<(), String> {
if e.clipboard.markers.is_empty() { Err("no markers on the clipboard".into()) } else { Ok(()) }
}
fn paste_merge_markers(e: &mut Engine, p: &Value) -> Result<Value> {
let id = "edit.paste_merge_markers";
if e.clipboard.markers.is_empty() {
return Err(bad(id, "no markers on the clipboard (copy a range that contains markers)"));
}
let at = position_param(e, id, p, "at")?.unwrap_or(e.session().edit.selection.start).max(0);
let copied = e.clipboard.markers.clone();
let s = e.session_mut();
let mut added = 0;
for m in copied {
let start = at.saturating_add(m.start);
if s.markers.iter().any(|x| x.start == start && x.name == m.name && x.ruler == m.ruler) {
continue;
}
let new = s.add_marker(&m.name, m.kind, start, start.saturating_add(m.end - m.start));
if let Some(x) = s.markers.iter_mut().find(|x| x.id == new) {
x.comments = m.comments;
x.color = m.color;
x.ruler = m.ruler;
}
added += 1;
}
Ok(json!({"added": added}))
}
#[cfg(test)]
mod tests {
use super::*;
use soundcraft_model::{ChannelFormat, SourceId, TrackKind};
#[test]
fn merge_markers_pastes_copied_markers_once() {
let mut e = crate::demo::demo_engine();
let first = e.session().markers.first().cloned().expect("demo has markers");
let r = json!({"start": first.start.saturating_sub(10).max(0), "end": first.start + 10});
e.execute("edit.select", &json!({"tracks": ["Kick"], "start": r["start"], "end": r["end"]})).unwrap();
e.execute("edit.copy", &json!({})).unwrap();
let before = e.session().markers.len();
let at = 5_000_000;
let out = e.execute("edit.paste_merge_markers", &json!({"at": at})).unwrap();
assert_eq!(out["added"], 1);
assert_eq!(e.session().markers.len(), before + 1);
assert!(e.session().markers.iter().any(|m| m.name == first.name && m.start == at + first.start - r["start"].as_i64().unwrap()));
// Pasting again at the same place adds nothing.
assert_eq!(e.execute("edit.paste_merge_markers", &json!({"at": at})).unwrap()["added"], 0);
}
fn session_with_clips(starts: &[(Samples, Samples)]) -> (Engine, soundcraft_model::TrackId, Vec<ClipId>) {
let mut s = Session::default();
let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None);
let mut ids = Vec::new();
for (st, len) in starts {
let id = s.new_clip_id();
ops::place_clip(&mut s, t, Clip::audio(id, "c", SourceId(1), 0, *st, *len));
ids.push(id);
}
s.edit.selected_tracks = vec![t];
(Engine::new(s), t, ids)
}
fn starts(e: &Engine, t: soundcraft_model::TrackId) -> Vec<Samples> {
e.session().track(t).map(|tr| tr.clips().iter().map(|c| c.start).collect()).unwrap_or_default()
}
#[test]
fn space_clips_butts_with_gap() {
let (mut e, t, ids) = session_with_clips(&[(0, 100), (500, 100), (2000, 50)]);
e.execute("edit.space_clips", &json!({"clips": ids.iter().map(|c| c.0).collect::<Vec<_>>(), "gap": 10})).unwrap();
assert_eq!(starts(&e, t), vec![0, 110, 220]);
assert!(e.can_undo());
}
#[test]
fn snap_next_and_previous() {
let (mut e, t, ids) = session_with_clips(&[(0, 100), (300, 100), (1000, 100)]);
e.execute("edit.snap_previous", &json!({"clip": ids[1].0})).unwrap();
assert_eq!(starts(&e, t), vec![0, 100, 1000]);
e.execute("edit.snap_next", &json!({"clip": ids[1].0})).unwrap();
assert_eq!(starts(&e, t), vec![0, 900, 1000]);
}
#[test]
fn cut_all_automation_can_be_pasted() {
let (mut e, t, _) = session_with_clips(&[(0, 1000)]);
e.execute("automation.set_point", &json!({"track": t.0, "param": "volume", "at": 100, "value": -6.0})).unwrap();
e.execute("automation.set_point", &json!({"track": t.0, "param": "volume", "at": 400, "value": -12.0})).unwrap();
let cut = e.execute("edit.cut_all_automation", &json!({"start": 50, "end": 250})).unwrap();
assert!(cut["lanes"].as_u64().unwrap() >= 1, "{cut}");
assert!(e.clipboard.automation.iter().any(|lanes| !lanes.is_empty()));
let lane = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().clone();
assert!(lane.points.iter().all(|p| p.at != 100), "the cut point is gone: {:?}", lane.points);
e.execute("edit.paste_to_current_automation", &json!({"at": 1000})).unwrap();
let vol = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().clone();
assert!(vol.points.iter().any(|p| p.at >= 1000 && (p.value + 6.0).abs() < 1e-2), "paste wrote nothing at -6 dB: {:?}", vol.points);
}
#[test]
fn snap_selected_neighbours_keeps_both_clips() {
let (mut e, t, ids) = session_with_clips(&[(0, 100), (300, 100), (1000, 100)]);
e.execute("edit.snap_next", &json!({"clips": [ids[0].0, ids[1].0]})).unwrap();
assert_eq!(e.session().track(t).unwrap().clips().len(), 3);
assert_eq!(starts(&e, t), vec![800, 900, 1000]);
let (mut e, t, ids) = session_with_clips(&[(0, 100), (300, 100), (1000, 100)]);
e.execute("edit.snap_previous", &json!({"clips": [ids[0].0, ids[1].0]})).unwrap();
assert_eq!(e.session().track(t).unwrap().clips().len(), 3);
assert_eq!(starts(&e, t), vec![0, 100, 1000]);
}
#[test]
fn copy_and_paste_automation_only() {
let (mut e, t, _) = session_with_clips(&[(0, 1000)]);
e.execute("automation.set_point", &json!({"track": t.0, "param": "pan", "at": 100, "value": -1.0})).unwrap();
e.execute("automation.set_point", &json!({"track": t.0, "param": "pan", "at": 200, "value": 1.0})).unwrap();
e.execute("automation.set_point", &json!({"track": t.0, "param": "volume", "at": 150, "value": -6.0})).unwrap();
e.execute("edit.cut_pan_automation", &json!({"start": 50, "end": 250})).unwrap();
assert_eq!(e.clipboard.automation[0].len(), 1, "only the pan lane is cut");
assert!(e.session().track(t).unwrap().lane(&AutoParam::Pan(0)).unwrap().points.is_empty());
assert_eq!(e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().points.len(), 1);
// Paste pan into the volume lane, rescaled from -1..1 to -144..12.
e.execute("track.view", &json!({"view": "volume"})).unwrap();
e.execute("edit.paste_to_current_automation", &json!({"at": 1000})).unwrap();
let vol = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().clone();
assert!((vol.value_at(1150, 0.0) - 12.0).abs() < 1e-3, "{:?}", vol.points);
assert!((vol.value_at(1050, 0.0) + 144.0).abs() < 1e-3);
}
#[test]
fn clip_gain_copy_paste() {
let (mut e, t, ids) = session_with_clips(&[(0, 1000), (2000, 1000)]);
e.execute("clip.gain", &json!({"clip": ids[0].0, "db": -6.0})).unwrap();
e.execute("edit.copy_clip_gain", &json!({"start": 0, "end": 1000})).unwrap();
e.execute("edit.paste_clip_gain", &json!({"at": 2000})).unwrap();
let c = e.session().track(t).unwrap().clips()[1].clone();
assert!((clip_db(&c, 500) + 6.0).abs() < 1e-3, "{c:?}");
}
#[test]
fn cut_clip_gain_can_be_pasted() {
let (mut e, t, ids) = session_with_clips(&[(0, 1000), (2000, 1000), (4000, 1000)]);
e.execute("clip.gain", &json!({"clip": ids[0].0, "db": -6.0})).unwrap();
e.execute("clip.gain", &json!({"clip": ids[2].0, "db": -12.0})).unwrap();
// An older copy sits in the clipboard: the paste must get the cut gain, not this one.
e.execute("edit.copy_clip_gain", &json!({"start": 4000, "end": 5000})).unwrap();
e.execute("edit.select", &json!({"tracks": [t.0], "clips": [ids[0].0], "start": 0, "end": 1000})).unwrap();
e.execute("edit.cut_clip_gain", &json!({})).unwrap();
let src = e.session().track(t).unwrap().clips()[0].clone();
assert!(clip_db(&src, 500).abs() < 1e-3, "cut resets the source: {src:?}");
e.execute("edit.paste_clip_gain", &json!({"at": 2000})).unwrap();
let c = e.session().track(t).unwrap().clips()[1].clone();
assert!((clip_db(&c, 500) + 6.0).abs() < 1e-3, "{c:?}");
}
#[test]
fn move_to_new_playlist_clears_main() {
let (mut e, t, _) = session_with_clips(&[(0, 1000)]);
e.execute("edit.move_to_new_playlist", &json!({"start": 200, "end": 400})).unwrap();
let tr = e.session().track(t).unwrap();
assert_eq!(tr.playlists.len(), 2);
assert_eq!(tr.active_playlist, 0);
assert_eq!(tr.playlists[1].clips.len(), 1);
assert_eq!(tr.playlists[1].clips[0].range(), Range::new(200, 400));
assert!(tr.clips().iter().all(|c| !c.range().overlaps(&Range::new(200, 400))));
// Target playlist needs a designation first.
assert!(e.execute("edit.copy_to_target_playlist", &json!({"start": 0, "end": 100})).is_err());
e.execute("track.playlist_select", &json!({"index": 1})).unwrap();
e.execute("track.designate_target_playlist", &json!({})).unwrap();
e.execute("track.playlist_select", &json!({"index": 0})).unwrap();
e.execute("edit.copy_to_target_playlist", &json!({"start": 0, "end": 100})).unwrap();
assert_eq!(e.session().track(t).unwrap().playlists[1].clips.len(), 2);
}
#[test]
fn coalesce_volume_into_clip_gain_and_back() {
let (mut e, t, _) = session_with_clips(&[(0, 1000)]);
e.execute("automation.set_point", &json!({"track": t.0, "at": 0, "value": -10.0})).unwrap();
e.execute("automation.set_point", &json!({"track": t.0, "at": 1000, "value": 0.0})).unwrap();
e.execute("edit.automation_coalesce_volume_to_clip_gain", &json!({})).unwrap();
let c = e.session().track(t).unwrap().clips()[0].clone();
assert!((clip_db(&c, 500) + 5.0).abs() < 1e-3);
assert!(e.session().track(t).unwrap().lane(&AutoParam::Volume).is_none());
e.execute("edit.automation_coalesce_clip_gain_to_volume", &json!({})).unwrap();
let tr = e.session().track(t).unwrap();
assert!((tr.lane(&AutoParam::Volume).unwrap().value_at(500, 0.0) + 5.0).abs() < 0.1);
assert_eq!(tr.clips()[0].gain_db, 0.0);
}
#[test]
fn glide_and_trim() {
let (mut e, t, _) = session_with_clips(&[(0, 1000)]);
e.execute("automation.set_point", &json!({"track": t.0, "at": 0, "value": -10.0})).unwrap();
e.execute("mix.volume", &json!({"db": 0.0})).unwrap();
e.execute("edit.automation_glide_to_all", &json!({"start": 100, "end": 300})).unwrap();
let l = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().clone();
assert!((l.value_at(200, 0.0) + 5.0).abs() < 0.1);
assert!((l.value_at(600, 0.0) + 10.0).abs() < 1e-3, "after the glide the old curve resumes");
e.execute("edit.automation_trim_to_all", &json!({"start": 400, "end": 500})).unwrap();
let l = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap().clone();
assert!((l.value_at(450, 0.0)).abs() < 1e-3);
assert!((l.value_at(700, 0.0) + 10.0).abs() < 1e-3);
}
#[test]
fn merge_midi_keeps_existing_notes() {
let mut e = crate::demo::demo_engine();
let keys = e.session().track_by_name("Keys").unwrap().id;
let clip = e.session().track(keys).unwrap().clips()[0].clone();
let before = match &clip.content {
ClipContent::Midi { sequence } => sequence.notes.len(),
_ => 0,
};
let r = Range::new(clip.start, clip.start + 48_000);
e.execute("edit.select", &json!({"tracks": [keys.0], "start": r.start, "end": r.end})).unwrap();
e.execute("edit.copy", &json!({})).unwrap();
let copied = match &e.clipboard.tracks[0][0].content {
ClipContent::Midi { sequence } => sequence.notes.len(),
_ => 0,
};
e.execute("edit.paste_merge_midi", &json!({"at": clip.start + 96_000})).unwrap();
let after = match &e.session().track(keys).unwrap().clips()[0].content {
ClipContent::Midi { sequence } => sequence.notes.len(),
_ => 0,
};
assert_eq!(after, before + copied);
}
#[test]
fn tce_fits_timeline() {
let mut s = Session::default();
let t = s.add_track(TrackKind::Audio, ChannelFormat::Mono, None);
let tone: Vec<f32> = (0..24_000).map(|i| (i as f32 * 0.05).sin() * 0.5).collect();
let buf = craft_audio::AudioBuffer { sample_rate: 48_000, channels: vec![tone] };
let src = crate::io::add_source(&mut s, "tone", buf, None, soundcraft_model::FileFormat::Wav);
let id = s.new_clip_id();
ops::place_clip(&mut s, t, Clip::audio(id, "tone", src, 0, 0, 24_000));
s.edit.selected_tracks = vec![t];
s.edit.selected_clips = vec![id];
s.edit.timeline_selection = Range::new(1000, 31_000);
let mut e = Engine::new(s);
let r = e.execute("edit.tce_to_timeline", &json!({})).unwrap();
assert!((r["ratio"].as_f64().unwrap() - 1.25).abs() < 1e-9);
let nc = e.session().find_clip(id).unwrap().1.clone();
assert_eq!((nc.start, nc.length), (1000, 30_000));
let nsrc = nc.source().unwrap();
assert_ne!(nsrc, src);
assert_eq!(e.session().source(nsrc).unwrap().frames, 30_000);
assert!(e.session().pool.get(nsrc).unwrap().buffer.channels[0].iter().any(|v| v.abs() > 0.1));
}
#[test]
fn extend_to_members() {
let mut e = Engine::default();
e.execute("track.new", &json!({"count": 2})).unwrap();
e.execute("track.move_to_new_folder", &json!({})).unwrap();
let folder = e.session().tracks.iter().find(|t| t.is_folder()).unwrap().id;
e.execute("edit.select", &json!({"tracks": [folder.0]})).unwrap();
e.execute("edit.extend_down_to_members", &json!({})).unwrap();
assert_eq!(e.session().edit.selected_tracks.len(), 3);
let member = e.session().tracks.iter().find(|t| t.folder == Some(folder)).unwrap().id;
e.execute("edit.select", &json!({"tracks": [member.0]})).unwrap();
e.execute("edit.extend_up_to_members", &json!({})).unwrap();
assert_eq!(e.session().edit.selected_tracks.len(), 3);
}
#[test]
fn marker_lane_selection() {
let mut e = Engine::default();
e.execute("edit.marker_lane_move_down", &json!({})).unwrap();
e.execute("edit.marker_lane_extend_down", &json!({})).unwrap();
let r = e.execute("edit.marker_lane_extend_up", &json!({})).unwrap();
assert_eq!(r["lanes"], json!([1, 3]));
let r = e.execute("edit.marker_lane_move_up", &json!({})).unwrap();
assert_eq!(r["lanes"], json!([1, 1]));
}
#[test]
fn duplicate_and_extend() {
let (mut e, t, _) = session_with_clips(&[(0, 100)]);
e.execute("edit.duplicate_extend", &json!({"start": 0, "end": 100})).unwrap();
assert_eq!(starts(&e, t), vec![0, 100]);
assert_eq!(e.session().edit.selection, Range::new(0, 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.