diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..2c4b8cb1
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,30 @@
+version: 2
+updates:
+ # Maintain Rust / Cargo dependencies
+ - package-ecosystem: "cargo"
+ directory: "/"
+ schedule:
+ interval: "daily"
+ time: "06:00"
+ timezone: "America/New_York"
+ # Consolidate updates into a single PR rather than one PR per crate
+ groups:
+ cargo-dependencies:
+ patterns:
+ - "*"
+ commit-message:
+ prefix: "chore(deps)"
+
+ # Maintain GitHub Actions workflows
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "daily"
+ time: "06:00"
+ timezone: "America/New_York"
+ groups:
+ actions:
+ patterns:
+ - "*"
+ commit-message:
+ prefix: "ci(deps)"
diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
index 18392587..01cb9cd6 100644
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -18,16 +18,6 @@ concurrency:
cancel-in-progress: true
jobs:
- eval:
- runs-on: ubuntu-latest
- timeout-minutes: 15
- steps:
- - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- - uses: cachix/install-nix-action@13d8dd58da0234aa297dedd986986ccb8e7f3e24 # v31.11.1
- - name: nix flake check --no-build
- run: |
- if [ -f flake.nix ]; then
- nix flake check --no-build --all-systems
- else
- echo "No flake.nix present in this repository; skipping check."
- fi
+ nix:
+ # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
+ uses: storytold/craft-common-actions/.github/workflows/nix.yml@main
diff --git a/Cargo.lock b/Cargo.lock
index b8eb7655..5ab3653d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -846,6 +846,11 @@ dependencies = [
"windows 0.54.0",
]
+[[package]]
+name = "craft-docpath"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=82a24b006eefa036b43c09a67fb9a3fbd17ffe63#82a24b006eefa036b43c09a67fb9a3fbd17ffe63"
+
[[package]]
name = "craft-ui"
version = "0.1.0"
@@ -3567,7 +3572,7 @@ dependencies = [
[[package]]
name = "soundcraft"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"eframe",
"egui",
@@ -3585,7 +3590,7 @@ dependencies = [
[[package]]
name = "soundcraft-au-host"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"log",
"serde",
@@ -3595,7 +3600,7 @@ dependencies = [
[[package]]
name = "soundcraft-audio-io"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"log",
"proptest",
@@ -3607,7 +3612,7 @@ dependencies = [
[[package]]
name = "soundcraft-automation"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"log",
"serde_json",
@@ -3617,7 +3622,7 @@ dependencies = [
[[package]]
name = "soundcraft-clap-host"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"clap-sys",
"libloading",
@@ -3630,7 +3635,7 @@ dependencies = [
[[package]]
name = "soundcraft-cli"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"serde_json",
"soundcraft-audio-io",
@@ -3641,7 +3646,7 @@ dependencies = [
[[package]]
name = "soundcraft-dsp"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"log",
"proptest",
@@ -3652,8 +3657,9 @@ dependencies = [
[[package]]
name = "soundcraft-engine"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
+ "craft-docpath",
"log",
"proptest",
"serde",
@@ -3674,7 +3680,7 @@ dependencies = [
[[package]]
name = "soundcraft-midi"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"proptest",
"serde",
@@ -3684,7 +3690,7 @@ dependencies = [
[[package]]
name = "soundcraft-mix"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"log",
"rayon",
@@ -3700,7 +3706,7 @@ dependencies = [
[[package]]
name = "soundcraft-model"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"proptest",
"serde",
@@ -3713,7 +3719,7 @@ dependencies = [
[[package]]
name = "soundcraft-playback"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"cpal",
"log",
@@ -3728,7 +3734,7 @@ dependencies = [
[[package]]
name = "soundcraft-time"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"proptest",
"serde",
@@ -3738,7 +3744,7 @@ dependencies = [
[[package]]
name = "soundcraft-ui-egui"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"craft-ui",
"egui",
@@ -3764,7 +3770,7 @@ dependencies = [
[[package]]
name = "soundcraft-video"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"image",
"proptest",
@@ -3775,7 +3781,7 @@ dependencies = [
[[package]]
name = "soundcraft-vst3-host"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"libloading",
"log",
@@ -3791,7 +3797,7 @@ dependencies = [
[[package]]
name = "soundcraft-web"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"eframe",
"egui",
@@ -5348,7 +5354,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
[[package]]
name = "xtask"
-version = "0.7.0"
+version = "0.9.0"
dependencies = [
"serde_json",
]
diff --git a/Cargo.toml b/Cargo.toml
index 362e6a9a..65b8ea5c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
default-members = ["crates/*", "apps/*", "xtask"]
[workspace.package]
-version = "0.7.0"
+version = "0.9.0"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.90"
@@ -42,6 +42,9 @@ rustfft = "6"
zip = { version = "9", default-features = false }
cpal = "0.16"
+# Which file paths stored in a session may be opened.
+craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "82a24b006eefa036b43c09a67fb9a3fbd17ffe63" }
+
# ui
craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "5c874d51eeb3de70e735c8ce87a59a7dedd47675", features = ["serde"] }
egui = "0.36"
diff --git a/README.md b/README.md
index d88fee8a..c683c34b 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
SoundCraft
- Recording, editing and mixing audio; an open-source, clean-room reimplementation of Avid Pro Tools, rebuilt in pure Rust.
+ Recording, editing and mixing audio; an open-source, modern digital audio workstation (DAW), built in pure Rust.
@@ -25,6 +25,9 @@
+
+ 
+ 
@@ -375,10 +378,6 @@ ArtCraft Team and are not covered by this license. They may be used only unmodif
part of this repository and SoundCraft, under [`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt).
Forks and modified versions must remove them.
-Avid and Pro Tools are trademarks or registered trademarks of Avid Technology, Inc. in the United States and/or other countries. SoundCraft is an independent, open-source project and is not affiliated with, sponsored by or endorsed by Avid Technology, Inc.; these names are used only to describe the workflows it is compatible with.
-
-Adobe, Photoshop, Illustrator, Premiere Pro, Lightroom, Acrobat, After Effects and InDesign are trademarks or registered trademarks of Adobe Inc. in the United States and/or other countries. SoundCraft is an independent, open-source project and is not affiliated with, sponsored by or endorsed by Adobe Inc.; these names are used only to describe the workflows it is compatible with.
-
Made by the ArtCraft team and community.
diff --git a/ROADMAP.md b/ROADMAP.md
index 73197650..c44cdcf6 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-10 · **Last updated:** 2026-10-14 · **Change:** trivial (MCP batch limit validation) · **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-14:** MCP `batch` rejects more than 1000 calls before executing any command, instead of silently running only the first 1000 (#460). 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-14 | trivial | Progress log: oversized MCP batches rejected before execution (#460) |
| 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/apps/soundcraft-web/src/web.rs b/apps/soundcraft-web/src/web.rs
index 3682fab7..0d9b6485 100644
--- a/apps/soundcraft-web/src/web.rs
+++ b/apps/soundcraft-web/src/web.rs
@@ -1,6 +1,5 @@
//! The browser shell: the eframe web runner around [`SoundApp`].
-use serde_json::json;
use soundcraft_engine::{Engine, io};
use soundcraft_ui_egui::dialogs::Dialog;
use soundcraft_ui_egui::sampler_window::SampleRead;
@@ -166,30 +165,23 @@ impl WebShell {
}
}
- fn handle(&mut self, purpose: Purpose, name: &str, bytes: &[u8]) {
- if matches!(purpose, Purpose::Session) && soundcraft_ui_egui::bounce::refuses_session_switch(&mut self.app) {
- return;
- }
+ fn handle(&mut self, purpose: Purpose, name: String, bytes: Vec) {
let e = &mut self.app.engine;
let at = e.session().edit.selection.start.max(0);
let result = match purpose {
- Purpose::Session => {
- let _ = self.app.run("transport.stop", json!({}));
- io::open_session_bytes(&mut self.app.engine, name, bytes).map(|missing| {
- if missing.is_empty() { format!("Opened {name}") } else { format!("Opened {name} ({} missing media)", missing.len()) }
- })
- }
+ // Asks first when the open session has changes: the bytes wait for the answer.
+ Purpose::Session => return soundcraft_ui_egui::dialogs::open_session_bytes(&mut self.app, name, bytes),
// Imports are edits: one undo step each, like the import commands.
Purpose::Audio => {
let before = e.session_arc();
- io::import_audio_bytes(e, name, bytes, None, None, at).map(|_| {
+ io::import_audio_bytes(e, &name, &bytes, None, None, at).map(|_| {
e.push_undo("Import Audio", before);
format!("Imported {name}")
})
}
Purpose::Midi => {
let before = e.session_arc();
- io::import_midi_bytes(e, bytes, at, true).map(|_| {
+ io::import_midi_bytes(e, &bytes, at, true).map(|_| {
e.push_undo("Import MIDI", before);
format!("Imported {name}")
})
@@ -205,7 +197,7 @@ impl eframe::App for WebShell {
self.take_path_prompt(ctx);
let pending = std::mem::take(&mut *self.inbox.borrow_mut());
for (purpose, name, bytes) in pending {
- self.handle(purpose, &name, &bytes);
+ self.handle(purpose, name, bytes);
}
let samples = std::mem::take(&mut *self.samples.borrow_mut());
for (read, bytes) in samples {
diff --git a/apps/soundcraft/src/config.rs b/apps/soundcraft/src/config.rs
index 1ade4ee0..5efab9a7 100644
--- a/apps/soundcraft/src/config.rs
+++ b/apps/soundcraft/src/config.rs
@@ -1,7 +1,12 @@
//! Per-user settings and automation profile directories.
use std::ffi::OsString;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+
+/// Portable mode (#268): this file beside the executable keeps settings, autosaves, presets and
+/// logs in [`PORTABLE_DATA_DIR`] next to it instead of the user profile.
+const PORTABLE_MARKER: &str = "portable.txt";
+const PORTABLE_DATA_DIR: &str = "SoundCraftData";
#[derive(Clone, Copy)]
enum Platform {
@@ -13,7 +18,18 @@ enum Platform {
/// SoundCraft's settings folder. A nonempty `$SOUNDCRAFT_CONFIG_DIR` overrides the platform default.
/// The override is the complete directory; no application-name suffix is appended. An explicitly
/// empty value disables the settings directory instead of falling back to a personal profile.
+/// Otherwise `portable.txt` beside the executable selects `/SoundCraftData`, when that
+/// folder can be written (a read-only medium falls back to the platform default).
pub fn config_dir() -> Option {
+ static DIR: std::sync::OnceLock> = std::sync::OnceLock::new();
+ DIR.get_or_init(|| {
+ let exe = std::env::current_exe().ok();
+ resolve(exe.as_deref().and_then(Path::parent))
+ })
+ .clone()
+}
+
+fn resolve(exe_dir: Option<&Path>) -> Option {
let platform = if cfg!(target_os = "macos") {
Platform::Mac
} else if cfg!(windows) {
@@ -21,13 +37,20 @@ pub fn config_dir() -> Option {
} else {
Platform::Other
};
- config_dir_with(platform, |name| std::env::var_os(name))
+ config_dir_with(platform, |name| std::env::var_os(name), exe_dir)
}
-fn config_dir_with(platform: Platform, env: impl Fn(&str) -> Option) -> Option {
+fn config_dir_with(platform: Platform, env: impl Fn(&str) -> Option, exe_dir: Option<&Path>) -> Option {
if let Some(dir) = env("SOUNDCRAFT_CONFIG_DIR") {
return (!dir.is_empty()).then(|| PathBuf::from(dir));
}
+ if let Some(exe_dir) = exe_dir.filter(|d| d.join(PORTABLE_MARKER).is_file()) {
+ let data = exe_dir.join(PORTABLE_DATA_DIR);
+ match writable(&data) {
+ Ok(()) => return Some(data),
+ Err(e) => log::warn!("portable mode: {} can't be written ({e}); using the user profile instead", data.display()),
+ }
+ }
match platform {
Platform::Mac => env("HOME").map(|h| PathBuf::from(h).join("Library/Application Support/SoundCraft")),
Platform::Windows => env("APPDATA").map(|a| PathBuf::from(a).join("SoundCraft")),
@@ -37,6 +60,14 @@ fn config_dir_with(platform: Platform, env: impl Fn(&str) -> Option) -
}
}
+/// Create `dir` if needed and prove a file can be written in it.
+fn writable(dir: &Path) -> std::io::Result<()> {
+ std::fs::create_dir_all(dir)?;
+ let probe = dir.join(format!(".write-test-{}", std::process::id()));
+ std::fs::write(&probe, b"")?;
+ std::fs::remove_file(probe)
+}
+
/// Read bounded settings, recovering unreadable docking metadata independently of other settings.
pub fn load_ui(path: &std::path::Path) -> Result, String> {
read_ui(path, true)
@@ -195,16 +226,20 @@ mod config_tests {
}
fn resolve(platform: Platform, vars: &[(&str, &str)]) -> Option {
- config_dir_with(platform, |name| vars.iter().find_map(|(key, value)| (*key == name).then(|| OsString::from(value))))
+ config_dir_with(platform, |name| vars.iter().find_map(|(key, value)| (*key == name).then(|| OsString::from(value))), None)
}
#[test]
fn config_override_wins_without_reading_user_profile() {
for platform in [Platform::Mac, Platform::Windows, Platform::Other] {
- let actual = config_dir_with(platform, |name| {
- assert_eq!(name, "SOUNDCRAFT_CONFIG_DIR");
- Some(OsString::from("isolated/settings"))
- });
+ let actual = config_dir_with(
+ platform,
+ |name| {
+ assert_eq!(name, "SOUNDCRAFT_CONFIG_DIR");
+ Some(OsString::from("isolated/settings"))
+ },
+ None,
+ );
assert_eq!(actual, Some(PathBuf::from("isolated/settings")));
}
}
@@ -213,10 +248,14 @@ mod config_tests {
fn config_empty_override_disables_profile_without_reading_defaults() {
for platform in [Platform::Mac, Platform::Windows, Platform::Other] {
assert_eq!(
- config_dir_with(platform, |name| {
- assert_eq!(name, "SOUNDCRAFT_CONFIG_DIR");
- Some(OsString::new())
- }),
+ config_dir_with(
+ platform,
+ |name| {
+ assert_eq!(name, "SOUNDCRAFT_CONFIG_DIR");
+ Some(OsString::new())
+ },
+ None
+ ),
None
);
}
@@ -234,11 +273,34 @@ mod config_tests {
}
}
+ #[test]
+ fn portable_txt_beside_the_exe_keeps_settings_next_to_it() {
+ let exe = std::env::temp_dir().join(format!("soundcraft-portable-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&exe);
+ std::fs::create_dir_all(&exe).unwrap();
+ let vars = [("APPDATA", "/roaming")];
+ assert_eq!(resolve_with_exe(&vars, &exe), Some(PathBuf::from("/roaming/SoundCraft")), "no marker: the profile");
+ std::fs::write(exe.join("portable.txt"), b"").unwrap();
+ assert_eq!(resolve_with_exe(&vars, &exe), Some(exe.join("SoundCraftData")));
+ assert!(exe.join("SoundCraftData").is_dir());
+ // The explicit override still wins.
+ assert_eq!(resolve_with_exe(&[("SOUNDCRAFT_CONFIG_DIR", "/custom")], &exe), Some(PathBuf::from("/custom")));
+ // A data folder that can't be made (a file is in the way) falls back to the profile.
+ std::fs::remove_dir_all(exe.join("SoundCraftData")).unwrap();
+ std::fs::write(exe.join("SoundCraftData"), b"").unwrap();
+ assert_eq!(resolve_with_exe(&vars, &exe), Some(PathBuf::from("/roaming/SoundCraft")));
+ std::fs::remove_dir_all(exe).unwrap();
+ }
+
+ fn resolve_with_exe(vars: &[(&str, &str)], exe: &Path) -> Option {
+ config_dir_with(Platform::Windows, |name| vars.iter().find_map(|(key, value)| (*key == name).then(|| OsString::from(value))), Some(exe))
+ }
+
#[cfg(unix)]
#[test]
fn config_override_preserves_non_unicode_paths() {
use std::os::unix::ffi::OsStringExt as _;
let value = OsString::from_vec(b"isolated/\xff".to_vec());
- assert_eq!(config_dir_with(Platform::Mac, |_| Some(value.clone())), Some(PathBuf::from(value)));
+ assert_eq!(config_dir_with(Platform::Mac, |_| Some(value.clone()), None), Some(PathBuf::from(value)));
}
}
diff --git a/contributors/people.toml b/contributors/people.toml
index 1c344199..7799757f 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -50,3 +50,8 @@ sync_github_name = false
[people.Momentum96]
sync_github_name = true
+
+[people.marcoarnulfo]
+real_name = "Marco Arnulfo"
+display_name = "Marco Arnulfo"
+sync_github_name = false
diff --git a/crates/automation/src/mcp.rs b/crates/automation/src/mcp.rs
index cacd9a03..886b25d7 100644
--- a/crates/automation/src/mcp.rs
+++ b/crates/automation/src/mcp.rs
@@ -6,6 +6,7 @@ use std::io::{BufRead, Write};
pub const PROTOCOL_VERSION: &str = "2025-06-18";
const SUPPORTED: &[&str] = &["2025-06-18", "2025-03-26", "2024-11-05"];
+const MAX_BATCH_CALLS: usize = 1000;
const INSTRUCTIONS: &str = "SoundCraft is a digital audio workstation (Pro Tools-class). Everything a user can do is a \
command: call `list_commands` to discover ids and their params, then `execute` (or `batch`). Positions are samples \
@@ -37,8 +38,8 @@ pub fn tool_definitions() -> Vec {
),
tool(
"batch",
- "Run several commands in order; stops at the first error unless keep_going.",
- json!({"calls": {"type": "array", "items": {"type": "object", "properties": {"command": {"type": "string"}, "params": {"type": "object"}}}}, "keep_going": {"type": "boolean"}}),
+ "Run up to 1000 commands in order; stops at the first error unless keep_going. Larger batches are rejected before any command runs.",
+ json!({"calls": {"type": "array", "maxItems": MAX_BATCH_CALLS, "items": {"type": "object", "properties": {"command": {"type": "string"}, "params": {"type": "object"}}}}, "keep_going": {"type": "boolean"}}),
&["calls"],
),
tool(
@@ -135,9 +136,12 @@ impl Server {
let Some(calls) = args.get("calls").and_then(Value::as_array) else {
return error_result("`calls` must be an array");
};
+ if calls.len() > MAX_BATCH_CALLS {
+ return error_result(&format!("`calls` must contain at most {MAX_BATCH_CALLS} commands; no commands were executed"));
+ }
let mut out = Vec::new();
let mut failed = false;
- for c in calls.iter().take(1000) {
+ for c in calls {
let Some(cmd) = c.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) else {
out.push(json!({"command": "", "ok": false, "error": "`command` required"}));
failed = true;
diff --git a/crates/automation/tests/agent_tasks.rs b/crates/automation/tests/agent_tasks.rs
index 3636cfe3..b94178b1 100644
--- a/crates/automation/tests/agent_tasks.rs
+++ b/crates/automation/tests/agent_tasks.rs
@@ -31,6 +31,8 @@ fn handshake_and_tool_list() {
assert_eq!(r["result"]["serverInfo"]["name"], "soundcraft");
let r = rpc(&mut s, 2, "tools/list", json!({}));
assert!(r["result"]["tools"].as_array().unwrap().len() >= 10);
+ let batch = r["result"]["tools"].as_array().unwrap().iter().find(|tool| tool["name"] == "batch").unwrap();
+ assert_eq!(batch["inputSchema"]["properties"]["calls"]["maxItems"], 1000);
assert!(s.handle(&json!({"jsonrpc": "2.0", "method": "notifications/initialized"})).is_none());
let r = rpc(&mut s, 3, "nope", json!({}));
assert_eq!(r["error"]["code"], -32601);
@@ -171,3 +173,35 @@ fn batch_rejects_non_array_calls() {
assert!(text.contains("`calls` must be an array"), "{text}");
assert_eq!(session(&mut s)["tracks"].as_array().unwrap().len(), 0);
}
+
+#[test]
+fn batch_rejects_oversize_calls_before_any_mutation() {
+ for keep_going in [false, true] {
+ let mut s = Server::new(Headless::new(Engine::default()));
+ let before = session(&mut s);
+ let mut calls = vec![json!({"command": "engine.history"}); 1001];
+ calls[0] = json!({"command": "track.new", "params": {"name": "Must not be created"}});
+ let r = rpc(&mut s, 1, "tools/call", json!({"name": "batch", "arguments": {"calls": calls, "keep_going": keep_going}}));
+ assert_eq!(session(&mut s), before, "oversize batch mutated the session (keep_going={keep_going})");
+ assert!(s.backend.engine.journal.is_empty());
+ assert!(!s.backend.engine.can_undo());
+ assert_eq!(r["result"]["isError"], true);
+ let text = r["result"]["content"][0]["text"].as_str().unwrap();
+ assert!(text.contains("1000"), "{text}");
+ }
+}
+
+#[test]
+fn batch_accepts_empty_and_limit_sized_calls_in_order() {
+ for count in [0, 1000] {
+ let mut s = Server::new(Headless::new(Engine::default()));
+ let calls: Vec<_> = (0..count).map(|at| json!({"command": "session.format_time", "params": {"at": at, "format": "samples"}})).collect();
+ let results = tool(&mut s, "batch", json!({"calls": calls}));
+ let results = results.as_array().unwrap();
+ assert_eq!(results.len(), count);
+ for (at, result) in results.iter().enumerate() {
+ assert_eq!(result["ok"], true);
+ assert_eq!(result["result"]["text"], at.to_string());
+ }
+ }
+}
diff --git a/crates/clap-host/src/ffi.rs b/crates/clap-host/src/ffi.rs
index 82f57bf3..99062807 100644
--- a/crates/clap-host/src/ffi.rs
+++ b/crates/clap-host/src/ffi.rs
@@ -1241,25 +1241,38 @@ impl Instance {
ok.then(|| read_name(&buf)).filter(|s| !s.is_empty())
}
- pub fn audio_ports(&self, is_input: bool) -> Vec {
+ /// The plugin's audio ports in one direction. A layout beyond `MAX_PORTS` ports or
+ /// `MAX_PORT_CHANNELS` channels per port is an error: we never hand a plugin fewer ports or
+ /// channels than it advertised.
+ pub fn audio_ports(&self, is_input: bool) -> Result, ClapError> {
// SAFETY: see `params`.
- let Some(p) = (unsafe { self.ports.as_ref() }) else { return Vec::new() };
- let (Some(count), Some(get)) = (p.count, p.get) else { return Vec::new() };
+ let Some(p) = (unsafe { self.ports.as_ref() }) else { return Ok(Vec::new()) };
+ let (Some(count), Some(get)) = (p.count, p.get) else { return Ok(Vec::new()) };
+ let dir = if is_input { "input" } else { "output" };
// SAFETY: vtable call with its instance.
- let n = unsafe { count(self.plugin, is_input) }.min(MAX_PORTS);
+ let n = unsafe { count(self.plugin, is_input) };
+ if n > MAX_PORTS {
+ return Err(ClapError::Process(format!("{n} audio {dir} ports (at most {MAX_PORTS} supported)")));
+ }
let mut out = Vec::new();
for i in 0..n {
// SAFETY: plain data; all-zero (null port_type pointer) is valid.
let mut info: clap_audio_port_info = unsafe { std::mem::zeroed() };
// SAFETY: index below the count; `info` is writable.
if unsafe { get(self.plugin, i, is_input, &mut info) } {
- out.push(PortInfo { channels: info.channel_count.min(MAX_PORT_CHANNELS), main: info.flags & CLAP_AUDIO_PORT_IS_MAIN != 0 });
+ if info.channel_count > MAX_PORT_CHANNELS {
+ return Err(ClapError::Process(format!(
+ "audio {dir} port {i} has {} channels (at most {MAX_PORT_CHANNELS} supported)",
+ info.channel_count
+ )));
+ }
+ out.push(PortInfo { channels: info.channel_count, main: info.flags & CLAP_AUDIO_PORT_IS_MAIN != 0 });
} else {
// Keep port indices aligned: an unreadable port still needs a (silent) buffer slot.
out.push(PortInfo { channels: 0, main: false });
}
}
- out
+ Ok(out)
}
pub fn note_port(&self) -> Option {
diff --git a/crates/clap-host/src/plugin.rs b/crates/clap-host/src/plugin.rs
index 89f8dbf8..2fbf2726 100644
--- a/crates/clap-host/src/plugin.rs
+++ b/crates/clap-host/src/plugin.rs
@@ -113,8 +113,21 @@ impl Plugin for ClapPlugin {
self.channels = channels.clamp(1, MAX_CHANNELS);
self.inst.deactivate();
self.inst.service_callback();
- let ins = self.inst.audio_ports(true);
- let outs = self.inst.audio_ports(false);
+ let ports = self.inst.audio_ports(true).and_then(|ins| Ok((ins, self.inst.audio_ports(false)?)));
+ let (ins, outs) = match ports {
+ Ok(p) => p,
+ Err(e) => {
+ // Unsupported layout: stay inactive (`process` passes audio through untouched).
+ log::warn!("{}: {e}", self.info.id);
+ self.inputs = PortBuffers::new(&[], 0);
+ self.outputs = PortBuffers::new(&[], 0);
+ self.in_main = None;
+ self.out_main = None;
+ self.max_block = 0;
+ self.latency = 0;
+ return;
+ }
+ };
self.in_main = pick_main(&ins);
self.out_main = pick_main(&outs);
self.inputs = PortBuffers::new(&ins.iter().map(|p| p.channels).collect::>(), mb);
diff --git a/crates/clap-host/tests/common/mod.rs b/crates/clap-host/tests/common/mod.rs
index 2da23955..1318104d 100644
--- a/crates/clap-host/tests/common/mod.rs
+++ b/crates/clap-host/tests/common/mod.rs
@@ -40,7 +40,7 @@ pub fn fixture_dir() -> &'static Path {
std::fs::create_dir_all(dir.join("vendor")).unwrap();
std::fs::copy(&built, dir.join("vendor/Fixture.clap")).unwrap();
}
- assert_eq!(soundcraft_clap_host::add_search_dir(&dir), 2);
+ assert_eq!(soundcraft_clap_host::add_search_dir(&dir), 5);
dir
})
}
diff --git a/crates/clap-host/tests/fixture/src/lib.rs b/crates/clap-host/tests/fixture/src/lib.rs
index 85a7999b..b88f434f 100644
--- a/crates/clap-host/tests/fixture/src/lib.rs
+++ b/crates/clap-host/tests/fixture/src/lib.rs
@@ -6,6 +6,11 @@
//! to the velocity of the held note (0 when none), switching at the event's sample offset. A
//! MIDI CC 7 (volume) sets the constant to its value / 127.
//!
+//! - `org.soundcraft.test.wide16`, `.wide17ports`, `.wide65ch`: effects advertising wide layouts
+//! (16 ports of 64 channels, 17 ports of 2 channels, one port of 65 channels per direction).
+//! `process` writes 1.0 into every output channel it was given when the host's buffers match the
+//! advertised layout, -1.0 when they do not.
+//!
//! The gain plugin also implements `clap.state` (gain and mode as two little-endian f64s) and a
//! floating-only `clap.gui` without a real window: showing it "edits" the gain to 0.25 in the GUI,
//! reported as an output parameter event by the next `process`.
@@ -36,6 +41,27 @@ unsafe impl Sync for Features {}
static GAIN_FEATURES: Features<3> = Features([c"audio-effect".as_ptr(), c"stereo".as_ptr(), std::ptr::null()]);
static SYNTH_FEATURES: Features<3> = Features([c"instrument".as_ptr(), c"synthesizer".as_ptr(), std::ptr::null()]);
+static WIDE_FEATURES: Features<2> = Features([c"audio-effect".as_ptr(), std::ptr::null()]);
+
+const fn wide_desc(id: &'static CStr, name: &'static CStr) -> clap_plugin_descriptor {
+ clap_plugin_descriptor {
+ clap_version: CLAP_VERSION,
+ id: id.as_ptr(),
+ name: name.as_ptr(),
+ vendor: c"SoundCraft tests".as_ptr(),
+ url: std::ptr::null(),
+ manual_url: std::ptr::null(),
+ support_url: std::ptr::null(),
+ version: c"1.0.0".as_ptr(),
+ description: std::ptr::null(),
+ features: WIDE_FEATURES.0.as_ptr(),
+ }
+}
+
+static WIDE16_DESC: clap_plugin_descriptor = wide_desc(c"org.soundcraft.test.wide16", c"Fixture Wide 16x64");
+static WIDE17_DESC: clap_plugin_descriptor = wide_desc(c"org.soundcraft.test.wide17ports", c"Fixture Wide 17 ports");
+static WIDE65_DESC: clap_plugin_descriptor = wide_desc(c"org.soundcraft.test.wide65ch", c"Fixture Wide 65 channels");
+
static GAIN_DESC: clap_plugin_descriptor = clap_plugin_descriptor {
clap_version: CLAP_VERSION,
id: c"org.soundcraft.test.gain".as_ptr(),
@@ -66,6 +92,8 @@ struct Fx {
plugin: clap_plugin,
host: *const clap_host,
synth: bool,
+ /// `(ports per direction, channels per port)` for the wide fixtures.
+ wide: Option<(u32, u32)>,
gain: f64,
mode: f64,
level: f64,
@@ -168,6 +196,22 @@ unsafe extern "C" fn process(p: *const clap_plugin, pr: *const clap_process) ->
let n = pr.frames_count as usize;
let ev = unsafe { &*pr.in_events };
let count = unsafe { (ev.size.unwrap())(pr.in_events) };
+ if let Some((ports, channels)) = f.wide {
+ let fits = |bufs: *const clap_audio_buffer, n: u32| {
+ n == ports && (0..n as usize).all(|i| unsafe { &*bufs.add(i) }.channel_count == channels)
+ };
+ let ok = fits(pr.audio_inputs, pr.audio_inputs_count) && fits(pr.audio_outputs, pr.audio_outputs_count);
+ if pr.audio_outputs_count > 0 {
+ let out = unsafe { &*pr.audio_outputs };
+ for c in 0..out.channel_count as usize {
+ let o = unsafe { *out.data32.add(c) };
+ for i in 0..n {
+ unsafe { *o.add(i) = if ok { 1.0 } else { -1.0 } };
+ }
+ }
+ }
+ return CLAP_PROCESS_CONTINUE;
+ }
if pr.audio_outputs_count != 1 {
return CLAP_PROCESS_ERROR;
}
@@ -324,10 +368,26 @@ static PARAMS: clap_plugin_params = clap_plugin_params {
};
unsafe extern "C" fn ports_count(p: *const clap_plugin, is_input: bool) -> u32 {
+ if let Some((ports, _)) = unsafe { fx(p) }.wide {
+ return ports;
+ }
if is_input && unsafe { fx(p) }.synth { 0 } else { 1 }
}
unsafe extern "C" fn ports_get(p: *const clap_plugin, index: u32, is_input: bool, info: *mut clap_audio_port_info) -> bool {
+ if let Some((ports, channels)) = unsafe { fx(p) }.wide {
+ if index >= ports {
+ return false;
+ }
+ let info = unsafe { &mut *info };
+ info.id = index * 2 + u32::from(is_input);
+ write_name(&mut info.name, c"wide");
+ info.flags = if index == 0 { CLAP_AUDIO_PORT_IS_MAIN } else { 0 };
+ info.channel_count = channels;
+ info.port_type = std::ptr::null();
+ info.in_place_pair = clap_sys::id::CLAP_INVALID_ID;
+ return true;
+ }
if index != 0 || (is_input && unsafe { fx(p) }.synth) {
return false;
}
@@ -498,23 +558,32 @@ unsafe extern "C" fn on_main_thread(_p: *const clap_plugin) {}
// ---- factory + entry ----
unsafe extern "C" fn factory_count(_f: *const clap_plugin_factory) -> u32 {
- 2
+ 5
}
unsafe extern "C" fn factory_desc(_f: *const clap_plugin_factory, i: u32) -> *const clap_plugin_descriptor {
match i {
0 => &GAIN_DESC,
1 => &SYNTH_DESC,
+ 2 => &WIDE16_DESC,
+ 3 => &WIDE17_DESC,
+ 4 => &WIDE65_DESC,
_ => std::ptr::null(),
}
}
unsafe extern "C" fn factory_create(_f: *const clap_plugin_factory, host: *const clap_host, id: *const c_char) -> *const clap_plugin {
let id = unsafe { CStr::from_ptr(id) };
- let (desc, synth) = if id == c"org.soundcraft.test.gain" {
- (&GAIN_DESC as *const _, false)
+ let (desc, synth, wide) = if id == c"org.soundcraft.test.gain" {
+ (&GAIN_DESC as *const _, false, None)
} else if id == c"org.soundcraft.test.synth" {
- (&SYNTH_DESC as *const _, true)
+ (&SYNTH_DESC as *const _, true, None)
+ } else if id == c"org.soundcraft.test.wide16" {
+ (&WIDE16_DESC as *const _, false, Some((16, 64)))
+ } else if id == c"org.soundcraft.test.wide17ports" {
+ (&WIDE17_DESC as *const _, false, Some((17, 2)))
+ } else if id == c"org.soundcraft.test.wide65ch" {
+ (&WIDE65_DESC as *const _, false, Some((1, 65)))
} else {
return std::ptr::null();
};
@@ -535,6 +604,7 @@ unsafe extern "C" fn factory_create(_f: *const clap_plugin_factory, host: *const
},
host,
synth,
+ wide,
gain: 1.0,
mode: 0.0,
level: 0.0,
diff --git a/crates/clap-host/tests/fixture_e2e.rs b/crates/clap-host/tests/fixture_e2e.rs
index a6c28cae..8525d740 100644
--- a/crates/clap-host/tests/fixture_e2e.rs
+++ b/crates/clap-host/tests/fixture_e2e.rs
@@ -13,7 +13,7 @@ const SYNTH: &str = "clap:org.soundcraft.test.synth";
fn scan_lists_both_fixture_plugins() {
let dir = fixture_dir();
let found = soundcraft_clap_host::scan_paths(&[dir.to_path_buf()]);
- assert_eq!(found.len(), 2);
+ assert_eq!(found.len(), 5);
let g = found.iter().find(|d| d.id == GAIN).unwrap();
assert_eq!(g.name, "Fixture Gain");
assert_eq!(g.vendor, "SoundCraft tests");
@@ -110,6 +110,27 @@ fn synth_plays_notes_at_their_offsets() {
assert!(io[0][19].abs() < 1e-6 && (io[0][20] - 64.0 / 127.0).abs() < 1e-6, "controllers arrive as MIDI at their offset");
}
+#[test]
+fn layouts_beyond_the_host_limits_are_rejected_not_truncated() {
+ fixture_dir();
+ // Control: exactly at the limits (16 ports of 64 channels) activates and gets its full layout.
+ let mut p = soundcraft_clap_host::create("clap:org.soundcraft.test.wide16").unwrap();
+ p.prepare(44_100.0, 64, 2);
+ assert_eq!(p.latency(), 3);
+ let mut io = vec![vec![0.5f32; 64]; 2];
+ p.process(&mut io, 64);
+ assert!(io.iter().flatten().all(|&x| x == 1.0), "16x64 layout delivered as advertised: {:?}", &io[0][..4]);
+ // 17 ports, or a 65-channel port: never activated, never processed with a cut-down layout.
+ for id in ["clap:org.soundcraft.test.wide17ports", "clap:org.soundcraft.test.wide65ch"] {
+ let mut p = soundcraft_clap_host::create(id).unwrap();
+ p.prepare(44_100.0, 64, 2);
+ assert_eq!(p.latency(), 0, "{id}: not activated");
+ let mut io = vec![vec![0.5f32; 64]; 2];
+ p.process(&mut io, 64);
+ assert!(io.iter().flatten().all(|&x| x == 0.5), "{id}: the plugin never ran: {:?}", &io[0][..4]);
+ }
+}
+
#[test]
fn many_instances_create_and_drop_cleanly() {
fixture_dir();
diff --git a/crates/dsp/src/lib.rs b/crates/dsp/src/lib.rs
index d31ddac2..afa17dad 100644
--- a/crates/dsp/src/lib.rs
+++ b/crates/dsp/src/lib.rs
@@ -275,6 +275,12 @@ pub trait PluginEditor: Send {
/// Tells the editor that a parameter changed elsewhere (generic editor, automation), so the
/// GUI shows it. Values are in SoundCraft units.
fn set_param(&mut self, _id: &str, _value: f32) {}
+ /// The plugin's own text for a parameter value (SoundCraft units) when SoundCraft's
+ /// [`ParamInfo::format`] would be wrong for it. Main thread only; `None` means "format it
+ /// yourself".
+ fn value_text(&mut self, _id: &str, _value: f32) -> Option {
+ None
+ }
}
/// Reads a plugin's state on the main (UI) thread while the instance processes on the audio
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index 9b097a00..48a03408 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -23,6 +23,7 @@ serde_json.workspace = true
thiserror.workspace = true
log.workspace = true
zip.workspace = true
+craft-docpath.workspace = true
[dev-dependencies]
proptest.workspace = true
diff --git a/crates/engine/src/autosave.rs b/crates/engine/src/autosave.rs
index cb7faac1..01899d2f 100644
--- a/crates/engine/src/autosave.rs
+++ b/crates/engine/src/autosave.rs
@@ -1,7 +1,7 @@
//! Crash-recovery copies of open sessions, one folder each, written in the background, and the
//! recovery of the ones left behind with unsaved work.
-use crate::io::{Recording, open_session, sanitize_name};
+use crate::io::{Recording, open_session_linked, sanitize_name};
use crate::{Engine, EngineError, Result};
use soundcraft_audio_io::{BitDepth, EncodeOptions, FileFormat};
use soundcraft_model::{Session, SourceAudio, SourceId};
@@ -197,7 +197,7 @@ impl Autosave {
let file = if Path::new(&src.path).is_absolute() { Some(PathBuf::from(&src.path)) } else { base.as_ref().map(|b| b.join(&src.path)) };
let audio = s.pool.get(src.id);
if let Some(f) = &file
- && (!src.unsaved && f.is_file() || audio.is_none())
+ && (audio.is_none() || !src.unsaved && f.is_file())
{
src.path = f.to_string_lossy().into_owned();
continue;
@@ -291,7 +291,9 @@ pub fn leftovers(root: &Path) -> Vec {
/// media that couldn't be loaded.
pub fn recover(e: &mut Engine, left: &Leftover) -> Result> {
let mut r = Engine::default();
- let mut missing = open_session(&mut r, &left.dir.join(SESSION).to_string_lossy())?;
+ let session = left.dir.join(SESSION);
+ let links = left.origin.as_deref().map_or(session.as_path(), Path::new);
+ let mut missing = open_session_linked(&mut r, &session.to_string_lossy(), links)?;
let mut s = r.session().clone();
let unfinished = unfinished_takes(left, &s, &mut missing);
if let Some(home) = left.origin.as_deref().and_then(|o| Path::new(o).parent()) {
@@ -315,7 +317,8 @@ pub fn recover(e: &mut Engine, left: &Leftover) -> Result> {
/// is left untouched and added to `skipped`.
fn unfinished_takes(left: &Leftover, s: &Session, skipped: &mut Vec) -> Option<(Recording, Vec<(soundcraft_model::TrackId, PathBuf)>)> {
let plan: Recording = serde_json::from_str(&std::fs::read_to_string(left.dir.join(RECORDING)).ok()?).ok()?;
- let known: Vec = s.sources.iter().filter_map(|src| std::fs::canonicalize(&src.path).ok()).collect();
+ let known: Vec =
+ s.sources.iter().filter(|src| s.pool.get(src.id).is_some()).filter_map(|src| std::fs::canonicalize(&src.path).ok()).collect();
let folders = take_folders(left);
let mut takes = Vec::new();
for t in &plan.takes {
@@ -413,6 +416,7 @@ fn io_error(path: &Path, err: std::io::Error) -> EngineError {
#[cfg(test)]
mod tests {
use super::*;
+ use crate::io::open_session;
use serde_json::json;
use soundcraft_audio_io::AudioBuffer;
use soundcraft_model::{ChannelFormat, Clip, TrackKind};
diff --git a/crates/engine/src/cmd/event.rs b/crates/engine/src/cmd/event.rs
index 7231ab0e..80af311f 100644
--- a/crates/engine/src/cmd/event.rs
+++ b/crates/engine/src/cmd/event.rs
@@ -94,7 +94,7 @@ pub fn specs() -> Vec {
add_marker
),
cmd!("markers.delete", "Delete Memory Location", [], None, "{number | id}", always, delete_marker),
- cmd!("markers.edit", "Edit Memory Location", [], None, "{number | id, name?, comments?, at?, color?}", always, edit_marker),
+ cmd!("markers.edit", "Edit Memory Location", [], None, "{number | id, name?, comments?, at?, color?: [r,g,b] | null}", always, edit_marker),
cmd!(noundo "markers.recall", "Recall Memory Location", [], Some("Period + n + Period"), "{number}", always, recall_marker),
cmd!(noundo "markers.next", "Go to Next Marker", [], None, "{}", always, |e, _| step_marker(e, 1)),
cmd!(noundo "markers.previous", "Go to Previous Marker", [], None, "{}", always, |e, _| step_marker(e, -1)),
@@ -338,8 +338,23 @@ fn delete_marker(e: &mut Engine, p: &Value) -> Result {
fn edit_marker(e: &mut Engine, p: &Value) -> Result {
let i = marker_index(e, p, "markers.edit")?;
let at = position_param(e, "markers.edit", p, "at")?;
+ let color = match p.get("color") {
+ None => None,
+ Some(Value::Null) => Some(None),
+ Some(Value::Array(a)) if a.len() == 3 => {
+ let ch = |i: usize| a.get(i).and_then(Value::as_u64).and_then(|v| u8::try_from(v).ok());
+ match (ch(0), ch(1), ch(2)) {
+ (Some(r), Some(g), Some(b)) => Some(Some([r, g, b])),
+ _ => return Err(bad("markers.edit", "`color` components must be integers 0..=255")),
+ }
+ }
+ Some(_) => return Err(bad("markers.edit", "`color` must be [r,g,b] or null")),
+ };
let s = e.session_mut();
let Some(m) = s.markers.get_mut(i) else { return Err(bad("markers.edit", "gone")) };
+ if let Some(c) = color {
+ m.color = c;
+ }
// `name` is the documented new name; when it was the selector it already matches, so this is a no-op.
if let Some(n) = str_param(p, "rename").or_else(|| str_param(p, "name")) {
m.name = n.to_string();
@@ -458,6 +473,30 @@ mod tests {
assert_eq!(find(&c), Some((1000, 2000)));
}
+ /// `markers.edit` documents `color`: it sets the memory location's RGB colour, undoably; `null` clears it.
+ #[test]
+ fn edit_marker_sets_documented_color() {
+ let mut e = demo_engine();
+ let n = e.session().markers.first().unwrap().number;
+ let color = |e: &crate::Engine| e.session().markers.iter().find(|m| m.number == n).unwrap().color;
+ assert_eq!(color(&e), None);
+
+ e.execute("markers.edit", &json!({"number": n, "color": [255, 0, 0]})).unwrap();
+ assert_eq!(color(&e), Some([255, 0, 0]));
+ assert!(e.undo());
+ assert_eq!(color(&e), None);
+ assert!(e.redo());
+ assert_eq!(color(&e), Some([255, 0, 0]));
+
+ e.execute("markers.edit", &json!({"number": n, "color": null})).unwrap();
+ assert_eq!(color(&e), None);
+
+ for bad in [json!([1, 2]), json!([1, 2, 300]), json!("red"), json!([1, 2, -3])] {
+ assert!(e.execute("markers.edit", &json!({"number": n, "color": bad})).is_err());
+ assert_eq!(color(&e), None);
+ }
+ }
+
/// Constant replaces the tempo over [start, end) only; the tempo at the old end tick carries on after it.
#[test]
fn tempo_constant_is_bounded_by_its_range() {
diff --git a/crates/engine/src/cmd/event_more.rs b/crates/engine/src/cmd/event_more.rs
index c0780a55..783ddcf5 100644
--- a/crates/engine/src/cmd/event_more.rs
+++ b/crates/engine/src/cmd/event_more.rs
@@ -414,7 +414,9 @@ fn step_input(e: &mut Engine, p: &Value) -> Result {
let end = s.tempo.tick_to_samples(end_tick, sr);
// Continue the clip under (or ending at) the insertion point, else start a new one.
let host = s.track(t).and_then(|tr| {
- tr.clips().iter().filter(|c| matches!(c.content, ClipContent::Midi { .. })).find(|c| c.range().contains(at) || c.end() == at).map(|c| c.id)
+ let mut midi = tr.clips().iter().filter(|c| matches!(c.content, ClipContent::Midi { .. }));
+ // A clip starting at `at` wins over one that merely ends there.
+ midi.clone().find(|c| c.range().contains(at)).or_else(|| midi.find(|c| c.end() == at)).map(|c| c.id)
});
let host = match host {
Some(h) => h,
@@ -730,13 +732,16 @@ fn retro_record(e: &mut Engine, p: &Value) -> Result {
let t = midi_target(e, p, id)?;
let s = e.session();
let sr = s.sample_rate;
+ // Latest start tick whose longest note still ends within MAX_POSITION.
+ let max_tick = s.tempo.samples_to_ticks(MAX_POSITION, sr).saturating_sub(TICKS_PER_QUARTER * 1024).max(0);
let mut raw: Vec<(i64, Note)> = Vec::new();
for v in list.iter().take(100_000) {
let tick = match (v.get("start_ticks").and_then(Value::as_i64), v.get("start")) {
(Some(tk), _) => tk.max(0),
(None, Some(_)) => s.tempo.samples_to_ticks(position_param(e, id, v, "start")?.unwrap_or(0).max(0), sr),
_ => return Err(bad(id, "each note needs `start` or `start_ticks`")),
- };
+ }
+ .min(max_tick);
let note = Note {
pitch: i64_or(v, "pitch", 60).clamp(0, 127) as u8,
velocity: i64_or(v, "velocity", 100).clamp(1, 127) as u8,
@@ -750,7 +755,7 @@ fn retro_record(e: &mut Engine, p: &Value) -> Result {
let first = raw.iter().map(|x| x.0).min().unwrap_or(0);
// Start the clip on the bar line so the quantize grid lines up with the music.
let clip_tick = s.tempo.bar_start_tick(s.tempo.bar_beat_at_tick(first).bar).min(first).max(0);
- let end_tick = raw.iter().map(|(tk, n)| tk.saturating_add(n.length)).max().unwrap_or(first + 1);
+ let end_tick = raw.iter().map(|(tk, n)| tk.saturating_add(n.length)).max().unwrap_or_else(|| first.saturating_add(1));
let mut seq = soundcraft_midi::Sequence::default();
for (tk, mut n) in raw {
n.start = tk - clip_tick;
@@ -764,7 +769,7 @@ fn retro_record(e: &mut Engine, p: &Value) -> Result {
seq.sort();
}
let start = s.tempo.tick_to_samples(clip_tick, sr);
- let end = s.tempo.tick_to_samples(end_tick, sr);
+ let end = s.tempo.tick_to_samples(end_tick, sr).min(MAX_POSITION);
let n = seq.notes.len();
let s = e.session_mut();
let cid = s.new_clip_id();
@@ -862,6 +867,25 @@ mod tests {
assert_eq!(e.session().edit.selection.start, 3 * 24_000);
}
+ #[test]
+ fn step_input_at_clip_boundary_uses_next_clip() {
+ let (mut e, t) = midi_engine();
+ let sr = 48_000;
+ e.execute("midi.new_clip", &json!({"track": t.0, "start": 0, "end": sr})).unwrap();
+ let second = e.execute("midi.new_clip", &json!({"track": t.0, "start": sr, "end": 2 * sr})).unwrap()["clip"].as_u64().unwrap();
+ e.execute("edit.select", &json!({"tracks": [t.0], "start": sr})).unwrap();
+ let r = e.execute("event.step_input", &json!({"track": t.0, "pitch": 60, "duration": "1/4"})).unwrap();
+ assert_eq!(r["clip"].as_u64(), Some(second));
+ let mut ranges: Vec<(i64, i64)> = e.session().track(t).unwrap().clips().iter().map(|c| (c.start, c.end())).collect();
+ ranges.sort();
+ assert_eq!(ranges, vec![(0, sr), (sr, 2 * sr)]);
+ let c = e.session().find_clip(soundcraft_model::ClipId(second)).map(|(_, c)| c.clone()).unwrap();
+ match &c.content {
+ ClipContent::Midi { sequence } => assert_eq!(sequence.notes.iter().map(|n| n.start).collect::>(), vec![0]),
+ _ => panic!(),
+ }
+ }
+
#[test]
fn tempo_curves() {
let mut e = Engine::default();
@@ -943,6 +967,18 @@ mod tests {
assert!(r["bpm"].as_f64().is_some());
}
+ #[test]
+ fn retro_record_huge_start_ticks_stay_in_range() {
+ for tk in [i64::MAX, 1_000_000_000_000_000] {
+ let (mut e, t) = midi_engine();
+ let notes = json!([{"pitch": 60, "start_ticks": tk, "length_ticks": TICKS_PER_QUARTER * 1024}]);
+ e.execute("event.retrospective_record", &json!({"track": t.0, "notes": notes})).unwrap();
+ let c = e.session().track(t).unwrap().clips()[0].clone();
+ assert!(c.start >= 0 && c.length >= 1, "{tk}: {} {}", c.start, c.length);
+ assert!(c.start.saturating_add(c.length) <= MAX_POSITION, "{tk}: start {} len {}", c.start, c.length);
+ }
+ }
+
#[test]
fn move_song_start_moves_tick_material() {
let (mut e, t) = midi_engine();
diff --git a/crates/engine/src/cmd/midi.rs b/crates/engine/src/cmd/midi.rs
index 10bcd767..129fd070 100644
--- a/crates/engine/src/cmd/midi.rs
+++ b/crates/engine/src/cmd/midi.rs
@@ -126,8 +126,8 @@ fn notes_move(e: &mut Engine, p: &Value) -> Result {
let seq = seq_mut(e, id, "midi.notes_move")?;
for (i, n) in seq.notes.iter_mut().enumerate() {
if idx.contains(&i) {
- n.start = (n.start + dt).max(0);
- n.pitch = (i64::from(n.pitch) + ds).clamp(0, 127) as u8;
+ n.start = n.start.saturating_add(dt).max(0);
+ n.pitch = i64::from(n.pitch).saturating_add(ds).clamp(0, 127) as u8;
}
}
seq.sort();
@@ -157,6 +157,21 @@ mod tests {
assert!(e.execute("midi.note_edit", &json!({"clip": clip, "index": 99})).is_err());
}
+ #[test]
+ fn notes_move_huge_params_do_not_overflow() {
+ let mut e = Engine::default();
+ let t = e.session_mut().add_track(TrackKind::Instrument, ChannelFormat::Stereo, Some("Keys"));
+ let r = e.execute("midi.new_clip", &json!({"track": t.0})).unwrap();
+ let clip = r["clip"].as_u64().unwrap();
+ e.execute("midi.note_add", &json!({"clip": clip, "pitch": 60, "start_ticks": 480})).unwrap();
+ e.execute("midi.notes_move", &json!({"clip": clip, "indices": [0], "ticks": i64::MAX})).unwrap();
+ let n = e.execute("midi.notes", &json!({"clip": clip})).unwrap();
+ assert_eq!(n["notes"][0]["start"], i64::MAX);
+ e.execute("midi.notes_move", &json!({"clip": clip, "indices": [0], "semitones": i64::MAX})).unwrap();
+ let n = e.execute("midi.notes", &json!({"clip": clip})).unwrap();
+ assert_eq!(n["notes"][0]["pitch"], 127);
+ }
+
#[test]
fn rejects_audio_tracks() {
let mut e = Engine::default();
diff --git a/crates/engine/src/cmd/setup_more.rs b/crates/engine/src/cmd/setup_more.rs
index 3d436759..aee13ba1 100644
--- a/crates/engine/src/cmd/setup_more.rs
+++ b/crates/engine/src/cmd/setup_more.rs
@@ -7,7 +7,7 @@ use crate::cmd;
use serde_json::json;
use soundcraft_model::{BusId, ChannelFormat, ClipContent, OutputPath, Route, Session, SourceId, TrackId, TrackKind};
use soundcraft_time::Timecode;
-use std::path::{Path, PathBuf};
+use std::path::Path;
macro_rules! option {
($id:literal, $label:literal, $flag:literal) => {
@@ -407,7 +407,6 @@ fn import_session_data(e: &mut Engine, p: &Value) -> Result {
let path = str_param(p, "path").filter(|x| !x.trim().is_empty()).ok_or_else(|| bad(id, "`path` required"))?.to_string();
let text_v = crate::io::read_text(&path)?;
let other = Session::from_json(&text_v).map_err(|err| EngineError::Io(format!("{path}: {err}")))?;
- let dir = Path::new(&path).parent().map(Path::to_path_buf).unwrap_or_default();
let names: Option> =
p.get("tracks").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_string).collect());
let picked: Vec = match &names {
@@ -435,20 +434,27 @@ fn import_session_data(e: &mut Engine, p: &Value) -> Result {
let mut map: std::collections::BTreeMap = Default::default();
let mut missing = Vec::new();
for src in needed.iter().filter_map(|sid| other.source(*sid)) {
- let abs = if Path::new(&src.path).is_absolute() { PathBuf::from(&src.path) } else { dir.join(&src.path) };
let mut ns = src.clone();
ns.id = SourceId(s.alloc());
- ns.path = abs.to_string_lossy().into_owned();
- match crate::io::decode_file(&mut files, &abs, sr) {
- Ok(audio) => {
- ns.frames = audio.buffer.frames() as u64;
- ns.sample_rate = sr;
- ns.unsaved = true;
- s.pool.insert(ns.id, audio);
+ match crate::io::stored_path(&src.path, Path::new(&path)) {
+ Ok(abs) => {
+ ns.path = abs.to_string_lossy().into_owned();
+ match crate::io::decode_file(&mut files, &abs, sr) {
+ Ok(audio) => {
+ ns.frames = audio.buffer.frames() as u64;
+ ns.sample_rate = sr;
+ ns.unsaved = true;
+ s.pool.insert(ns.id, audio);
+ }
+ Err(_) => {
+ ns.unsaved = false;
+ missing.push(ns.path.clone());
+ }
+ }
}
- Err(_) => {
+ Err(why) => {
ns.unsaved = false;
- missing.push(ns.path.clone());
+ missing.push(format!("{}: {why}", ns.path));
}
}
map.insert(src.id.0, ns.id);
diff --git a/crates/engine/src/cmd/track.rs b/crates/engine/src/cmd/track.rs
index 87912389..cc496448 100644
--- a/crates/engine/src/cmd/track.rs
+++ b/crates/engine/src/cmd/track.rs
@@ -19,6 +19,7 @@ pub fn specs() -> Vec {
cmd!("track.group", "Group...", ["Track"], Some("Cmd+G"), "{name?, tracks?, edit?: true, mix?: true}", has_selection, group),
cmd!("track.ungroup", "Delete Group", [], None, "{group: id|name}", always, delete_group),
cmd!("track.group_toggle", "Toggle Group Active", [], None, "{group: id|name}", always, toggle_group),
+ cmd!("track.group_modify", "Modify Group", [], None, "{group: id|name, name?, tracks?, edit?, mix?}", always, modify_group),
cmd!(
"track.duplicate",
"Duplicate...",
@@ -320,6 +321,55 @@ fn toggle_group(e: &mut Engine, p: &Value) -> Result {
Ok(json!({"active": active}))
}
+/// Change an existing group's name, membership and Edit/Mix linking. Omitted fields keep their value.
+fn modify_group(e: &mut Engine, p: &Value) -> Result {
+ const CMD: &str = "track.group_modify";
+ let g = find_group(e, p, CMD)?;
+ // Absent `tracks` leaves membership alone; present, it replaces it. Only an array counts, so a
+ // mistyped param can't silently swap the members for whatever happens to be selected.
+ let members = match p.get("tracks") {
+ None => None,
+ Some(Value::Array(_)) => {
+ let mut t = tracks_param(e, CMD, p)?;
+ // A track listed twice would take every linked move twice over.
+ let mut seen = std::collections::HashSet::new();
+ t.retain(|id| seen.insert(*id));
+ if t.is_empty() {
+ return Err(bad(CMD, "a group needs at least one track"));
+ }
+ Some(t)
+ }
+ Some(_) => return Err(bad(CMD, "`tracks` must be an array of track ids or names")),
+ };
+ let name = match str_param(p, "name") {
+ None => None,
+ Some(n) => {
+ let n = n.trim();
+ if n.is_empty() {
+ return Err(bad(CMD, "`name` must not be empty"));
+ }
+ // `find_group` resolves by name, so duplicates would make a group unaddressable.
+ if e.session().groups.iter().any(|x| x.name == n && x.id != g) {
+ return Err(bad(CMD, format!("a group named `{n}` already exists")));
+ }
+ let mut n = n.to_string();
+ soundcraft_model::truncate_chars(&mut n, soundcraft_model::MAX_NAME_CHARS);
+ Some(n)
+ }
+ };
+ let s = e.session_mut();
+ let Some(gr) = s.groups.iter_mut().find(|x| x.id == g) else { return Err(bad(CMD, "unknown `group`")) };
+ if let Some(n) = name {
+ gr.name = n;
+ }
+ if let Some(m) = members {
+ gr.members = m;
+ }
+ gr.edit = bool_or(p, "edit", gr.edit);
+ gr.mix = bool_or(p, "mix", gr.mix);
+ Ok(json!({"group": g, "name": gr.name, "tracks": gr.members, "edit": gr.edit, "mix": gr.mix}))
+}
+
fn duplicate(e: &mut Engine, p: &Value) -> Result {
let tracks = tracks_required(e, "track.duplicate", p)?;
let (pl, auto, ins, snd) =
@@ -872,6 +922,35 @@ mod tests {
assert!(e.execute("track.playlist_promote", &json!({"track": kick, "playlist": 1, "start": 0, "end": 10})).is_err());
}
+ #[test]
+ fn group_modify_changes_name_membership_and_linking() {
+ let mut e = crate::demo::demo_engine();
+ let g = e.execute("track.group", &json!({"tracks": ["Kick", "Snare"], "name": "Drums"})).unwrap()["group"].as_u64().unwrap();
+ // Every field at once, the way the dialog submits it.
+ let r = e.execute("track.group_modify", &json!({"group": g, "name": "Rhythm", "tracks": ["Kick", "Bass"], "edit": false})).unwrap();
+ assert_eq!(r["name"], "Rhythm");
+ let gr = e.session().groups.iter().find(|x| x.id.0 == g).unwrap().clone();
+ assert_eq!(gr.name, "Rhythm");
+ assert_eq!(gr.members, vec![e.session().track_by_name("Kick").unwrap().id, e.session().track_by_name("Bass").unwrap().id]);
+ assert!(!gr.edit);
+ assert!(gr.mix, "an omitted field keeps its value");
+ assert_eq!(gr.letter, 'a', "the letter is the group's stable id and never changes");
+ // Omitting `tracks` leaves membership alone rather than falling back to the selection.
+ e.execute("edit.select", &json!({"tracks": ["Pad"], "exact": true})).unwrap();
+ e.execute("track.group_modify", &json!({"group": g, "name": "Rhythm Section"})).unwrap();
+ assert_eq!(e.session().groups.iter().find(|x| x.id.0 == g).unwrap().members, gr.members);
+ // Resolving the group by its new name keeps working, so names stay unique and non-empty.
+ e.execute("track.group", &json!({"tracks": ["Pad"], "name": "Pads"})).unwrap();
+ assert!(e.execute("track.group_modify", &json!({"group": "Pads", "name": "Rhythm Section"})).is_err());
+ assert!(e.execute("track.group_modify", &json!({"group": g, "name": " "})).is_err());
+ assert!(e.execute("track.group_modify", &json!({"group": g, "tracks": []})).is_err());
+ assert!(e.execute("track.group_modify", &json!({"group": g, "tracks": "Kick"})).is_err(), "`tracks` must be an array");
+ assert!(e.execute("track.group_modify", &json!({"group": g, "tracks": ["Kick", "Kick"]})).is_ok());
+ assert_eq!(e.session().groups.iter().find(|x| x.id.0 == g).unwrap().members.len(), 1, "a repeated track is listed once");
+ assert!(e.execute("track.group_modify", &json!({"group": 9999, "name": "x"})).is_err());
+ assert_eq!(e.session().groups.iter().find(|x| x.id.0 == g).unwrap().name, "Rhythm Section", "a rejected call changes nothing");
+ }
+
#[test]
fn folder_routes_members_through_its_bus() {
let mut e = crate::demo::demo_engine();
diff --git a/crates/engine/src/cmd/track_more.rs b/crates/engine/src/cmd/track_more.rs
index 290a8d5a..9f547597 100644
--- a/crates/engine/src/cmd/track_more.rs
+++ b/crates/engine/src/cmd/track_more.rs
@@ -383,6 +383,10 @@ fn write_rtp(e: &mut Engine, p: &Value) -> Result {
n.start = n.start.saturating_add(r.delay_ticks).max(0);
notes += 1;
}
+ // Playback delays controller events too, but ignores those before tick 0 (hidden by a start trim).
+ for c in sequence.ctrls.iter_mut().filter(|c| c.tick >= 0) {
+ c.tick = c.tick.saturating_add(r.delay_ticks).max(0);
+ }
sequence.sort();
}
let pre = format!("rtp.{}.", t.0);
@@ -635,6 +639,31 @@ mod tests {
assert!(!e.session().edit.values.keys().any(|k| k.starts_with(&format!("rtp.{}.", keys.0))));
}
+ #[test]
+ fn rtp_delay_shifts_controller_events() {
+ use soundcraft_midi::{CtrlEvent, CtrlKind};
+ let mut e = crate::demo::demo_engine();
+ let keys = e.session().track_by_name("Keys").unwrap().id;
+ let s = e.session_mut();
+ if let Some(pl) = s.track_mut(keys).and_then(Track::playlist_mut)
+ && let ClipContent::Midi { sequence } = &mut pl.clips[0].content
+ {
+ sequence.ctrls.clear();
+ sequence.ctrls.push(CtrlEvent { tick: 100, channel: 0, kind: CtrlKind::Cc(7), value: 90 });
+ sequence.ctrls.push(CtrlEvent { tick: 200, channel: 0, kind: CtrlKind::PitchBend, value: 10 });
+ sequence.ctrls.push(CtrlEvent { tick: -30, channel: 0, kind: CtrlKind::Cc(1), value: 5 });
+ }
+ s.edit.values.insert(track_key("rtp", keys, "delay"), 50.0);
+ e.execute("edit.select", &json!({"tracks": [keys.0]})).unwrap();
+ e.execute("track.write_midi_rtp", &json!({})).unwrap();
+ let ClipContent::Midi { sequence } = &e.session().track(keys).unwrap().clips()[0].content else { panic!() };
+ let tick_of = |k: CtrlKind| sequence.ctrls.iter().find(|c| c.kind == k).map(|c| c.tick);
+ assert_eq!(tick_of(CtrlKind::Cc(7)), Some(150), "playback delayed the CC by 50 ticks; baked result must match");
+ assert_eq!(tick_of(CtrlKind::PitchBend), Some(250));
+ // Hidden by a start trim: playback ignores it, so baking leaves it alone.
+ assert_eq!(tick_of(CtrlKind::Cc(1)), Some(-30));
+ }
+
#[test]
fn trim_and_vca_coalesce() {
let mut e = Engine::default();
diff --git a/crates/engine/src/cmd/video.rs b/crates/engine/src/cmd/video.rs
index f361e0d4..c65e40d6 100644
--- a/crates/engine/src/cmd/video.rs
+++ b/crates/engine/src/cmd/video.rs
@@ -28,7 +28,7 @@ pub fn specs() -> Vec {
always,
offset
),
- cmd!(query "video.list", "Movies", [], None, "{} — movies used by Video tracks (path, size, rate, codec, online file)", always, |e, _| {
+ cmd!(query "video.list", "Movies", [], None, "{} — movies used by Video tracks (path, size, rate, codec, online file, why it is offline)", always, |e, _| {
let s = e.session();
let rows: Vec = s
.videos
@@ -36,7 +36,8 @@ pub fn specs() -> Vec {
.map(|v| {
let clips = s.tracks.iter().flat_map(|t| t.clips()).filter(|c| c.video_source() == Some(v.id)).count();
json!({"id": v.id, "name": v.name, "path": v.path, "width": v.width, "height": v.height, "frame_rate": v.frame_rate,
- "duration": v.duration, "codec": v.codec, "clips": clips, "file_found": crate::io::file_found(&v.path)})
+ "duration": v.duration, "codec": v.codec, "clips": clips,
+ "file_found": v.offline.is_none() && crate::io::file_found(&v.path), "offline": v.offline})
})
.collect();
Ok(json!({"videos": rows, "online": !s.edit.flag(OFFLINE_FLAG)}))
@@ -92,6 +93,7 @@ mod tests {
frame_rate: 24.0,
duration: 2.0,
codec: "h264".into(),
+ offline: None,
});
let c = s.new_clip_id();
crate::edit::place_clip(s, t, Clip::video(c, "m", vid, 0, 1000, 96_000));
diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index 7b26e0b1..e04cfbc9 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -60,6 +60,23 @@ pub fn file_found(path: impl AsRef) -> bool {
crate::file_access::check_read(path).is_ok() && path.is_file()
}
+/// The file a path stored in the session file `session` refers to, or why it is not opened.
+///
+/// Every path a session names (audio sources, movies) goes through here before it reaches the
+/// file system. A relative path is taken from the session's folder, and only files on this
+/// computer or on the network share the session itself is on are opened (`craft_docpath`).
+/// Paths the person picks in this session (imports) are not stored paths and skip this.
+pub fn stored_path(stored: &str, session: &Path) -> std::result::Result {
+ let session = std::path::absolute(session).unwrap_or_else(|_| session.to_path_buf());
+ let path = craft_docpath::resolve(stored, Some(&session)).map_err(|why| format!("not opened: {why}"))?;
+ // A path that is still relative would be taken from the working directory, which the session
+ // does not choose.
+ if path.is_relative() {
+ return Err("not opened: the path is not absolute".into());
+ }
+ Ok(path)
+}
+
/// Create `dir` and its parents, inside the automation write root when there is one.
pub(crate) fn make_dir(dir: impl AsRef) -> Result<()> {
let dir = dir.as_ref();
@@ -206,6 +223,7 @@ pub fn import_video_bytes(e: &mut Engine, path: &str, bytes: Vec, at: Sample
frame_rate: info.frame_rate,
duration: info.duration,
codec: info.codec.clone(),
+ offline: None,
});
// Reuse the first Video track when the new clip does not overlap its clips; else add one at the top.
let range = Range::new(at, at.saturating_add(len));
@@ -235,22 +253,35 @@ pub fn import_video_bytes(e: &mut Engine, path: &str, bytes: Vec, at: Sample
}))
}
-/// Resolve each referenced movie: keep it when its path exists, else look for a file of the same
-/// name next to the session (moved projects) and relink. Returns the movies still missing.
-pub fn relink_videos(s: &mut Session, session_dir: &Path) -> Vec {
+/// Resolve each movie referenced by the session file `session` ([`stored_path`]): keep the
+/// resolved path when its file exists, else look for a file of the same name next to the session
+/// (moved projects) and relink. A movie whose stored path is refused and has no such copy is
+/// marked offline. Returns the movies still missing.
+pub fn relink_videos(s: &mut Session, session: &Path) -> Vec {
+ let session_dir = session.parent().unwrap_or(Path::new(""));
let mut missing = Vec::new();
for v in &mut s.videos {
- let p = if Path::new(&v.path).is_absolute() { PathBuf::from(&v.path) } else { session_dir.join(&v.path) };
- if file_found(&p) {
+ v.offline = None;
+ let p = stored_path(&v.path, session);
+ // The UI opens `path` as it is: keep the checked path, not one relative to the working
+ // directory.
+ if let Ok(found) = &p
+ && file_found(found)
+ {
+ v.path = found.to_string_lossy().into_owned();
continue;
}
let name = Path::new(&v.path).file_name().map(PathBuf::from).unwrap_or_default();
let near = [session_dir.join(&name), session_dir.join("Video Files").join(&name)]
.into_iter()
.find(|c| !name.as_os_str().is_empty() && file_found(c));
- match near {
- Some(c) => v.path = c.to_string_lossy().into_owned(),
- None => missing.push(format!("{} (video)", p.display())),
+ match (near, p) {
+ (Some(c), _) => v.path = c.to_string_lossy().into_owned(),
+ (None, Ok(p)) => missing.push(format!("{} (video)", p.display())),
+ (None, Err(why)) => {
+ missing.push(format!("{} (video): {why}", v.path));
+ v.offline = Some(why);
+ }
}
}
missing
@@ -1096,19 +1127,26 @@ fn store_wav(dir: &Path, stem: &str, bytes: &[u8]) -> Result<(String, bool)> {
/// Open a `.scraft` session and decode its audio files (missing files are reported, not fatal).
pub fn open_session(e: &mut Engine, path: &str) -> Result> {
+ open_session_linked(e, path, Path::new(path))
+}
+
+/// [`open_session`], following the media paths in it as if they were stored in the session file
+/// `links` (crash recovery: the session written beside the autosave, its paths from the original).
+pub(crate) fn open_session_linked(e: &mut Engine, path: &str, links: &Path) -> Result> {
let text = read_text(path)?;
let mut s = Session::from_json(&text).map_err(|err| EngineError::Io(err.to_string()))?;
let dir = Path::new(path).parent().map(Path::to_path_buf).unwrap_or_default();
let mut missing = Vec::new();
let mut files = DecodedFiles::new();
for src in &s.sources {
- let p = if Path::new(&src.path).is_absolute() { PathBuf::from(&src.path) } else { dir.join(&src.path) };
- match decode_file(&mut files, &p, s.sample_rate.hz()) {
+ let decoded =
+ stored_path(&src.path, links).map_err(|why| format!("{}: {why}", src.path)).and_then(|p| decode_file(&mut files, &p, s.sample_rate.hz()));
+ match decoded {
Ok(audio) => s.pool.insert(src.id, audio),
Err(err) => missing.push(err),
}
}
- missing.extend(relink_videos(&mut s, &dir));
+ missing.extend(relink_videos(&mut s, links));
s.folder = Some(dir);
e.replace_session(s);
e.path = Some(path.to_string());
@@ -1350,18 +1388,25 @@ pub struct Take {
/// Place recorded take files as `plan` says, as one undo step ("Record").
pub fn place_recording(e: &mut Engine, plan: &Recording, takes: Vec<(TrackId, PathBuf)>) -> Vec {
- let ids = add_recording(e, plan.start, takes, plan.pass);
- if let Some(p) = plan.punch {
- let clips: Vec = ids.iter().map(|c| c.0).collect();
- let _ = e.execute_merged("edit.trim_to_fill_selection", &json!({"clips": clips, "start": p.start, "end": p.end}), "record");
- }
- ids
+ add_recording_in(e, plan.start, takes, plan.pass, plan.punch)
}
/// Turn recorded take files into clips at `start`, as one undo step ("Record"); each file is the
/// source of its clips. With `pass` (loop recording), a take becomes one clip per pass (at most
/// 1000), each pass after the first on a new playlist.
pub fn add_recording(e: &mut Engine, start: Samples, takes: Vec<(TrackId, PathBuf)>, pass: Option) -> Vec {
+ add_recording_in(e, start, takes, pass, None)
+}
+
+/// [`add_recording`] limited to the `punch` range: each clip is cut to it before it's placed, so
+/// the material around the punch isn't overwritten.
+fn add_recording_in(
+ e: &mut Engine,
+ start: Samples,
+ takes: Vec<(TrackId, PathBuf)>,
+ pass: Option,
+ punch: Option,
+) -> Vec {
let before = e.session_arc();
let mut out = Vec::new();
for (tid, path) in takes {
@@ -1384,6 +1429,13 @@ pub fn add_recording(e: &mut Engine, start: Samples, takes: Vec<(TrackId, PathBu
if offset > 0 && n < pass / 8 {
break;
}
+ let (clip_start, cut, clip_len) = match punch {
+ Some(p) => {
+ let Some(kept) = Range::new(start, start.saturating_add(n)).intersect(&p) else { continue };
+ (kept.start, kept.start.saturating_sub(start), kept.len())
+ }
+ None => (start, 0, n),
+ };
if offset > 0
&& let Some(t) = s.track_mut(tid)
{
@@ -1391,7 +1443,7 @@ pub fn add_recording(e: &mut Engine, start: Samples, takes: Vec<(TrackId, PathBu
t.active_playlist = t.playlists.len() - 1;
}
let cid = s.new_clip_id();
- crate::edit::place_clip(s, tid, Clip::audio(cid, name, src, offset, start, n));
+ crate::edit::place_clip(s, tid, Clip::audio(cid, name, src, offset.saturating_add(cut), clip_start, clip_len));
out.push(cid);
}
}
@@ -1473,6 +1525,30 @@ mod record_tests {
let _ = std::fs::remove_dir_all(&dir);
}
+ #[test]
+ fn punching_in_keeps_the_material_around_the_punch_range() {
+ let dir = std::env::temp_dir().join(format!("soundcraft-punch-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ let mut e = Engine::default();
+ let vox = armed(&mut e, "Vox", "mono", "In 1");
+ let base = dir.join("Audio Files/Base.wav");
+ let take = dir.join("Audio Files/Take.wav");
+ write_take(&base, 3_000);
+ write_take(&take, 1_000);
+ add_recording(&mut e, 0, vec![(vox, base)], None);
+ let plan = Recording {
+ start: 1_000,
+ pass: None,
+ punch: Some(Range::new(1_400, 1_600)),
+ rate: 48_000,
+ takes: vec![Take { track: vox, path: take.clone(), channels: 1 }],
+ };
+ place_recording(&mut e, &plan, vec![(vox, take)]);
+ let clips: Vec<_> = e.session().track(vox).unwrap().clips().iter().map(|c| (c.start, c.length, c.source_offset())).collect();
+ assert_eq!(clips, vec![(0, 1_400, 0), (1_400, 200, 400), (1_600, 1_400, 1_600)]);
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
#[test]
fn a_take_shows_the_pass_under_way_within_the_punch_while_it_records() {
assert_eq!(live_span(1_000, None, None, 0), None);
@@ -1731,6 +1807,60 @@ mod open_tests {
assert_eq!(std::fs::read_dir(dir.join("copy/Audio Files")).unwrap().count(), 1);
let _ = std::fs::remove_dir_all(&dir);
}
+ #[test]
+ fn stored_media_paths_are_followed_only_on_this_computer() {
+ let dir = std::env::temp_dir().join(format!("soundcraft-stored-paths-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ std::fs::create_dir_all(&dir).unwrap();
+ let audio = AudioBuffer { sample_rate: 48_000, channels: vec![vec![0.25; 480]] };
+ std::fs::write(dir.join("k.wav"), soundcraft_audio_io::encode(&audio, &EncodeOptions::default()).unwrap()).unwrap();
+ let mut saved = Session::default();
+ let t = saved.add_track(TrackKind::Audio, ChannelFormat::Mono, None);
+ let src = add_source(&mut saved, "k", audio, Some("../k.wav"), FileFormat::Wav);
+ let id = saved.new_clip_id();
+ crate::edit::place_clip(&mut saved, t, Clip::audio(id, "k", src, 0, 0, 480));
+ // In a folder of its own, so a movie named `k.wav` is not relinked to a file beside it.
+ std::fs::create_dir_all(dir.join("s")).unwrap();
+ let path = dir.join("s").join("Song.scraft").to_string_lossy().into_owned();
+ let mut stored = vec![r"\\192.0.2.1\share\x.wav".to_string(), "file://192.0.2.1/s/x.wav".to_string()];
+ // Linux reads `//tmp/…` as the local `/tmp/…`, so only the path check keeps it from being read.
+ if cfg!(unix) {
+ stored.push(format!("/{}", dir.join("k.wav").display()));
+ }
+ let refused = |m: &str| m.contains("not opened: the path is on another computer");
+ for p in stored {
+ let mut s = saved.clone();
+ s.sources[0].path.clone_from(&p);
+ let id = SourceId(s.alloc());
+ s.videos.push(soundcraft_model::VideoSource {
+ id,
+ name: "x".into(),
+ path: p.clone(),
+ width: 0,
+ height: 0,
+ frame_rate: 0.0,
+ duration: 0.0,
+ codec: String::new(),
+ offline: None,
+ });
+ std::fs::write(&path, s.to_json().unwrap()).unwrap();
+ let mut r = Engine::default();
+ let missing = open_session(&mut r, &path).unwrap();
+ assert_eq!(missing.iter().filter(|m| refused(m)).count(), 2, "{p}: {missing:?}");
+ assert!(r.session().pool.get(r.session().sources[0].id).is_none(), "{p}");
+ assert!(r.session().videos[0].offline.is_some(), "{p}");
+ let mut into = Engine::default();
+ let imported = into.execute("file.import_session_data", &json!({"path": path})).unwrap();
+ assert!(imported["missing"].as_array().unwrap().iter().any(|m| m.as_str().is_some_and(refused)), "{p}: {imported}");
+ assert!(into.session().pool.get(into.session().sources[0].id).is_none(), "{p}");
+ }
+ // A path relative to the session opens.
+ std::fs::write(&path, saved.to_json().unwrap()).unwrap();
+ let mut r = Engine::default();
+ assert!(open_session(&mut r, &path).unwrap().is_empty());
+ assert!(r.session().pool.get(r.session().sources[0].id).is_some());
+ let _ = std::fs::remove_dir_all(&dir);
+ }
}
#[cfg(test)]
diff --git a/crates/engine/tests/clap_e2e.rs b/crates/engine/tests/clap_e2e.rs
index cd554a9d..96743198 100644
--- a/crates/engine/tests/clap_e2e.rs
+++ b/crates/engine/tests/clap_e2e.rs
@@ -40,7 +40,7 @@ fn install_fixture_now() {
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::copy(target.join("debug").join(lib), dir.join("Fixture.clap")).unwrap();
- assert_eq!(soundcraft_clap_host::add_search_dir(&dir), 2);
+ assert_eq!(soundcraft_clap_host::add_search_dir(&dir), 5);
}
#[test]
diff --git a/crates/model/src/session.rs b/crates/model/src/session.rs
index 449d82da..b72818dc 100644
--- a/crates/model/src/session.rs
+++ b/crates/model/src/session.rs
@@ -695,6 +695,7 @@ mod tests {
frame_rate: 23.976,
duration: 12.5,
codec: "prores".into(),
+ offline: None,
});
let cid = s.new_clip_id();
if let Some(p) = s.track_mut(t).and_then(Track::playlist_mut) {
@@ -749,6 +750,17 @@ mod tests {
assert_eq!((s.sample_rate, s.tempo), (SampleRate::HZ_48000, TempoMap::default()));
}
+ #[test]
+ fn a_meter_change_far_beyond_the_position_range_is_dropped_on_load() {
+ let mut v = serde_json::to_value(Session::default()).unwrap();
+ v["tempo"]["meters"] = serde_json::json!([
+ {"tick": 0, "numerator": 4, "denominator": 4},
+ {"tick": i64::MAX, "numerator": 3, "denominator": 4}
+ ]);
+ let s = Session::from_json(&v.to_string()).unwrap();
+ assert_eq!(s.parse_position("2|1|000", TimeFormat::BarsBeats), Ok(96_000));
+ }
+
#[test]
fn rejects_garbage_and_future_versions() {
assert!(Session::from_json("not json").is_err());
diff --git a/crates/model/src/source.rs b/crates/model/src/source.rs
index 5da35e76..c7c8a341 100644
--- a/crates/model/src/source.rs
+++ b/crates/model/src/source.rs
@@ -46,6 +46,9 @@ pub struct VideoSource {
/// Codec id (`h264`, `prores`, `mjpeg`, `hevc`, …).
#[serde(default)]
pub codec: String,
+ /// Why the movie is not opened, when its stored path was refused on opening the session.
+ #[serde(skip)]
+ pub offline: Option,
}
impl VideoSource {
diff --git a/crates/playback/src/lib.rs b/crates/playback/src/lib.rs
index b945d4b6..e290727d 100644
--- a/crates/playback/src/lib.rs
+++ b/crates/playback/src/lib.rs
@@ -726,6 +726,12 @@ impl Player {
}
}
+ /// The plugin's own text for a parameter value when SoundCraft's format would be wrong for it
+ /// (see `PluginEditor::value_text`). Main thread only.
+ pub fn editor_value_text(&self, track: TrackId, slot: usize, id: &str, value: f32) -> Option {
+ self.side().editors.get_mut(&(track, slot))?.value_text(id, value)
+ }
+
/// Start playback at `from`, stopping at `end`, or looping `looped`.
pub fn play(&self, from: Samples, end: Option, looped: Option) {
self.shared.position.store(from, Ordering::Relaxed);
diff --git a/crates/time/src/format.rs b/crates/time/src/format.rs
index bdd2fcb1..3c11c844 100644
--- a/crates/time/src/format.rs
+++ b/crates/time/src/format.rs
@@ -43,7 +43,8 @@ impl TimeFormat {
fn min_secs(s: Samples, sr: SampleRate) -> String {
let neg = s < 0;
- let ms_total = (sr.seconds(s.saturating_abs()) * 1000.0).floor() as i64;
+ // Integer maths: a float `seconds * 1000` lands just below exact millisecond positions.
+ let ms_total = i64::try_from(i128::from(s).abs() * 1000 / i128::from(sr.hz().max(1))).unwrap_or(i64::MAX);
let mins = ms_total / 60_000;
let secs = (ms_total / 1000) % 60;
let ms = ms_total % 1000;
diff --git a/crates/time/src/tempo.rs b/crates/time/src/tempo.rs
index 6d16471b..24a8f49a 100644
--- a/crates/time/src/tempo.rs
+++ b/crates/time/src/tempo.rs
@@ -1,6 +1,6 @@
//! Tempo and meter maps: the conversion between musical time (ticks) and samples.
-use crate::{SampleRate, Samples, TimeError, to_samples};
+use crate::{MAX_POSITION, SampleRate, Samples, TimeError, to_samples};
/// Ticks per quarter note (Pro Tools' resolution).
pub const TICKS_PER_QUARTER: i64 = 960;
@@ -74,17 +74,17 @@ impl TempoMap {
&self.meters
}
- /// Repair a map read from a file: only valid tempos and meters, in tick order, with one of each
- /// at tick 0.
+ /// Repair a map read from a file: only valid tempos and meters within `0..=MAX_POSITION` ticks, in
+ /// tick order, with one of each at tick 0.
pub fn sanitize(&mut self) {
- self.tempos.retain(|e| e.tick >= 0 && valid_bpm(e.bpm).is_ok());
+ self.tempos.retain(|e| (0..=MAX_POSITION).contains(&e.tick) && valid_bpm(e.bpm).is_ok());
self.tempos.sort_by_key(|e| e.tick);
self.tempos.dedup_by_key(|e| e.tick);
if self.tempos.first().is_none_or(|e| e.tick > 0) {
let bpm = self.tempos.first().map_or(120.0, |e| e.bpm);
self.tempos.insert(0, TempoEvent { tick: 0, bpm });
}
- self.meters.retain(|m| m.tick >= 0 && valid_meter(m.numerator, m.denominator));
+ self.meters.retain(|m| (0..=MAX_POSITION).contains(&m.tick) && valid_meter(m.numerator, m.denominator));
self.meters.sort_by_key(|m| m.tick);
self.meters.dedup_by_key(|m| m.tick);
if self.meters.first().is_none_or(|m| m.tick > 0) {
@@ -386,6 +386,17 @@ mod tests {
assert_eq!(empty, TempoMap::default());
}
+ #[test]
+ fn sanitize_drops_events_beyond_the_position_range() {
+ let mut m = TempoMap {
+ tempos: vec![TempoEvent { tick: 0, bpm: 120.0 }, TempoEvent { tick: i64::MAX, bpm: 90.0 }],
+ meters: vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }, MeterEvent { tick: i64::MAX, numerator: 3, denominator: 4 }],
+ };
+ m.sanitize();
+ assert_eq!(m, TempoMap::default());
+ assert_eq!(m.bar_start_tick(2), TICKS_PER_QUARTER * 4);
+ }
+
#[test]
fn rejects_bad_values() {
let mut m = TempoMap::default();
diff --git a/crates/time/tests/min_secs_exact_ms.rs b/crates/time/tests/min_secs_exact_ms.rs
new file mode 100644
index 00000000..738a4bf4
--- /dev/null
+++ b/crates/time/tests/min_secs_exact_ms.rs
@@ -0,0 +1,36 @@
+//! Min:Secs shows exact millisecond positions exactly (no float-floor off-by-one).
+
+use soundcraft_time::{FrameRate, SampleRate, TempoMap, TimeFormat, format_position};
+
+fn min_secs(s: i64, sr: SampleRate) -> String {
+ format_position(s, TimeFormat::MinSecs, sr, &TempoMap::default(), FrameRate::default(), 0, 0)
+}
+
+fn expected(ms_total: i64) -> String {
+ format!("{}:{:02}.{:03}", ms_total / 60_000, (ms_total / 1000) % 60, ms_total % 1000)
+}
+
+#[test]
+fn known_positions_at_44100() {
+ assert_eq!(min_secs(88_641, SampleRate::HZ_44100), "0:02.010");
+ assert_eq!(min_secs(89_523, SampleRate::HZ_44100), "0:02.030");
+}
+
+#[test]
+fn negative_position_at_44100() {
+ assert_eq!(min_secs(-88_641, SampleRate::HZ_44100), "-0:02.010");
+}
+
+#[test]
+fn every_exact_millisecond_displays_exactly() {
+ for sr in [SampleRate::HZ_44100, SampleRate::HZ_48000] {
+ let hz = i64::from(sr.hz());
+ for ms in 0..=600_000_i64 {
+ if (ms * hz) % 1000 != 0 {
+ continue;
+ }
+ let s = ms * hz / 1000;
+ assert_eq!(min_secs(s, sr), expected(ms), "{hz} Hz, sample {s}");
+ }
+ }
+}
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 713e94b7..d752c16e 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -5,7 +5,7 @@ use crate::theme::{Tokens, bold};
use egui::{Align2, vec2};
use serde_json::{Value, json};
use soundcraft_engine::Engine;
-use soundcraft_model::{ClipId, Session, SourceId, TrackId};
+use soundcraft_model::{ClipId, GroupId, Session, SourceId, TrackId};
use soundcraft_time::Samples;
#[derive(Debug, Clone)]
@@ -23,7 +23,8 @@ pub enum Dialog {
Spot(crate::spot::Spot),
Fades { shape: String },
StripSilence { threshold: f64, min_ms: f64, pre_ms: f64, post_ms: f64 },
- Group { name: String, edit: bool, mix: bool, members: Vec<(u64, String, bool)> },
+ // `id: None` creates (Track › Group…); `id: Some` modifies that group (Groups list › Modify Group…).
+ Group { id: Option, name: String, edit: bool, mix: bool, members: Vec<(u64, String, bool)> },
Session { frame_rate: String, bit_depth: String },
ScoreSetup { title: String, composer: String, bars_per_system: u32, show_track_names: bool },
SaveChanges { then: (String, Value) },
@@ -34,6 +35,8 @@ pub struct Dialogs {
pub open: Option