diff --git a/.gitea/workflows/check.yml b/.gitea/workflows/check.yml index 37b0381..c4b713c 100644 --- a/.gitea/workflows/check.yml +++ b/.gitea/workflows/check.yml @@ -22,7 +22,7 @@ jobs: strategy: fail-fast: false matrix: - plugin: [rivet, patina, anvil, crucible, lathe, temper, weld, knurl, planish, braze, quench, ballast] + plugin: [rivet, patina, anvil, crucible, lathe, temper, weld, knurl, planish, braze, quench, ballast, forge] steps: - uses: https://github.com/actions/checkout@v4 with: @@ -66,6 +66,7 @@ jobs: cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/braze.png --plugin braze cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/quench.png --plugin quench cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/ballast.png --plugin ballast + cargo run --manifest-path tools/editor-check/Cargo.toml --locked -- target/editor/forge.png --plugin forge - uses: https://github.com/actions/upload-artifact@v3-node20 with: name: editor-previews @@ -101,6 +102,7 @@ jobs: python3 scripts/build-plugin.py --plugin braze --target x86_64-pc-windows-gnu python3 scripts/build-plugin.py --plugin quench --target x86_64-pc-windows-gnu python3 scripts/build-plugin.py --plugin ballast --target x86_64-pc-windows-gnu + python3 scripts/build-plugin.py --plugin forge --target x86_64-pc-windows-gnu python3 scripts/package-windows.py - uses: https://github.com/actions/upload-artifact@v3-node20 with: diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml index 8c142f3..af63c6b 100644 --- a/.gitea/workflows/release.yml +++ b/.gitea/workflows/release.yml @@ -1,7 +1,7 @@ name: Independent plugin release on: push: - tags: ["rivet-v*", "patina-v*", "anvil-v*", "crucible-v*", "lathe-v*", "temper-v*", "weld-v*", "knurl-v*", "planish-v*", "braze-v*", "quench-v*", "ballast-v*"] + tags: ["rivet-v*", "patina-v*", "anvil-v*", "crucible-v*", "lathe-v*", "temper-v*", "weld-v*", "knurl-v*", "planish-v*", "braze-v*", "quench-v*", "ballast-v*", "forge-v*"] permissions: contents: read diff --git a/Cargo.lock b/Cargo.lock index 069d7e4..c33c362 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -202,6 +202,34 @@ version = "0.31.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc7e7a64c02cf7a5b51e745a9e45f60660a286f151c238b9d397b3e923f5082f" +[[package]] +name = "forge-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "knurl-core", + "lathe-core", + "serde", + "serde_json", + "temper-core", +] + +[[package]] +name = "forge-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "forge-core", + "knurl-core", + "knurl-ui", + "lathe-core", + "lathe-ui", + "temper-core", + "temper-ui", +] + [[package]] name = "itoa" version = "1.0.18" diff --git a/Cargo.toml b/Cargo.toml index 9e666a0..681e48d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] resolver = "2" -members = ["plugins/common/ui", "plugins/common/dsp", "plugins/anvil/core", "plugins/anvil/ui", "plugins/lathe/core", "plugins/lathe/ui", "plugins/temper/core", "plugins/temper/ui", "plugins/weld/core", "plugins/weld/ui", "plugins/knurl/core", "plugins/knurl/ui", "plugins/planish/core", "plugins/planish/ui", "plugins/braze/core", "plugins/braze/ui", "plugins/quench/core", "plugins/quench/ui", "plugins/ballast/core", "plugins/ballast/ui", "plugins/crucible/core", "plugins/crucible/ui", "plugins/rivet/core", "plugins/rivet/midi", "plugins/rivet/preview", "plugins/rivet/app", "plugins/patina/core", "plugins/patina/render", "plugins/patina/ui"] +members = ["plugins/common/ui", "plugins/common/dsp", "plugins/anvil/core", "plugins/anvil/ui", "plugins/lathe/core", "plugins/lathe/ui", "plugins/temper/core", "plugins/temper/ui", "plugins/weld/core", "plugins/weld/ui", "plugins/knurl/core", "plugins/knurl/ui", "plugins/planish/core", "plugins/planish/ui", "plugins/braze/core", "plugins/braze/ui", "plugins/quench/core", "plugins/quench/ui", "plugins/ballast/core", "plugins/ballast/ui", "plugins/forge/core", "plugins/forge/ui", "plugins/crucible/core", "plugins/crucible/ui", "plugins/rivet/core", "plugins/rivet/midi", "plugins/rivet/preview", "plugins/rivet/app", "plugins/patina/core", "plugins/patina/render", "plugins/patina/ui"] exclude = ["plugins/rivet/plugin", "tools/editor-check", "plugins/patina/plugin", "plugins/anvil/plugin", "plugins/crucible/plugin", "plugins/lathe/plugin", "plugins/temper/plugin", "plugins/weld/plugin", "plugins/knurl/plugin", "plugins/planish/plugin"] [workspace.package] @@ -35,3 +35,5 @@ opt-level = 2 opt-level = 2 [profile.dev.package.ballast-core] opt-level = 2 +[profile.dev.package.forge-core] +opt-level = 2 diff --git a/README.md b/README.md index 94071b4..3c44f0b 100644 --- a/README.md +++ b/README.md @@ -32,9 +32,10 @@ note. Each plugin is a separate product with its own version, guide and release. | **[Braze](docs/braze/README.md)** | Adds a detuned copy whose beating stays on the tempo grid on every note: reese movement in time | Bass | ≈ 67 ms | [Guide](docs/braze/README.md) · [Changes](docs/braze/CHANGELOG.md) | | **[Quench](docs/quench/README.md)** | Clips the top as hard as you like while the sub passes clean: the low end keeps its level under a loud master | Master or bass bus, last | < 1 ms (oversampling) | [Guide](docs/quench/README.md) · [Changes](docs/quench/CHANGELOG.md) | | **[Ballast](docs/ballast/README.md)** | Levels every note or switch-up to one loudness with a single gain each: no compression inside a part | Bass, after the sound design | ≈ 172 ms | [Guide](docs/ballast/README.md) · [Changes](docs/ballast/CHANGELOG.md) | +| **[Forge](docs/forge/README.md)** | Lathe, Temper and Knurl as one channel strip behind one note tracker, in any order: one lookahead, and no module hears Knurl's sub-octave | Bass, after the synth | ≈ 72 ms | [Guide](docs/forge/README.md) · [Changes](docs/forge/CHANGELOG.md) | Plugins with latency report it to the host, so FL Studio compensates the delay. -Anvil, Lathe, Temper, Knurl, Planish, Braze and Ballast detect notes from the audio. They can also take the +Anvil, Lathe, Temper, Knurl, Planish, Braze, Ballast and Forge detect notes from the audio. They can also take the pitch from MIDI. The order of the plugins matters: see [Signal chain](docs/chain.md). The names come from metalwork: a **rivet** joins pieces; **patina** changes a @@ -44,7 +45,8 @@ turns a piece so each cut lands the same all the way round; **tempering** sets how hard and how tough a metal ends up; a **weld** fuses two pieces into one; **knurling** presses a ridged grip pattern into a surface; **planishing** hammers a surface smooth and even; **brazing** joins two metals with a filler; **quenching** hardens hot metal in one -fast step; **ballast** is the weight that keeps a ship level. +fast step; **ballast** is the weight that keeps a ship level; a **forge** is the hearth where +every piece is heated and worked. The suite is the **foundry**: the workshop where the bass gets cast, shaped and finished. Hosts list the plugins under the vendor name *Bass Foundry*. @@ -75,6 +77,9 @@ finished. Hosts list the plugins under the vendor name *Bass Foundry*. Quench editor
Quench: sub-safe clipper Ballast editor
Ballast: switch-up leveller + + Forge editor
Forge: tracked channel strip + The previews are rendered headless from the real editor code by @@ -133,7 +138,7 @@ cargo run --manifest-path tools/editor-check/Cargo.toml -- target/editor/lathe.p ``` Plugin names for the scripts are `rivet`, `patina`, `anvil`, `crucible`, -`lathe`, `temper`, `weld`, `knurl`, `planish`, `braze`, `quench` and `ballast`. Builds go to `dist//.clap`. No +`lathe`, `temper`, `weld`, `knurl`, `planish`, `braze`, `quench`, `ballast` and `forge`. Builds go to `dist//.clap`. No script installs anything into a DAW. [Development and testing](docs/development.md) has the full command list. @@ -175,6 +180,7 @@ plugins/ braze/ core · ui · plugin quench/ core · ui · plugin ballast/ core · ui · plugin + forge/ core · ui · plugin common/ ui/ Shared look: palette, embedded fonts, knobs, panels, meters dsp/ Shared filters, pitch tracking, oversampling, meters, WAV files diff --git a/docs/chain.md b/docs/chain.md index 8e46e6e..a94739b 100644 --- a/docs/chain.md +++ b/docs/chain.md @@ -1,19 +1,24 @@ # Signal chain The order of the Bass Foundry plugins in a chain matters. Anvil, Lathe, Temper, -Knurl, Planish, Braze and Ballast each detect the pitch from the audio they receive. If a plugin earlier +Knurl, Planish, Braze, Ballast and Forge each detect the pitch from the audio they receive. If a plugin earlier in the chain changes the audio, the pitch detection after it can go wrong. ## Recommended order ```text bass track: synth → Lathe → Temper → Planish → Braze → Knurl → Patina → Ballast → Weld + or: synth → Forge (Lathe, Temper, Knurl) → Planish → Braze → Patina → Ballast → Weld bass bus: Anvil → (bus compression) → Quench → Crucible master: … → Quench (last, or before a true-peak limiter) ``` - **Lathe and Temper before Knurl.** They hear the plain synth, where the pitch is clear. +- **Or Forge in their place.** Forge runs Lathe, Temper and Knurl behind one + tracker that reads its input, so the order inside it does not upset the pitch + detection, and the three cost one lookahead (about 72 ms) instead of three. + Planish and Braze then come after Knurl: run them from MIDI. - **Planish after the distortion, before Knurl.** OTT usually comes after distortion. Planish's band edges follow the tracked note, so it also needs a clear pitch: after Knurl, use MIDI. @@ -58,13 +63,15 @@ tracker on a saw bass: its phase on each, Lathe, Temper and Planish retune on each. When a tracked plugin must come after Knurl, select **MIDI** as its pitch source -and route the bass's MIDI notes to it. +and route the bass's MIDI notes to it. Inside Forge this does not apply: its one +tracker reads the input before Knurl. ## Latency Each tracked plugin adds its own lookahead: Anvil 80 ms, Lathe, Temper, Planish and Braze about 67 ms, Knurl about 71 ms, Patina about 45 ms, Ballast -about 172 ms, Quench under 1 ms. A full chain is +about 172 ms, Quench under 1 ms. Forge holds Lathe, Temper and Knurl in about +72 ms, against about 206 ms for the three plugins in a row. A full chain is about 400 ms. FL Studio compensates this for playback and rendering, but playing a MIDI keyboard through the full chain is not practical. Write with a shorter chain and add the diff --git a/docs/development.md b/docs/development.md index 3648d4b..47075f6 100644 --- a/docs/development.md +++ b/docs/development.md @@ -25,8 +25,10 @@ Patina has `render` for offline WAV evaluation. The shared crates are: - `common-ui`: palette, embedded fonts, header, panels, knobs, meters. - `common-dsp`: filters, YIN pitch tracking, the note tracker used by Anvil, - Lathe, Temper, Knurl, Planish, Braze and Ballast, 4× oversampling (also Quench's), - BS.1770 K-weighting (Ballast), meters and WAV files. + Lathe, Temper, Knurl, Planish, Braze, Ballast and Forge (with the `Tracked` + module trait that lets Lathe, Temper and Knurl run behind one shared tracker), + 4× oversampling (also Quench's), BS.1770 K-weighting (Ballast), meters and WAV + files. The wrappers stay separate workspaces, each with its own lockfile, so the NIH-plug Git dependency stays out of the root workspace. Host identities and @@ -46,7 +48,7 @@ python3 -m unittest discover -s scripts/tests -v ``` Products: `rivet`, `patina`, `anvil`, `crucible`, `lathe`, `temper`, `weld`, -`knurl`, `planish`, `braze`, `quench`, `ballast`. +`knurl`, `planish`, `braze`, `quench`, `ballast`, `forge`. `check-plugin.py` runs formatting, tests and clippy for one product's packages and its wrapper, without compiling the other products. Run it for every product @@ -149,6 +151,7 @@ identify plugins by CLAP ID, so the vendor name does not affect saved projects. | Braze | (new) | `io.narl.bass-foundry.braze` | | Quench | (new) | `io.narl.bass-foundry.quench` | | Ballast | (new) | `io.narl.bass-foundry.ballast` | +| Forge | (new) | `io.narl.bass-foundry.forge` | CLAP IDs use the form `io.narl.bass-foundry.`. Builds tagged before this scheme used `io.storyboard.*` IDs; hosts treat the new IDs as different diff --git a/docs/forge/CHANGELOG.md b/docs/forge/CHANGELOG.md new file mode 100644 index 0000000..67ff16d --- /dev/null +++ b/docs/forge/CHANGELOG.md @@ -0,0 +1,13 @@ +# Forge changelog + +## Unreleased (0.1.0) + +- Introduce Forge, one tracked channel strip: Lathe, Temper and Knurl behind a + single note tracker, in any of the six orders, each module on or off. +- Every module follows the note read from the strip's input, so a module after + Knurl no longer hears Knurl's sub-octave. +- One latency of about 72 ms, the same in every order, instead of more than + 200 ms for the three plugins in a row. +- A single module on its own gives the same output, sample for sample, as its + standalone plugin. +- Editor: the chain, and each module's standalone editor as its page. diff --git a/docs/forge/README.md b/docs/forge/README.md new file mode 100644 index 0000000..9b95f3f --- /dev/null +++ b/docs/forge/README.md @@ -0,0 +1,63 @@ +# Forge + +Forge is one tracked channel strip: Lathe, Temper and Knurl run behind a single +note tracker, in the order you choose. Current version **0.1.0** (unreleased). + +Each of the three plugins detects the played note itself. In a row, their +lookaheads add up (Lathe 67 ms, Temper 68 ms, Knurl 71 ms: more than 200 ms), +and a tracker after Knurl hears Knurl's sub-octave and follows a note an octave +low. Forge reads the note once, from its input, and every module follows that +one tracker. In a test with Knurl's sub-octave pattern in front of Lathe, a +standalone Lathe after Knurl followed the note an octave low in every frame; +Lathe inside Forge followed the played note in every frame. + +![Forge](assets/editor.png) + +## Install on Windows + +Copy `Forge.clap` into `C:\Program Files\Common Files\CLAP\`. In FL Studio +2024.1 or newer, open Options → Manage plugins, enable Verify plugins, and Find +installed plugins. Load Forge in the mixer slot of the bass, right after the +synth. Keep the font license with redistributed packages. + +## Work with it + +1. Choose **Pitch from** in the header: **AUDIO** detects the note from the + input; **MIDI** follows MIDI notes sent to the effect. All modules use it. +2. The **Chain** row shows the modules in processing order. Click a module's + name to edit it below; **ON** switches it on or off. The button between two + modules swaps them. The default order is Lathe, Temper, Knurl, as in the + standalone chain. +3. Each module's page is its standalone editor: [Lathe](../lathe/README.md), + [Temper](../temper/README.md) and [Knurl](../knurl/README.md) explain the + controls. Temper's **AUTO GAIN** sits in the Chain row while its page is + open. +4. The **Gate** knob on every page is the one shared tracker gate: turning it on + one page turns it on all. + +**Bypass** in the header crossfades the whole strip to the delayed input. + +## How it works + +The tracker reads the strip's input, and the audio is delayed by its lookahead +once. Every module gets the note events delayed by the latency of the modules +in front of it, so each module sees a note start exactly on the attack of the +audio it receives. A single module on its own in Forge gives the same output, +sample for sample, as its standalone plugin, in every position of the chain. + +Temper's **Normalize** measures each note's level one lookahead ahead. In Forge +it measures the strip's input, not the output of the modules in front of it. +Lathe and Knurl change the level about equally on every note, so the notes +still reach the shaper at one level. + +## Timing and limits + +Latency is the tracker's lookahead (about 67 ms), Temper's oversampling filters +(under 1 ms) and Knurl's room for timing jitter (about 4 ms): about 72 ms in +all, reported to the host. A module that is off still delays its audio by its +own latency, so the latency stays the same in every order and with any module +off. + +Changing the order while audio plays switches the routing at once and can +click. The standalone plugins stay: use them when you need only one module, or +when another plugin must sit between two of them. diff --git a/docs/forge/assets/editor.png b/docs/forge/assets/editor.png new file mode 100644 index 0000000..1885888 Binary files /dev/null and b/docs/forge/assets/editor.png differ diff --git a/docs/ideas.md b/docs/ideas.md index 29b7a2f..a829feb 100644 --- a/docs/ideas.md +++ b/docs/ideas.md @@ -270,7 +270,7 @@ one period of the note, so heavy settings do not ripple at f0. See [Planish](pla (prototype `scripts/fatness.py`); Anvil Ghost harmonics and Phone listen (done, Anvil 0.3.0); Braze (done, 0.1.0); Anvil Kick lock with offset audition (done, Anvil 0.3.0). -4. Forge, when enough modules exist. +4. Forge (done, unreleased 0.1.0): Lathe, Temper and Knurl behind one tracker. 5. Assay, one plugin for the display-only ideas. 6. Texture plugins (Anneal, Swarf, Etch, Bellows) and the note-keyed sequencer. @@ -291,6 +291,31 @@ before Knurl) and the repeated MIDI routing. The standalone plugins stay. Sharing one tracker between separate `.clap` files would need named shared memory across DLLs, which is fragile; one strip is simpler. +Built (unreleased 0.1.0, see [Forge](forge/README.md)). Lathe, Temper and Knurl +became modules (a `Tracked` trait in common-dsp: `ahead`, `event`, `process`); +each standalone plugin is now its tracker plus its module, Lathe and Temper +bit-exact against the old engines, Knurl one sample later (its interpolation +needs one newer sample) and equal within float rounding. In the strip one +tracker reads the input; a per-sample record of the tracker's events, note state +and input is replayed to each module, delayed by the latency of the modules in +front of it. Findings: + +- One module alone in Forge matches its standalone plugin sample for sample, in + all six orders (tested). +- Knurl's Double-style pattern (0, −12 dB) in front of Lathe: standalone Lathe + after Knurl read the note an octave low in 149 of 149 frames on an A2 saw; + Lathe inside Forge read A2 in 149 of 149. +- Latency 72 ms against 206 ms for the three in a row (48 kHz). +- Temper's Normalize looks one lookahead ahead; in the strip it reads the strip + input, not the modules in front of it. Fine while those change every note's + level alike. + +Next for Forge: the *Tension* macro over Knurl (and later Anneal) at matched +loudness; Planish and Braze as modules (both are tracked, and Braze after +Knurl is the next tracker that hears the sub-octave); a short crossfade when +the order changes; one shared modulation source (per-note envelope or LFO in +cycles) that every module can read. + ### Braze — tempo-locked beating (problem 20) Brazing joins two metals with a filler. Braze adds a detuned copy of the bass diff --git a/plugins/catalog.json b/plugins/catalog.json index e509775..7b0b914 100644 --- a/plugins/catalog.json +++ b/plugins/catalog.json @@ -199,5 +199,28 @@ "ballast-core", "ballast-ui" ] + }, + "forge": { + "name": "Forge", + "description": "One tracked channel strip: Lathe, Temper and Knurl behind one note tracker, in any order", + "manifest": "plugins/forge/plugin/Cargo.toml", + "library": "forge", + "documentation": "docs/forge", + "clap_id": "io.narl.bass-foundry.forge", + "licenses": { + "plugins/common/ui/assets/OFL.txt": "licenses/Roboto-OFL.txt" + }, + "packages": [ + "common-ui", + "common-dsp", + "forge-core", + "forge-ui", + "lathe-core", + "lathe-ui", + "temper-core", + "temper-ui", + "knurl-core", + "knurl-ui" + ] } } diff --git a/plugins/forge/core/Cargo.toml b/plugins/forge/core/Cargo.toml new file mode 100644 index 0000000..cb33a35 --- /dev/null +++ b/plugins/forge/core/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "forge-core" +version = "0.1.0" +edition.workspace = true +license.workspace = true + +[dependencies] +common-dsp = { path = "../../common/dsp" } +lathe-core = { path = "../../lathe/core" } +temper-core = { path = "../../temper/core" } +knurl-core = { path = "../../knurl/core" } +serde = { workspace = true } + +[dev-dependencies] +serde_json = { workspace = true } diff --git a/plugins/forge/core/src/lib.rs b/plugins/forge/core/src/lib.rs new file mode 100644 index 0000000..bee8bc3 --- /dev/null +++ b/plugins/forge/core/src/lib.rs @@ -0,0 +1,271 @@ +//! Forge: one tracked channel strip. One note tracker reads the strip's input, and Lathe, +//! Temper and Knurl run behind it as modules in a chosen order. +//! +//! The audio path is delayed by the tracker's lookahead once. Every module gets the note events +//! delayed by the latency of the modules in front of it, so each module sees a note start on +//! that note's attack in the audio it receives. A module that is switched off still delays +//! its audio by its own latency, so the strip's latency never changes. Allocation-free after +//! `new`. +mod settings; +use common_dsp::tracker::{NoteEvent, Tracked, Tracker, TrackerConfig}; +use common_dsp::{coefficient, hz_to_midi}; +pub use settings::{Settings, Source, Stage, ORDERS, STAGES}; + +/// Note events kept per sample. More arrive only on floods; the oldest are dropped. +const EVENTS: usize = 4; + +#[derive(Clone, Copy, Debug)] +pub struct AnalyzerFrame { + pub lathe: lathe_core::AnalyzerFrame, + pub temper: temper_core::AnalyzerFrame, + pub knurl: knurl_core::AnalyzerFrame, + /// Pitch at the strip's output, 0 before the first note. + pub hz: f32, + pub note: Option, + pub latency: u32, + pub sample_rate: f32, +} +impl Default for AnalyzerFrame { + fn default() -> Self { + Self { + lathe: lathe_core::AnalyzerFrame::default(), + temper: temper_core::AnalyzerFrame::default(), + knurl: knurl_core::AnalyzerFrame::default(), + hz: 0., + note: None, + latency: 0, + sample_rate: 48000., + } + } +} + +/// What the tracker reported for one sample, kept so later modules can replay it. +#[derive(Clone, Copy)] +struct Slot { + events: [NoteEvent; EVENTS], + len: usize, + sounding: bool, + /// The undelayed input, one lookahead ahead of the audio this slot belongs to. + ahead: f32, +} +impl Default for Slot { + fn default() -> Self { + Self { + events: [NoteEvent::Stop; EVENTS], + len: 0, + sounding: false, + ahead: 0., + } + } +} +impl Slot { + fn push(&mut self, e: NoteEvent) { + if self.len == EVENTS { + self.events.copy_within(1.., 0); + self.len -= 1; + } + self.events[self.len] = e; + self.len += 1; + } +} + +pub struct Engine { + rate: f32, + channels: usize, + settings: Settings, + tracker: Tracker, + delay: Vec<[f32; 2]>, + delay_at: usize, + lathe: lathe_core::Module, + temper: temper_core::Module, + knurl: knurl_core::Module, + /// Tracker reports of the last samples, newest at `line_at`. + line: Vec, + line_at: usize, + /// How far back in `line` each position of the order reads. + offsets: [usize; STAGES], + /// The aligned input, delayed by every module's latency, for the strip's bypass. + dry: Vec<[f32; 2]>, + dry_at: usize, + /// Pitch at the output, for the editor. + pitch: common_dsp::tracker::PitchFollower, + sounding: bool, + smooth: f32, + bypass: f32, + fresh: bool, +} + +impl Engine { + pub fn new(rate: f32, channels: usize) -> Result { + let lathe = lathe_core::Module::new(rate, channels)?; + let temper = temper_core::Module::new(rate, channels)?; + let knurl = knurl_core::Module::new(rate, channels)?; + let tracker = Tracker::new(rate, TrackerConfig::BASS); + let modules = lathe.latency() + temper.latency() + knurl.latency(); + let lookahead = tracker.latency(); + let mut e = Self { + rate, + channels, + settings: Settings::default(), + tracker, + delay: vec![[0.; 2]; lookahead + 1], + delay_at: 0, + lathe, + temper, + knurl, + line: vec![Slot::default(); modules + 1], + line_at: 0, + offsets: [0; STAGES], + dry: vec![[0.; 2]; modules + 1], + dry_at: 0, + pitch: Default::default(), + sounding: false, + smooth: coefficient(rate, 10.), + bypass: 0., + fresh: true, + }; + // The modules already hold their defaults; only the routing still needs them. + e.route(&Settings::default()); + Ok(e) + } + /// The tracker's lookahead plus every module's latency, in any order. + pub fn latency_samples(&self) -> u32 { + (self.tracker.latency() + self.dry.len() - 1) as u32 + } + pub fn channels(&self) -> usize { + self.channels + } + pub fn settings(&self) -> Settings { + self.settings + } + pub fn set_settings(&mut self, s: Settings) -> Result<(), &'static str> { + s.validate()?; + let mut s = s; + s.share(); + self.lathe.set_settings(s.lathe)?; + self.temper.set_settings(s.temper)?; + self.knurl.set_settings(s.knurl)?; + self.route(&s); + self.settings = s; + if std::mem::take(&mut self.fresh) { + self.bypass = f32::from(s.bypass); + } + Ok(()) + } + /// Tracker settings and how far back each position reads the note events. + fn route(&mut self, s: &Settings) { + // Each module decides itself whether a legato note slides. + self.tracker.set(s.source == Source::Midi, s.gate, true); + let mut at = 0; + for (i, stage) in s.order.into_iter().enumerate() { + self.offsets[i] = at; + at += self.module(stage).latency(); + } + } + pub fn reset(&mut self) { + self.tracker.reset(); + self.delay.fill([0.; 2]); + self.line.fill(Slot::default()); + self.dry.fill([0.; 2]); + self.lathe.reset(); + self.temper.reset(); + self.knurl.reset(); + self.pitch = Default::default(); + self.sounding = false; + self.fresh = true; + } + pub fn note_on(&mut self, note: u8) { + self.tracker.note_on(note); + } + pub fn note_off(&mut self, note: u8) { + self.tracker.note_off(note); + } + fn module(&mut self, stage: Stage) -> &mut dyn Tracked { + match stage { + Stage::Lathe => &mut self.lathe, + Stage::Temper => &mut self.temper, + Stage::Knurl => &mut self.knurl, + } + } + pub fn process_sample(&mut self, x: [f32; 2]) -> [f32; 2] { + let mono = if self.channels == 2 { + 0.5 * (x[0] + x[1]) + } else { + x[0] + }; + let mut slot = Slot { + ahead: mono, + ..Slot::default() + }; + self.tracker.process(mono, |e| slot.push(e)); + slot.sounding = self.tracker.sounding(); + let len = self.line.len(); + self.line_at = (self.line_at + 1) % len; + self.line[self.line_at] = slot; + + let len = self.delay.len(); + self.delay[self.delay_at] = x; + self.delay_at = (self.delay_at + 1) % len; + let y = self.delay[self.delay_at]; + + let mut v = y; + let len = self.line.len(); + for i in 0..STAGES { + let slot = self.line[(self.line_at + len - self.offsets[i]) % len]; + let m: &mut dyn Tracked = match self.settings.order[i] { + Stage::Lathe => &mut self.lathe, + Stage::Temper => &mut self.temper, + Stage::Knurl => &mut self.knurl, + }; + m.ahead(slot.ahead); + for &e in &slot.events[..slot.len] { + m.event(e); + } + v = m.process(v, slot.sounding); + } + + // The pitch at the output: the oldest slot is the last module's input time minus its + // latency, which is the output time. + let last = self.line[(self.line_at + 1) % self.line.len()]; + for &e in &last.events[..last.len] { + self.pitch.event(false, e); + } + self.pitch.step(1.); + self.sounding = last.sounding; + + let len = self.dry.len(); + self.dry_at = (self.dry_at + 1) % len; + self.dry[self.dry_at] = y; + let dry = self.dry[(self.dry_at + 1) % len]; + let s = &self.settings; + self.bypass += (f32::from(s.bypass) - self.bypass) * self.smooth; + let mut out = [0.; 2]; + for c in 0..self.channels { + out[c] = v[c] * (1. - self.bypass) + dry[c] * self.bypass; + } + out + } + /// Editor data of every module, with the strip's latency. + pub fn take_analyzer(&mut self) -> AnalyzerFrame { + let latency = self.latency_samples(); + let hz = self.pitch.hz(); + AnalyzerFrame { + lathe: lathe_core::AnalyzerFrame { + latency, + ..self.lathe.take_analyzer() + }, + temper: temper_core::AnalyzerFrame { + latency, + ..self.temper.take_analyzer() + }, + knurl: knurl_core::AnalyzerFrame { + latency, + ..self.knurl.take_analyzer() + }, + hz, + note: (self.sounding && hz > 0.).then(|| hz_to_midi(hz).round().clamp(0., 127.) as u8), + latency, + sample_rate: self.rate, + } + } +} diff --git a/plugins/forge/core/src/settings.rs b/plugins/forge/core/src/settings.rs new file mode 100644 index 0000000..b296a90 --- /dev/null +++ b/plugins/forge/core/src/settings.rs @@ -0,0 +1,119 @@ +//! Host-independent controls of the strip and its modules. +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)] +pub enum Source { + /// Pitch and note starts are detected from the incoming bass. + #[default] + Audio, + /// Notes come from MIDI note input. + Midi, +} + +/// One module of the strip. +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] +pub enum Stage { + Lathe, + Temper, + Knurl, +} +impl Stage { + pub const ALL: [Stage; 3] = [Stage::Lathe, Stage::Temper, Stage::Knurl]; + pub fn name(self) -> &'static str { + match self { + Stage::Lathe => "Lathe", + Stage::Temper => "Temper", + Stage::Knurl => "Knurl", + } + } +} +pub const STAGES: usize = Stage::ALL.len(); + +/// Every order of the three modules. The first is the default: harmonic EQ, then distortion, +/// then the cycle texture, as in the standalone chain. +pub const ORDERS: [[Stage; STAGES]; 6] = [ + [Stage::Lathe, Stage::Temper, Stage::Knurl], + [Stage::Temper, Stage::Lathe, Stage::Knurl], + [Stage::Lathe, Stage::Knurl, Stage::Temper], + [Stage::Temper, Stage::Knurl, Stage::Lathe], + [Stage::Knurl, Stage::Lathe, Stage::Temper], + [Stage::Knurl, Stage::Temper, Stage::Lathe], +]; + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)] +#[serde(deny_unknown_fields)] +pub struct Settings { + /// Pitch source of the one tracker every module follows. + pub source: Source, + /// Detection threshold in dBFS for note starts (Audio source). + pub gate: f32, + /// Modules in processing order. + pub order: [Stage; STAGES], + /// Module settings. Their `source` and `gate` are replaced by the strip's, and their + /// `bypass` switches the module off. + pub lathe: lathe_core::Settings, + pub temper: temper_core::Settings, + pub knurl: knurl_core::Settings, + pub bypass: bool, +} +impl Default for Settings { + fn default() -> Self { + Self { + source: Source::Audio, + gate: lathe_core::Settings::default().gate, + order: ORDERS[0], + lathe: lathe_core::Settings::default(), + temper: temper_core::Settings::default(), + knurl: knurl_core::Settings::default(), + bypass: false, + } + } +} +impl Settings { + pub fn validate(&self) -> Result<(), &'static str> { + let ok = (-60.0..=-20.).contains(&self.gate) && ORDERS.contains(&self.order); + if !ok { + return Err("invalid settings"); + } + self.lathe.validate()?; + self.temper.validate()?; + self.knurl.validate() + } + /// True when the module is switched on. + pub fn on(&self, stage: Stage) -> bool { + !match stage { + Stage::Lathe => self.lathe.bypass, + Stage::Temper => self.temper.bypass, + Stage::Knurl => self.knurl.bypass, + } + } + pub fn set_on(&mut self, stage: Stage, on: bool) { + match stage { + Stage::Lathe => self.lathe.bypass = !on, + Stage::Temper => self.temper.bypass = !on, + Stage::Knurl => self.knurl.bypass = !on, + } + } + /// Copies the strip's pitch source and gate into every module. + pub fn share(&mut self) { + let midi = self.source == Source::Midi; + self.lathe.gate = self.gate; + self.temper.gate = self.gate; + self.knurl.gate = self.gate; + self.lathe.source = if midi { + lathe_core::Source::Midi + } else { + lathe_core::Source::Audio + }; + self.temper.source = if midi { + temper_core::Source::Midi + } else { + temper_core::Source::Audio + }; + self.knurl.source = if midi { + knurl_core::Source::Midi + } else { + knurl_core::Source::Audio + }; + } +} diff --git a/plugins/forge/core/tests/dsp.rs b/plugins/forge/core/tests/dsp.rs new file mode 100644 index 0000000..3713ab9 --- /dev/null +++ b/plugins/forge/core/tests/dsp.rs @@ -0,0 +1,219 @@ +use forge_core::{Engine, Settings, Source, Stage, ORDERS}; + +const RATE: f32 = 48000.; + +/// A bassline of saw notes with gaps, a different pitch each, at A1 to A2. +fn bass(i: usize) -> [f32; 2] { + let note = [33., 40., 36., 45., 38.][(i / 14400) % 5]; + let hz = 440. * 2f64.powf((note - 69.) / 12.); + let t = i as f64 / RATE as f64; + let on = i % 14400 < 12000; + let v = if on { + (0.4 * (2. * (hz * t).fract() - 1.)) as f32 + } else { + 0. + }; + [v, 0.8 * v] +} + +/// Module settings that change the sound, so a mismatch would show. +fn shaped() -> Settings { + let mut s = Settings::default(); + s.lathe.gains[2] = -12.; + s.lathe.tilt = -3.; + s.temper.drive = 12.; + s.temper.bias = 20.; + s.temper.push_gain = 6.; + s.temper.bright = 8.; + s.knurl.apply_pattern(&[0., -9.]); + s.knurl.time_jitter = 6.; + s.knurl.level_jitter = 2.; + s.knurl.grit = -18.; + s +} + +fn only(stage: Stage, order: [Stage; 3]) -> Settings { + let mut s = shaped(); + s.order = order; + for st in Stage::ALL { + s.set_on(st, st == stage); + } + s +} + +/// One module on its own in the strip sounds exactly like its standalone plugin, in every +/// position: the strip's tracker and note timing are the plugin's. +#[test] +fn each_module_alone_matches_its_standalone_plugin() { + let n = 80000; + for order in ORDERS { + for stage in Stage::ALL { + let s = only(stage, order); + let mut forge = Engine::new(RATE, 2).unwrap(); + forge.set_settings(s).unwrap(); + let (alone, latency): (Vec<[f32; 2]>, u32) = match stage { + Stage::Lathe => { + let mut e = lathe_core::Engine::new(RATE, 2).unwrap(); + e.set_settings(s.lathe).unwrap(); + ( + (0..n).map(|i| e.process_sample(bass(i))).collect(), + e.latency_samples(), + ) + } + Stage::Temper => { + let mut e = temper_core::Engine::new(RATE, 2).unwrap(); + e.set_settings(s.temper).unwrap(); + ( + (0..n).map(|i| e.process_sample(bass(i))).collect(), + e.latency_samples(), + ) + } + Stage::Knurl => { + let mut e = knurl_core::Engine::new(RATE, 2).unwrap(); + e.set_settings(s.knurl).unwrap(); + ( + (0..n).map(|i| e.process_sample(bass(i))).collect(), + e.latency_samples(), + ) + } + }; + let strip: Vec<[f32; 2]> = (0..n).map(|i| forge.process_sample(bass(i))).collect(); + let shift = (forge.latency_samples() - latency) as usize; + for i in 0..n - shift { + assert_eq!( + strip[i + shift], + alone[i], + "{stage:?} in {order:?}, sample {i}" + ); + } + } + } +} + +#[test] +fn the_strip_has_one_lookahead() { + let forge = Engine::new(RATE, 2).unwrap(); + let lathe = lathe_core::Engine::new(RATE, 2).unwrap().latency_samples(); + let temper = temper_core::Engine::new(RATE, 2).unwrap().latency_samples(); + let knurl = knurl_core::Engine::new(RATE, 2).unwrap().latency_samples(); + // Lathe has no latency of its own: its latency is the lookahead. + let own = (temper - lathe) + (knurl - lathe); + assert_eq!(forge.latency_samples(), lathe + own); + let ms = |s: u32| s as f32 / RATE * 1000.; + assert!( + ms(forge.latency_samples()) < 75., + "{}", + ms(forge.latency_samples()) + ); + assert!(ms(lathe + temper + knurl) > 200.); + // Changing the order keeps the latency. + let mut f = Engine::new(RATE, 2).unwrap(); + let before = f.latency_samples(); + for order in ORDERS { + f.set_settings(Settings { + order, + ..Settings::default() + }) + .unwrap(); + assert_eq!(f.latency_samples(), before); + } +} + +/// Knurl's sub-octave pattern first, then Lathe: Lathe still follows the played note, because +/// the tracker reads the strip's input. A standalone Lathe after Knurl hears the sub-octave. +#[test] +fn modules_after_knurl_follow_the_played_note() { + let mut s = Settings { + order: [Stage::Knurl, Stage::Lathe, Stage::Temper], + ..Settings::default() + }; + s.knurl.apply_pattern(&[0., -12.]); + s.temper.bypass = true; + let mut forge = Engine::new(RATE, 2).unwrap(); + forge.set_settings(s).unwrap(); + let mut knurl = knurl_core::Engine::new(RATE, 2).unwrap(); + knurl.set_settings(s.knurl).unwrap(); + let mut lathe = lathe_core::Engine::new(RATE, 2).unwrap(); + lathe.set_settings(s.lathe).unwrap(); + // One long note at A2 (110 Hz). + let hz = 110.; + let note = |i: usize| { + let v = (0.4 * (2. * (hz * i as f64 / RATE as f64).fract() - 1.)) as f32; + [v, v] + }; + let (mut strip_ok, mut chain_ok, mut frames) = (0, 0, 0); + for i in 0..96000 { + forge.process_sample(note(i)); + lathe.process_sample(knurl.process_sample(note(i))); + if i > 24000 && i % 480 == 0 { + frames += 1; + let near = |f: f32| (f / hz as f32 - 1.).abs() < 0.02; + strip_ok += usize::from(near(forge.take_analyzer().lathe.hz)); + chain_ok += usize::from(near(lathe.take_analyzer().hz)); + } + } + assert_eq!(strip_ok, frames); + assert!(chain_ok < frames / 2, "{chain_ok} of {frames}"); +} + +#[test] +fn bypass_is_the_input_delayed_by_the_latency() { + let mut e = Engine::new(RATE, 2).unwrap(); + e.set_settings(Settings { + bypass: true, + ..shaped() + }) + .unwrap(); + let latency = e.latency_samples() as usize; + let out: Vec<[f32; 2]> = (0..30000).map(|i| e.process_sample(bass(i))).collect(); + for (i, o) in out.iter().enumerate().skip(latency) { + assert_eq!(*o, bass(i - latency)); + } +} + +#[test] +fn midi_notes_drive_every_module() { + let mut s = shaped(); + s.source = Source::Midi; + let mut e = Engine::new(RATE, 1).unwrap(); + e.set_settings(s).unwrap(); + for i in 0..24000 { + if i == 100 { + e.note_on(45); + } + e.process_sample(bass(i)); + } + let f = e.take_analyzer(); + assert_eq!(f.note, Some(45)); + assert_eq!(f.lathe.note, Some(45)); + assert_eq!(f.temper.note, Some(45)); + assert_eq!(f.knurl.note, Some(45)); + assert_eq!(f.lathe.latency, e.latency_samples()); +} + +#[test] +fn settings_are_validated_and_serialise() { + assert!(Settings::default().validate().is_ok()); + let bad = Settings { + order: [Stage::Lathe, Stage::Lathe, Stage::Knurl], + ..Settings::default() + }; + assert!(bad.validate().is_err()); + assert!(Engine::new(RATE, 2).unwrap().set_settings(bad).is_err()); + let bad = Settings { + gate: -10., + ..Settings::default() + }; + assert!(bad.validate().is_err()); + let mut bad = Settings::default(); + bad.temper.drive = f32::NAN; + assert!(bad.validate().is_err()); + let s = Settings { + order: ORDERS[4], + source: Source::Midi, + ..shaped() + }; + let json = serde_json::to_string(&s).unwrap(); + assert_eq!(serde_json::from_str::(&json).unwrap(), s); + assert!(serde_json::from_str::(r#"{"gate":-40,"oops":1}"#).is_err()); +} diff --git a/plugins/forge/core/tests/realtime.rs b/plugins/forge/core/tests/realtime.rs new file mode 100644 index 0000000..466211a --- /dev/null +++ b/plugins/forge/core/tests/realtime.rs @@ -0,0 +1,72 @@ +use forge_core::{Engine, Settings, Source, Stage, ORDERS}; +use std::{ + alloc::{GlobalAlloc, Layout, System}, + cell::Cell, +}; + +struct CheckedAllocator; +thread_local! { + static CHECK:Cell=const {Cell::new(false)}; + static OPERATIONS:Cell=const {Cell::new(0)}; +} +fn record() { + if CHECK.try_with(Cell::get).unwrap_or(false) { + let _ = OPERATIONS.try_with(|n| n.set(n.get() + 1)); + } +} +unsafe impl GlobalAlloc for CheckedAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + record(); + unsafe { System.alloc(layout) } + } + unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) { + record(); + unsafe { System.dealloc(pointer, layout) } + } + unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, size: usize) -> *mut u8 { + record(); + unsafe { System.realloc(pointer, layout, size) } + } +} +#[global_allocator] +static ALLOCATOR: CheckedAllocator = CheckedAllocator; + +#[test] +fn processing_notes_settings_and_analysis_do_not_allocate_or_free() { + let mut engine = Engine::new(48000., 2).unwrap(); + let mut settings = Settings::default(); + settings.knurl.grit = -12.; + engine.set_settings(settings).unwrap(); + CHECK.with(|v| v.set(true)); + for i in 0..96000 { + if i % 4800 == 0 { + let step = i / 4800; + settings.order = ORDERS[step % ORDERS.len()]; + settings.source = if step % 4 < 2 { + Source::Audio + } else { + Source::Midi + }; + settings.set_on(Stage::ALL[step % 3], step % 2 == 0); + settings.temper.drive = (step % 5) as f32 * 6.; + engine.set_settings(settings).unwrap(); + engine.note_on(33 + (step % 12) as u8); + } + if i % 4800 == 2400 { + engine.note_off(33 + (i / 4800 % 12) as u8); + } + let t = i as f32 / 48000.; + let x = if (i / 2400) % 2 == 0 { + (std::f32::consts::TAU * 55. * t).sin() * 0.5 + } else { + 0. + }; + std::hint::black_box(engine.process_sample([x, -x])); + if i % 1600 == 0 { + std::hint::black_box(engine.take_analyzer()); + } + } + engine.reset(); + CHECK.with(|v| v.set(false)); + assert_eq!(OPERATIONS.with(Cell::get), 0); +} diff --git a/plugins/forge/plugin/Cargo.lock b/plugins/forge/plugin/Cargo.lock new file mode 100644 index 0000000..6c28d9e --- /dev/null +++ b/plugins/forge/plugin/Cargo.lock @@ -0,0 +1,2448 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ab_glyph" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2" +dependencies = [ + "ab_glyph_rasterizer", + "owned_ttf_parser", +] + +[[package]] +name = "ab_glyph_rasterizer" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618" + +[[package]] +name = "addr2line" +version = "0.27.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e567177890eb1617b1f774005b66b26b2377afd138a2ca37aae7d8f0c81429d4" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "android-activity" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f2a1bb052857d5dd49572219344a7332b31b76405648eabac5bc68978251bcd" +dependencies = [ + "android-properties", + "bitflags 2.13.2", + "cc", + "jni", + "libc", + "log", + "ndk", + "ndk-context", + "ndk-sys", + "num_enum", + "thiserror 2.0.21", +] + +[[package]] +name = "android-properties" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04" + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "anymap3" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5dfbc6d8d2675589ccbe4d0fd61df2419075625f8c1a62325e718e2b0049f9" + +[[package]] +name = "as-raw-xcb-connection" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b" + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "atomic_float" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62af46d040ba9df09edc6528dae9d8e49f5f3e82f55b7d2ec31a733c38dbc49d" + +[[package]] +name = "atomic_refcell" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21e4227379beff4205943696e6c3e0cd809bacdf3f0edd6e3dd153e2269571a4" + +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi 0.1.19", + "libc", + "winapi", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "backtrace" +version = "0.3.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f4220217f3288537b83684130f42fad43320b1c3b805f1910d683d52ded24f" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "baseview" +version = "0.1.0" +source = "git+https://github.com/RustAudio/baseview.git?rev=9a0b42c09d712777b2edb4c5e0cb6baf21e988f0#9a0b42c09d712777b2edb4c5e0cb6baf21e988f0" +dependencies = [ + "cocoa", + "core-foundation", + "keyboard-types", + "nix", + "objc", + "raw-window-handle 0.5.2", + "uuid", + "winapi", + "x11", + "x11rb", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + +[[package]] +name = "block2" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" +dependencies = [ + "objc2", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "calloop" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec" +dependencies = [ + "bitflags 2.13.2", + "log", + "polling", + "rustix 0.38.44", + "slab", + "thiserror 1.0.69", +] + +[[package]] +name = "cc" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "375989decec1a0fa424442bed520fa12ede43a48475ce8c7417d2c69b32b5f6b" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "clap-sys" +version = "0.5.0" +source = "git+https://github.com/micahrj/clap-sys.git?rev=25d7f53fdb6363ad63fbd80049cb7a42a97ac156#25d7f53fdb6363ad63fbd80049cb7a42a97ac156" + +[[package]] +name = "clipboard-win" +version = "5.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "052af7878466feccda12ba7a6a67d019d712f296809559b47c12c8cc196d3a9a" +dependencies = [ + "error-code", +] + +[[package]] +name = "cocoa" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f425db7937052c684daec3bd6375c8abe2d146dca4b8b143d6db777c39138f3a" +dependencies = [ + "bitflags 1.3.2", + "block", + "cocoa-foundation", + "core-foundation", + "core-graphics 0.22.3", + "foreign-types 0.3.2", + "libc", + "objc", +] + +[[package]] +name = "cocoa-foundation" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c6234cbb2e4c785b456c0644748b1ac416dd045799740356f8363dfe00c93f7" +dependencies = [ + "bitflags 1.3.2", + "block", + "core-foundation", + "core-graphics-types", + "libc", + "objc", +] + +[[package]] +name = "combine" +version = "4.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92" +dependencies = [ + "bytes", + "memchr", +] + +[[package]] +name = "common-dsp" +version = "0.1.0" + +[[package]] +name = "common-ui" +version = "0.1.0" +dependencies = [ + "egui", +] + +[[package]] +name = "concurrent-queue" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "copypasta" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e6811e17f81fe246ef2bc553f76b6ee6ab41a694845df1d37e52a92b7bbd38a" +dependencies = [ + "clipboard-win", + "objc2", + "objc2-app-kit", + "objc2-foundation", + "x11-clipboard", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "core-graphics" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types 0.3.2", + "libc", +] + +[[package]] +name = "core-graphics" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types 0.5.0", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + +[[package]] +name = "crossbeam" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e71406cd8807725f7ac2f999a4cdd32e98f829fdf65f528343cebf945e41df1e" +dependencies = [ + "crossbeam-channel", + "crossbeam-deque", + "crossbeam-epoch", + "crossbeam-queue", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-queue" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e8bd762f7479489c70ed6c768ddca99d7296857de437a68dcb2a94365b3fae" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6" + +[[package]] +name = "cursor-icon" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" + +[[package]] +name = "deranged" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e" + +[[package]] +name = "dispatch" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b" + +[[package]] +name = "dlib" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a" +dependencies = [ + "libloading", +] + +[[package]] +name = "dpi" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" + +[[package]] +name = "ecolor" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc4feb366740ded31a004a0e4452fbf84e80ef432ecf8314c485210229672fd1" +dependencies = [ + "bytemuck", + "emath", +] + +[[package]] +name = "egui" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25dd34cec49ab55d85ebf70139cb1ccd29c977ef6b6ba4fe85489d6877ee9ef3" +dependencies = [ + "ahash", + "bitflags 2.13.2", + "emath", + "epaint", + "nohash-hasher", + "profiling", +] + +[[package]] +name = "egui-baseview" +version = "0.5.0" +source = "git+https://github.com/BillyDM/egui-baseview.git?rev=ec70c3fe6b2f070dcacbc22924431edbe24bd1c0#ec70c3fe6b2f070dcacbc22924431edbe24bd1c0" +dependencies = [ + "baseview", + "copypasta", + "egui", + "egui_glow", + "keyboard-types", + "log", + "open", + "raw-window-handle 0.5.2", + "thiserror 2.0.21", +] + +[[package]] +name = "egui_glow" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "910906e3f042ea6d2378ec12a6fd07698e14ddae68aed2d819ffe944a73aab9e" +dependencies = [ + "ahash", + "bytemuck", + "egui", + "glow", + "log", + "memoffset 0.9.1", + "profiling", + "wasm-bindgen", + "web-sys", + "winit", +] + +[[package]] +name = "emath" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e4cadcff7a5353ba72b7fea76bf2122b5ebdbc68e8155aa56dfdea90083fe1b" +dependencies = [ + "bytemuck", +] + +[[package]] +name = "epaint" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41fcc0f5a7c613afd2dee5e4b30c3e6acafb8ad6f0edb06068811f708a67c562" +dependencies = [ + "ab_glyph", + "ahash", + "bytemuck", + "ecolor", + "emath", + "epaint_default_fonts", + "nohash-hasher", + "parking_lot", + "profiling", +] + +[[package]] +name = "epaint_default_fonts" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7e7a64c02cf7a5b51e745a9e45f60660a286f151c238b9d397b3e923f5082f" + +[[package]] +name = "equivalent" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "error-code" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7" + +[[package]] +name = "find-msvc-tools" +version = "0.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared 0.1.1", +] + +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared 0.3.1", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + +[[package]] +name = "forge" +version = "0.1.0" +dependencies = [ + "clap-sys", + "crossbeam-queue", + "forge-core", + "forge-ui", + "knurl-core", + "lathe-core", + "nih_plug", + "nih_plug_egui", + "serde", + "serde_json", + "temper-core", +] + +[[package]] +name = "forge-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "knurl-core", + "lathe-core", + "serde", + "temper-core", +] + +[[package]] +name = "forge-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "forge-core", + "knurl-core", + "knurl-ui", + "lathe-core", + "lathe-ui", + "temper-core", + "temper-ui", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "gethostname" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8" +dependencies = [ + "rustix 1.1.6", + "windows-link", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi", +] + +[[package]] +name = "gimli" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1033caf0b349c518623b5396bfb2cf0bddf44f0306d543a250e5743297aafd10" + +[[package]] +name = "glow" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5e5ea60d70410161c8bf5da3fdfeaa1c72ed2c15f8bbb9d19fe3a4fad085f08" +dependencies = [ + "js-sys", + "slotmap", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "hermit-abi" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284" + +[[package]] +name = "indexmap" +version = "2.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "is-docker" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3" +dependencies = [ + "once_cell", +] + +[[package]] +name = "is-wsl" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5" +dependencies = [ + "is-docker", + "once_cell", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jni" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" +dependencies = [ + "cfg-if", + "combine", + "jni-macros", + "jni-sys 0.4.1", + "log", + "simd_cesu8", + "thiserror 2.0.21", + "walkdir", + "windows-link", +] + +[[package]] +name = "jni-macros" +version = "0.22.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" +dependencies = [ + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn 2.0.119", +] + +[[package]] +name = "jni-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +dependencies = [ + "jni-sys 0.4.1", +] + +[[package]] +name = "jni-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2" +dependencies = [ + "jni-sys-macros", +] + +[[package]] +name = "jni-sys-macros" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" +dependencies = [ + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dc09d2154098bbf4ef54eab6b117a3c24cbbffe94046b16ee6d6d4510584d3a" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "keyboard-types" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7668b7cff6a51fe61cdde64cd27c8a220786f399501b57ebe36f7d8112fd68" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "knurl-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "serde", +] + +[[package]] +name = "knurl-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "knurl-core", +] + +[[package]] +name = "lathe-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "serde", +] + +[[package]] +name = "lathe-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "lathe-core", +] + +[[package]] +name = "libc" +version = "0.2.191" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libredox" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d" +dependencies = [ + "bitflags 2.13.2", + "libc", + "plain", + "redox_syscall 0.9.5", +] + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c" + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "midi-consts" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f2dd5c7f8aaf48a76e389068ab25ed80bdbc226b887f9013844c415698c9952" + +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", +] + +[[package]] +name = "ndk" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4" +dependencies = [ + "bitflags 2.13.2", + "jni-sys 0.3.1", + "log", + "ndk-sys", + "num_enum", + "raw-window-handle 0.6.2", + "thiserror 1.0.69", +] + +[[package]] +name = "ndk-context" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b" + +[[package]] +name = "ndk-sys" +version = "0.6.0+11769913" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873" +dependencies = [ + "jni-sys 0.3.1", +] + +[[package]] +name = "nih_log" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0cdb52ef79af48ae110401c883bdb9c15e0306a99ab6ecf18bc52068b668e54" +dependencies = [ + "atty", + "log", + "once_cell", + "termcolor", + "time", + "windows", +] + +[[package]] +name = "nih_plug" +version = "0.0.0" +source = "git+https://github.com/robbert-vdh/nih-plug.git?rev=de421011f41a6d10fc8c7a6084e4f4dee0143683#de421011f41a6d10fc8c7a6084e4f4dee0143683" +dependencies = [ + "anyhow", + "anymap3", + "atomic_float", + "atomic_refcell", + "backtrace", + "bitflags 1.3.2", + "cfg-if", + "clap-sys", + "core-foundation", + "crossbeam", + "libc", + "log", + "midi-consts", + "nih_log", + "nih_plug_derive", + "objc", + "parking_lot", + "raw-window-handle 0.5.2", + "serde", + "serde_json", + "widestring", + "windows", +] + +[[package]] +name = "nih_plug_derive" +version = "0.1.0" +source = "git+https://github.com/robbert-vdh/nih-plug.git?rev=de421011f41a6d10fc8c7a6084e4f4dee0143683#de421011f41a6d10fc8c7a6084e4f4dee0143683" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "nih_plug_egui" +version = "0.0.0" +source = "git+https://github.com/robbert-vdh/nih-plug.git?rev=de421011f41a6d10fc8c7a6084e4f4dee0143683#de421011f41a6d10fc8c7a6084e4f4dee0143683" +dependencies = [ + "baseview", + "crossbeam", + "egui-baseview", + "nih_plug", + "parking_lot", + "raw-window-handle 0.5.2", + "serde", +] + +[[package]] +name = "nix" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4916f159ed8e5de0082076562152a76b7a1f64a01fd9d1e0fea002c37624faf" +dependencies = [ + "bitflags 1.3.2", + "cc", + "cfg-if", + "libc", + "memoffset 0.6.5", +] + +[[package]] +name = "nohash-hasher" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451" + +[[package]] +name = "num-conv" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441" + +[[package]] +name = "num_enum" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "num_threads" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cabcc654086861f9e1bc5115258de62ef92c79b20f4615a1b0cc57c4e82027d4" +dependencies = [ + "libc", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "objc-sys" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" + +[[package]] +name = "objc2" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d5490aaf8f1d7cf7688dfa9b0ce07900e168852c45cd2c03f534dfd27cfd0b" +dependencies = [ + "objc-sys", + "objc2-encode", +] + +[[package]] +name = "objc2-app-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff" +dependencies = [ + "bitflags 2.13.2", + "block2", + "libc", + "objc2", + "objc2-core-data", + "objc2-core-image", + "objc2-foundation", + "objc2-quartz-core", +] + +[[package]] +name = "objc2-cloud-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-core-location", + "objc2-foundation", +] + +[[package]] +name = "objc2-contacts" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889" +dependencies = [ + "block2", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-data" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-core-image" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80" +dependencies = [ + "block2", + "objc2", + "objc2-foundation", + "objc2-metal", +] + +[[package]] +name = "objc2-core-location" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781" +dependencies = [ + "block2", + "objc2", + "objc2-contacts", + "objc2-foundation", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" +dependencies = [ + "bitflags 2.13.2", + "block2", + "dispatch", + "libc", + "objc2", +] + +[[package]] +name = "objc2-link-presentation" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398" +dependencies = [ + "block2", + "objc2", + "objc2-app-kit", + "objc2-foundation", +] + +[[package]] +name = "objc2-metal" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-foundation", + "objc2-metal", +] + +[[package]] +name = "objc2-symbols" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc" +dependencies = [ + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-cloud-kit", + "objc2-core-data", + "objc2-core-image", + "objc2-core-location", + "objc2-foundation", + "objc2-link-presentation", + "objc2-quartz-core", + "objc2-symbols", + "objc2-uniform-type-identifiers", + "objc2-user-notifications", +] + +[[package]] +name = "objc2-uniform-type-identifiers" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe" +dependencies = [ + "block2", + "objc2", + "objc2-foundation", +] + +[[package]] +name = "objc2-user-notifications" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3" +dependencies = [ + "bitflags 2.13.2", + "block2", + "objc2", + "objc2-core-location", + "objc2-foundation", +] + +[[package]] +name = "object" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd229a0361b9d0d4396176e02d65897f487eebeab7caa6d443855ee152ca0b9c" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "open" +version = "5.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d8c8b8e725ad26404d6896eb2f064294a0a7b4f1d9120210d85544684c4ca95" +dependencies = [ + "is-wsl", + "libc", +] + +[[package]] +name = "orbclient" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5df339f526ea9a60e371768d50efc2f2508c7203290731565d1f7a6f71d21747" +dependencies = [ + "libc", + "libredox", +] + +[[package]] +name = "owned_ttf_parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" +dependencies = [ + "ttf-parser", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "plain" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" + +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi 0.5.3", + "pin-project-lite", + "rustix 1.1.6", + "windows-sys 0.61.2", +] + +[[package]] +name = "powerfmt" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958" + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "raw-window-handle" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9" + +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "redox_syscall" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "580c875845b41ecb1564ad1ae4703044cef774145e3d7a94dc2b3fa7c97868fd" +dependencies = [ + "bitflags 2.13.2", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.4.15", + "windows-sys 0.59.0", +] + +[[package]] +name = "rustix" +version = "1.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5e76742e5294153d4dde1207dbec5bdd81eef6fabdc0d2118babadabfd858aa" +dependencies = [ + "bitflags 2.13.2", + "errno", + "libc", + "linux-raw-sys 0.12.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "simd_cesu8" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "slotmap" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038" +dependencies = [ + "version_check", +] + +[[package]] +name = "smallvec" +version = "1.16.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0d5d4b1981b8bbbb7aed204cae5726d683d5d6ac7e74ec54122ea28f315e7c8" + +[[package]] +name = "smol_str" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" +dependencies = [ + "serde", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "temper-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "serde", +] + +[[package]] +name = "temper-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "temper-core", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl 2.0.21", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "time" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134" +dependencies = [ + "deranged", + "libc", + "num-conv", + "num_threads", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109" + +[[package]] +name = "time-macros" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tokio" +version = "1.54.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3" +dependencies = [ + "pin-project-lite", +] + +[[package]] +name = "toml_datetime" +version = "1.1.2+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b86d767906c6c42421dcba507eb9d203e779497710a47782a224bb871653053" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.18+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ec6e78bd70db9420d8d212fa9dc97f116448a1ceff5d00eabb991d407e21396" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.1.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c" +dependencies = [ + "winnow", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" + +[[package]] +name = "ttf-parser" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31" + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "uuid" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasm-bindgen" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c" +dependencies = [ + "cfg-if", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.80" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e14e0327cb5368ad60ccb22d04a9827a693c95a926d8d125e9fa39e0baec501" +dependencies = [ + "js-sys", + "tokio", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e931a02a39abdbf66966fc35902b5ed58344750a70885bed4ebb3d8eaf28ed9" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ca4b54280e455bd831e33a6b8e734baf432fe63fbc35c42ac14ce67a043a53a" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.9", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b1f9c3798725016c6ee5f2f57869ec0831e8bbc0ab0310a86e787e97f41389e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "web-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7d179596ff5ec0f6de4db64d54011bde6289cc49603d3a6e4ce3f329207ab88" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "widestring" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winit" +version = "0.30.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6755fa58a9f8350bd1e472d4c3fcc25f824ec358933bba33306d0b63df5978d" +dependencies = [ + "android-activity", + "atomic-waker", + "bitflags 2.13.2", + "block2", + "bytemuck", + "calloop", + "cfg_aliases", + "concurrent-queue", + "core-foundation", + "core-graphics 0.23.2", + "cursor-icon", + "dpi", + "js-sys", + "libc", + "ndk", + "objc2", + "objc2-app-kit", + "objc2-foundation", + "objc2-ui-kit", + "orbclient", + "percent-encoding", + "pin-project", + "raw-window-handle 0.6.2", + "redox_syscall 0.4.1", + "rustix 0.38.44", + "smol_str", + "tracing", + "unicode-segmentation", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "web-time", + "windows-sys 0.52.0", + "x11-dl", + "x11rb", + "xkbcommon-dl", +] + +[[package]] +name = "winnow" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef" +dependencies = [ + "memchr", +] + +[[package]] +name = "x11" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e" +dependencies = [ + "libc", + "pkg-config", +] + +[[package]] +name = "x11-clipboard" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "662d74b3d77e396b8e5beb00b9cad6a9eccf40b2ef68cc858784b14c41d535a3" +dependencies = [ + "libc", + "x11rb", +] + +[[package]] +name = "x11-dl" +version = "2.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f" +dependencies = [ + "libc", + "once_cell", + "pkg-config", +] + +[[package]] +name = "x11rb" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414" +dependencies = [ + "as-raw-xcb-connection", + "gethostname", + "libc", + "libloading", + "once_cell", + "rustix 1.1.6", + "x11rb-protocol", + "xcursor", +] + +[[package]] +name = "x11rb-protocol" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd" + +[[package]] +name = "xcursor" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "163b33ed8786455e2fa5d72f554057ce3f3182425434f756cd39c99839d88e23" + +[[package]] +name = "xkbcommon-dl" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5" +dependencies = [ + "bitflags 2.13.2", + "dlib", + "log", + "once_cell", + "xkeysym", +] + +[[package]] +name = "xkeysym" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56" + +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/plugins/forge/plugin/Cargo.toml b/plugins/forge/plugin/Cargo.toml new file mode 100644 index 0000000..7be2ee4 --- /dev/null +++ b/plugins/forge/plugin/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "forge" +version = "0.1.0" +edition = "2021" +license = "ISC" + +[workspace] + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +nih_plug = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683", default-features = false } +nih_plug_egui = { git = "https://github.com/robbert-vdh/nih-plug.git", rev = "de421011f41a6d10fc8c7a6084e4f4dee0143683" } +forge-core = { path = "../core" } +lathe-core = { path = "../../lathe/core" } +temper-core = { path = "../../temper/core" } +knurl-core = { path = "../../knurl/core" } +forge-ui = { path = "../ui" } +crossbeam-queue = "0.3" +serde = { version = "1", features = ["derive"] } + +[dev-dependencies] +clap-sys = { git = "https://github.com/micahrj/clap-sys.git", rev = "25d7f53fdb6363ad63fbd80049cb7a42a97ac156" } +serde_json = "1" + +[profile.release] +lto = "thin" +strip = "symbols" diff --git a/plugins/forge/plugin/src/lib.rs b/plugins/forge/plugin/src/lib.rs new file mode 100644 index 0000000..5e887a5 --- /dev/null +++ b/plugins/forge/plugin/src/lib.rs @@ -0,0 +1,201 @@ +//! CLAP audio effect. All DSP state is owned by the processing thread. +mod params; +use crossbeam_queue::ArrayQueue; +use forge_core::{AnalyzerFrame, Engine}; +use nih_plug::prelude::*; +use nih_plug_egui::{create_egui_editor, egui}; +use params::{Drawn, ForgeParams, FLOATS}; +use std::sync::Arc; + +struct EditorData { + ui: forge_ui::State, + gestures: [bool; FLOATS], +} +pub struct Forge { + params: Arc, + analyzer: Arc>, + engine: Option, + drawn: Drawn, + publish_count: usize, + publish_interval: usize, +} +impl Default for Forge { + fn default() -> Self { + Self { + params: Arc::new(ForgeParams::default()), + analyzer: Arc::new(ArrayQueue::new(2)), + engine: None, + drawn: Drawn::default(), + publish_count: 0, + publish_interval: 1600, + } + } +} +impl Forge { + fn settings(&mut self) -> forge_core::Settings { + let s = self.params.settings(&self.drawn); + self.drawn = Drawn { + gains: s.lathe.gains, + pattern: params::Pattern { + gains: s.knurl.pattern, + grit: s.knurl.grit_steps, + }, + }; + s + } +} +impl Plugin for Forge { + const NAME: &'static str = "Forge"; + const VENDOR: &'static str = "Bass Foundry"; + const URL: &'static str = ""; + const EMAIL: &'static str = ""; + const VERSION: &'static str = env!("CARGO_PKG_VERSION"); + const AUDIO_IO_LAYOUTS: &'static [AudioIOLayout] = &[ + AudioIOLayout { + main_input_channels: NonZeroU32::new(2), + main_output_channels: NonZeroU32::new(2), + ..AudioIOLayout::const_default() + }, + AudioIOLayout { + main_input_channels: NonZeroU32::new(1), + main_output_channels: NonZeroU32::new(1), + ..AudioIOLayout::const_default() + }, + ]; + const MIDI_INPUT: MidiConfig = MidiConfig::Basic; + const SAMPLE_ACCURATE_AUTOMATION: bool = false; + type SysExMessage = (); + type BackgroundTask = (); + fn params(&self) -> Arc { + self.params.clone() + } + fn editor(&mut self, _: AsyncExecutor) -> Option> { + let params = self.params.clone(); + let analyzer = self.analyzer.clone(); + create_egui_editor( + params.editor.clone(), + EditorData { + ui: forge_ui::State::default(), + gestures: [false; FLOATS], + }, + |ctx, _| forge_ui::style(ctx), + move |ctx, setter, data| { + while let Some(frame) = analyzer.pop() { + data.ui.accept_frame(frame); + } + let before = params.settings(¶ms.drawn()); + let mut edited = before; + nih_plug_egui::resizable_window::ResizableWindow::new("forge-editor") + .min_size(egui::vec2( + forge_ui::WIDTH as f32 - 80., + forge_ui::HEIGHT as f32 - 40., + )) + .show(ctx, ¶ms.editor, |ui| { + forge_ui::show(ui, &mut edited, &mut data.ui) + }); + params.apply( + setter, + &before, + &edited, + data.ui.gesture_active, + &mut data.gestures, + ); + // Meters and scopes follow the audio. + ctx.request_repaint_after(std::time::Duration::from_millis(40)); + }, + ) + } + fn initialize( + &mut self, + layout: &AudioIOLayout, + config: &BufferConfig, + context: &mut impl InitContext, + ) -> bool { + let Ok(mut engine) = Engine::new( + config.sample_rate, + layout.main_input_channels.map_or(0, |v| v.get() as usize), + ) else { + return false; + }; + let settings = self.settings(); + if engine.set_settings(settings).is_err() { + return false; + } + context.set_latency_samples(engine.latency_samples()); + self.publish_interval = (config.sample_rate / 30.) as usize; + self.engine = Some(engine); + true + } + fn reset(&mut self) { + if let Some(e) = self.engine.as_mut() { + e.reset(); + } + self.publish_count = 0; + } + fn process( + &mut self, + buffer: &mut Buffer, + _: &mut AuxiliaryBuffers, + context: &mut impl ProcessContext, + ) -> ProcessStatus { + let settings = self.settings(); + let Some(engine) = self.engine.as_mut() else { + return ProcessStatus::Normal; + }; + let _ = engine.set_settings(settings); + let mut next = context.next_event(); + for (index, mut sample) in buffer.iter_samples().enumerate() { + while let Some(event) = next { + if event.timing() as usize > index { + break; + } + match event { + NoteEvent::NoteOn { note, velocity, .. } if velocity > 0. => { + engine.note_on(note) + } + NoteEvent::NoteOn { note, .. } | NoteEvent::NoteOff { note, .. } => { + engine.note_off(note) + } + NoteEvent::Choke { note, .. } => engine.note_off(note), + _ => {} + } + next = context.next_event(); + } + let x = [ + *sample.get_mut(0).unwrap(), + if engine.channels() == 2 { + *sample.get_mut(1).unwrap() + } else { + 0. + }, + ]; + let out = engine.process_sample(x); + for (c, value) in sample.into_iter().enumerate() { + *value = out[c]; + } + self.publish_count += 1; + if self.publish_count >= self.publish_interval { + self.analyzer.force_push(engine.take_analyzer()); + self.publish_count = 0; + } + } + // The lookahead delay and the module tails must drain after input stops. + ProcessStatus::KeepAlive + } +} +impl ClapPlugin for Forge { + const CLAP_ID: &'static str = "io.narl.bass-foundry.forge"; + const CLAP_DESCRIPTION: Option<&'static str> = Some( + "One tracked channel strip: Lathe, Temper and Knurl behind one note tracker, in any order", + ); + const CLAP_MANUAL_URL: Option<&'static str> = None; + const CLAP_SUPPORT_URL: Option<&'static str> = None; + const CLAP_FEATURES: &'static [ClapFeature] = &[ + ClapFeature::AudioEffect, + ClapFeature::Distortion, + ClapFeature::Equalizer, + ClapFeature::Stereo, + ClapFeature::Mono, + ]; +} +nih_export_clap!(Forge); diff --git a/plugins/forge/plugin/src/params.rs b/plugins/forge/plugin/src/params.rs new file mode 100644 index 0000000..0c6687d --- /dev/null +++ b/plugins/forge/plugin/src/params.rs @@ -0,0 +1,605 @@ +use forge_core::{Settings, Source, ORDERS}; +use knurl_core::{Seed, GRIT_OFF, STEPS, STEP_MIN}; +use lathe_core::HARMONICS; +use nih_plug::prelude::*; +use nih_plug_egui::EguiState; +use std::sync::{Arc, RwLock}; +use temper_core::Curve; + +#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)] +pub enum SourceParam { + #[id = "audio"] + Audio, + #[id = "midi"] + #[name = "MIDI"] + Midi, +} +/// The six orders of `ORDERS`, in the same order. +#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)] +pub enum OrderParam { + #[id = "lathe-temper-knurl"] + #[name = "Lathe, Temper, Knurl"] + LatheTemperKnurl, + #[id = "temper-lathe-knurl"] + #[name = "Temper, Lathe, Knurl"] + TemperLatheKnurl, + #[id = "lathe-knurl-temper"] + #[name = "Lathe, Knurl, Temper"] + LatheKnurlTemper, + #[id = "temper-knurl-lathe"] + #[name = "Temper, Knurl, Lathe"] + TemperKnurlLathe, + #[id = "knurl-lathe-temper"] + #[name = "Knurl, Lathe, Temper"] + KnurlLatheTemper, + #[id = "knurl-temper-lathe"] + #[name = "Knurl, Temper, Lathe"] + KnurlTemperLathe, +} +#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)] +pub enum CurveParam { + #[id = "soft"] + Soft, + #[id = "hard"] + Hard, + #[id = "fold"] + Fold, + #[id = "tube"] + Tube, +} +#[derive(Enum, Debug, PartialEq, Eq, Clone, Copy)] +pub enum SeedParam { + #[id = "same"] + #[name = "Same every note"] + Same, + #[id = "free"] + Free, +} + +fn linear(name: &str, v: f32, min: f32, max: f32, unit: &'static str) -> FloatParam { + FloatParam::new(name, v, FloatRange::Linear { min, max }).with_unit(unit) +} +fn on(name: &str) -> BoolParam { + BoolParam::new(format!("{name} on"), true) +} + +/// Knurl's drawn pattern: step gains and grit switches. +#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)] +pub struct Pattern { + pub gains: [f32; STEPS], + pub grit: [bool; STEPS], +} +impl Default for Pattern { + fn default() -> Self { + let d = knurl_core::Settings::default(); + Self { + gains: d.pattern, + grit: d.grit_steps, + } + } +} +/// Drawn data saved with the project, not exposed as automation lanes. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct Drawn { + pub gains: [f32; HARMONICS], + pub pattern: Pattern, +} +impl Default for Drawn { + fn default() -> Self { + Self { + gains: lathe_core::Settings::default().gains, + pattern: Pattern::default(), + } + } +} + +#[derive(Params)] +pub struct LatheParams { + #[persist = "gains"] + pub gains: RwLock<[f32; HARMONICS]>, + #[id = "on"] + pub on: BoolParam, + #[id = "tilt"] + pub tilt: FloatParam, + #[id = "odd-even"] + pub odd_even: FloatParam, + #[id = "between"] + pub between: FloatParam, + #[id = "width"] + pub width: FloatParam, + #[id = "smooth"] + pub smooth: FloatParam, + #[id = "mix"] + pub mix: FloatParam, + #[id = "output"] + pub output: FloatParam, + #[id = "harmonics"] + pub harmonics: IntParam, + #[id = "snap"] + pub snap: BoolParam, +} +impl Default for LatheParams { + fn default() -> Self { + let d = lathe_core::Settings::default(); + Self { + gains: RwLock::new(d.gains), + on: on("Lathe"), + tilt: linear("Lathe tilt", d.tilt, -12., 12., " dB/oct"), + odd_even: linear("Lathe odd/even", d.odd_even, -12., 12., " dB"), + between: linear("Lathe between", d.between, -24., 12., " dB"), + width: linear("Lathe width", d.width, 5., 50., " %"), + smooth: linear("Lathe smooth", d.smooth, 0., 100., " ms"), + mix: linear("Lathe mix", d.mix, 0., 100., " %"), + output: linear("Lathe output", d.output, -12., 12., " dB"), + harmonics: IntParam::new( + "Lathe harmonics", + d.harmonics as i32, + IntRange::Linear { + min: 8, + max: HARMONICS as i32, + }, + ), + snap: BoolParam::new("Lathe snap to semitone", d.snap), + } + } +} + +#[derive(Params)] +pub struct TemperParams { + #[id = "on"] + pub on: BoolParam, + #[id = "curve"] + pub curve: EnumParam, + #[id = "drive"] + pub drive: FloatParam, + #[id = "bias"] + pub bias: FloatParam, + #[id = "normalize"] + pub normalize: FloatParam, + #[id = "floor"] + pub floor: FloatParam, + #[id = "push"] + pub push_gain: FloatParam, + #[id = "bright"] + pub bright: FloatParam, + #[id = "mix"] + pub mix: FloatParam, + #[id = "output"] + pub output: FloatParam, + #[id = "push-at"] + pub push_harmonic: IntParam, + #[id = "auto-gain"] + pub auto_gain: BoolParam, +} +impl Default for TemperParams { + fn default() -> Self { + let d = temper_core::Settings::default(); + Self { + on: on("Temper"), + curve: EnumParam::new("Temper curve", CurveParam::Soft), + drive: linear("Temper drive", d.drive, 0., 36., " dB"), + bias: linear("Temper bias", d.bias, 0., 100., " %"), + normalize: linear("Temper normalize", d.normalize, 0., 100., " %"), + floor: linear("Temper floor", d.floor, 0., 2., " ×f0"), + push_gain: linear("Temper push", d.push_gain, -12., 12., " dB"), + bright: linear("Temper bright", d.bright, 0., 64., " ×f0"), + mix: linear("Temper mix", d.mix, 0., 100., " %"), + output: linear("Temper output", d.output, -12., 12., " dB"), + push_harmonic: IntParam::new( + "Temper push at", + d.push_harmonic as i32, + IntRange::Linear { min: 1, max: 16 }, + ), + auto_gain: BoolParam::new("Temper auto gain", d.auto_gain), + } + } +} + +#[derive(Params)] +pub struct KnurlParams { + #[persist = "pattern"] + pub pattern: RwLock, + #[id = "on"] + pub on: BoolParam, + #[id = "seed"] + pub seed: EnumParam, + #[id = "steps"] + pub steps: IntParam, + #[id = "edge"] + pub edge: FloatParam, + #[id = "level-jitter"] + pub level_jitter: FloatParam, + #[id = "time-jitter"] + pub time_jitter: FloatParam, + #[id = "grit"] + pub grit: FloatParam, + #[id = "tone"] + pub tone: FloatParam, + #[id = "position"] + pub position: FloatParam, + #[id = "length"] + pub length: FloatParam, + #[id = "mix"] + pub mix: FloatParam, + #[id = "output"] + pub output: FloatParam, + #[id = "snap"] + pub snap: BoolParam, +} +impl Default for KnurlParams { + fn default() -> Self { + let d = knurl_core::Settings::default(); + Self { + pattern: RwLock::new(Pattern::default()), + on: on("Knurl"), + seed: EnumParam::new("Knurl random", SeedParam::Same), + steps: IntParam::new( + "Knurl steps", + d.steps as i32, + IntRange::Linear { + min: 1, + max: STEPS as i32, + }, + ), + edge: linear("Knurl edge", d.edge, 5., 50., " %"), + level_jitter: linear("Knurl level jitter", d.level_jitter, 0., 6., " dB"), + time_jitter: linear("Knurl time jitter", d.time_jitter, 0., 10., " %"), + grit: linear("Knurl grit", d.grit, GRIT_OFF, 0., " dB").with_value_to_string(Arc::new( + |v| { + if v <= GRIT_OFF { + "Off".into() + } else { + format!("{v:.1}") + } + }, + )), + tone: FloatParam::new( + "Knurl tone", + d.tone, + FloatRange::Skewed { + min: 4., + max: 64., + factor: FloatRange::skew_factor(-1.), + }, + ) + .with_unit(" ×f0"), + position: linear("Knurl position", d.position, 0., 100., " %"), + length: linear("Knurl length", d.length, 2., 50., " %"), + mix: linear("Knurl mix", d.mix, 0., 100., " %"), + output: linear("Knurl output", d.output, -12., 12., " dB"), + snap: BoolParam::new("Knurl snap to semitone", d.snap), + } + } +} + +/// Continuous controls, in the order of the gesture slots. +pub const FLOATS: usize = 25; + +#[derive(Params)] +pub struct ForgeParams { + #[persist = "editor"] + pub editor: Arc, + #[id = "source"] + pub source: EnumParam, + #[id = "gate"] + pub gate: FloatParam, + #[id = "order"] + pub order: EnumParam, + #[id = "bypass"] + pub bypass: BoolParam, + #[nested(id_prefix = "lathe", group = "Lathe")] + pub lathe: LatheParams, + #[nested(id_prefix = "temper", group = "Temper")] + pub temper: TemperParams, + #[nested(id_prefix = "knurl", group = "Knurl")] + pub knurl: KnurlParams, +} +impl Default for ForgeParams { + fn default() -> Self { + let d = Settings::default(); + Self { + editor: EguiState::from_size(forge_ui::WIDTH, forge_ui::HEIGHT), + source: EnumParam::new("Pitch source", SourceParam::Audio), + gate: linear("Gate", d.gate, -60., -20., " dB"), + order: EnumParam::new("Order", OrderParam::LatheTemperKnurl), + bypass: BoolParam::new("Bypass", false).make_bypass(), + lathe: LatheParams::default(), + temper: TemperParams::default(), + knurl: KnurlParams::default(), + } + } +} + +const CURVES: [(CurveParam, Curve); 4] = [ + (CurveParam::Soft, Curve::Soft), + (CurveParam::Hard, Curve::Hard), + (CurveParam::Fold, Curve::Fold), + (CurveParam::Tube, Curve::Tube), +]; +const ORDER_PARAMS: [OrderParam; 6] = [ + OrderParam::LatheTemperKnurl, + OrderParam::TemperLatheKnurl, + OrderParam::LatheKnurlTemper, + OrderParam::TemperKnurlLathe, + OrderParam::KnurlLatheTemper, + OrderParam::KnurlTemperLathe, +]; + +/// Every continuous control's value, in the order of `ForgeParams::floats`. +fn float_values(s: &Settings) -> [f32; FLOATS] { + let (l, t, k) = (&s.lathe, &s.temper, &s.knurl); + [ + s.gate, + l.tilt, + l.odd_even, + l.between, + l.width, + l.smooth, + l.mix, + l.output, + t.drive, + t.bias, + t.normalize, + t.floor, + t.push_gain, + t.bright, + t.mix, + t.output, + k.edge, + k.level_jitter, + k.time_jitter, + k.grit, + k.tone, + k.position, + k.length, + k.mix, + k.output, + ] +} +fn switch(setter: &ParamSetter, p: &P, old: P::Plain, new: P::Plain) +where + P::Plain: PartialEq, +{ + if old != new { + setter.begin_set_parameter(p); + setter.set_parameter(p, new); + setter.end_set_parameter(p); + } +} + +impl ForgeParams { + /// The drawn data. Falls back to defaults while the editor holds a lock. + pub fn drawn(&self) -> Drawn { + let mut d = Drawn::default(); + if let Ok(g) = self.lathe.gains.read() { + d.gains = *g; + } + if let Ok(p) = self.knurl.pattern.read() { + d.pattern = *p; + } + d + } + /// Current settings. Drawn data falls back to `last` when the editor holds a lock, so the + /// audio thread never waits. + pub fn settings(&self, last: &Drawn) -> Settings { + let gains = self + .lathe + .gains + .try_read() + .map(|g| *g) + .unwrap_or(last.gains); + let pattern = self + .knurl + .pattern + .try_read() + .map(|p| *p) + .unwrap_or(last.pattern); + let (l, t, k) = (&self.lathe, &self.temper, &self.knurl); + let order = ORDER_PARAMS + .iter() + .position(|o| *o == self.order.value()) + .unwrap_or(0); + let curve = self.temper.curve.value(); + let mut s = Settings { + source: match self.source.value() { + SourceParam::Audio => Source::Audio, + SourceParam::Midi => Source::Midi, + }, + gate: self.gate.value(), + order: ORDERS[order], + lathe: lathe_core::Settings { + gains: gains.map(|g| { + if g.is_finite() { + g.clamp(lathe_core::GAIN_MIN, lathe_core::GAIN_MAX) + } else { + 0. + } + }), + tilt: l.tilt.value(), + odd_even: l.odd_even.value(), + between: l.between.value(), + width: l.width.value(), + harmonics: l.harmonics.value() as u32, + smooth: l.smooth.value(), + snap: l.snap.value(), + mix: l.mix.value(), + output: l.output.value(), + bypass: !l.on.value(), + ..lathe_core::Settings::default() + }, + temper: temper_core::Settings { + drive: t.drive.value(), + curve: CURVES + .iter() + .find(|(p, _)| *p == curve) + .map_or(Curve::Soft, |(_, c)| *c), + bias: t.bias.value(), + normalize: t.normalize.value(), + floor: t.floor.value(), + push_harmonic: t.push_harmonic.value() as u32, + push_gain: t.push_gain.value(), + bright: t.bright.value(), + auto_gain: t.auto_gain.value(), + mix: t.mix.value(), + output: t.output.value(), + bypass: !t.on.value(), + ..temper_core::Settings::default() + }, + knurl: knurl_core::Settings { + pattern: pattern.gains.map(|g| { + if g.is_finite() { + g.clamp(STEP_MIN, 0.) + } else { + 0. + } + }), + grit_steps: pattern.grit, + steps: k.steps.value().clamp(1, STEPS as i32) as usize, + edge: k.edge.value(), + level_jitter: k.level_jitter.value(), + time_jitter: k.time_jitter.value(), + grit: k.grit.value(), + tone: k.tone.value(), + position: k.position.value(), + length: k.length.value(), + seed: match k.seed.value() { + SeedParam::Same => Seed::Same, + SeedParam::Free => Seed::Free, + }, + snap: k.snap.value(), + mix: k.mix.value(), + output: k.output.value(), + bypass: !k.on.value(), + ..knurl_core::Settings::default() + }, + bypass: self.bypass.value(), + }; + s.share(); + s + } + fn floats(&self) -> [&FloatParam; FLOATS] { + let (l, t, k) = (&self.lathe, &self.temper, &self.knurl); + [ + &self.gate, + &l.tilt, + &l.odd_even, + &l.between, + &l.width, + &l.smooth, + &l.mix, + &l.output, + &t.drive, + &t.bias, + &t.normalize, + &t.floor, + &t.push_gain, + &t.bright, + &t.mix, + &t.output, + &k.edge, + &k.level_jitter, + &k.time_jitter, + &k.grit, + &k.tone, + &k.position, + &k.length, + &k.mix, + &k.output, + ] + } + /// Pushes every changed editor value to the host. Continuous controls hold one gesture + /// while the pointer is down; switches are set in a single gesture. Drawn data is stored + /// directly. + pub fn apply( + &self, + setter: &ParamSetter, + old: &Settings, + new: &Settings, + dragging: bool, + open: &mut [bool; FLOATS], + ) { + if new.lathe.gains != old.lathe.gains { + if let Ok(mut g) = self.lathe.gains.write() { + *g = new.lathe.gains; + } + } + if new.knurl.pattern != old.knurl.pattern || new.knurl.grit_steps != old.knurl.grit_steps { + if let Ok(mut p) = self.knurl.pattern.write() { + *p = Pattern { + gains: new.knurl.pattern, + grit: new.knurl.grit_steps, + }; + } + } + let (a, b) = (float_values(old), float_values(new)); + for (i, p) in self.floats().into_iter().enumerate() { + if a[i] != b[i] { + if !open[i] { + open[i] = true; + setter.begin_set_parameter(p); + } + setter.set_parameter(p, b[i]); + } + if !dragging && open[i] { + setter.end_set_parameter(p); + open[i] = false; + } + } + let (l, t, k) = (&self.lathe, &self.temper, &self.knurl); + switch(setter, &self.bypass, old.bypass, new.bypass); + switch(setter, &l.on, !old.lathe.bypass, !new.lathe.bypass); + switch(setter, &t.on, !old.temper.bypass, !new.temper.bypass); + switch(setter, &k.on, !old.knurl.bypass, !new.knurl.bypass); + switch(setter, &l.snap, old.lathe.snap, new.lathe.snap); + switch(setter, &k.snap, old.knurl.snap, new.knurl.snap); + switch( + setter, + &t.auto_gain, + old.temper.auto_gain, + new.temper.auto_gain, + ); + switch( + setter, + &l.harmonics, + old.lathe.harmonics as i32, + new.lathe.harmonics as i32, + ); + switch( + setter, + &t.push_harmonic, + old.temper.push_harmonic as i32, + new.temper.push_harmonic as i32, + ); + switch( + setter, + &k.steps, + old.knurl.steps as i32, + new.knurl.steps as i32, + ); + let source = |s: Source| match s { + Source::Audio => SourceParam::Audio, + Source::Midi => SourceParam::Midi, + }; + switch(setter, &self.source, source(old.source), source(new.source)); + let order = + |s: &Settings| ORDER_PARAMS[ORDERS.iter().position(|o| *o == s.order).unwrap_or(0)]; + switch(setter, &self.order, order(old), order(new)); + let curve = |c: Curve| { + CURVES + .iter() + .find(|(_, k)| *k == c) + .map_or(CurveParam::Soft, |(p, _)| *p) + }; + switch( + setter, + &t.curve, + curve(old.temper.curve), + curve(new.temper.curve), + ); + let seed = |s: Seed| match s { + Seed::Same => SeedParam::Same, + Seed::Free => SeedParam::Free, + }; + switch(setter, &k.seed, seed(old.knurl.seed), seed(new.knurl.seed)); + } +} diff --git a/plugins/forge/plugin/tests/host.rs b/plugins/forge/plugin/tests/host.rs new file mode 100644 index 0000000..57096e5 --- /dev/null +++ b/plugins/forge/plugin/tests/host.rs @@ -0,0 +1,231 @@ +//! Exercise the actual exported CLAP ABI without requiring a GUI or installed DAW. +use clap_sys::{ + audio_buffer::*, + events::*, + ext::{audio_ports::*, latency::*, state::*}, + factory::plugin_factory::*, + host::*, + process::*, + stream::*, + version::*, +}; +use std::{ + ffi::{c_char, c_void, CStr}, + io::{Cursor, Read}, + ptr, +}; + +unsafe extern "C" fn extension(_: *const clap_host, _: *const c_char) -> *const c_void { + ptr::null() +} +unsafe extern "C" fn request(_: *const clap_host) {} +unsafe extern "C" fn count(_: *const clap_input_events) -> u32 { + 0 +} +unsafe extern "C" fn event(_: *const clap_input_events, _: u32) -> *const clap_event_header { + ptr::null() +} +unsafe extern "C" fn push(_: *const clap_output_events, _: *const clap_event_header) -> bool { + true +} +unsafe extern "C" fn write(stream: *const clap_ostream, buffer: *const c_void, size: u64) -> i64 { + // SAFETY: The test owns the Vec for the entire synchronous save call. + let bytes = unsafe { &mut *((*stream).ctx as *mut Vec) }; + bytes.extend_from_slice(unsafe { + std::slice::from_raw_parts(buffer as *const u8, size as usize) + }); + size as i64 +} +unsafe extern "C" fn read(stream: *const clap_istream, buffer: *mut c_void, size: u64) -> i64 { + // SAFETY: The test owns the Cursor; the wrapper supplies writable stream storage. + let cursor = unsafe { &mut *((*stream).ctx as *mut Cursor>) }; + cursor + .read(unsafe { std::slice::from_raw_parts_mut(buffer as *mut u8, size as usize) }) + .unwrap() as i64 +} + +#[test] +fn effect_ports_state_latency_and_audio_lifecycle() { + // SAFETY: All callbacks, strings, streams, buffers, and the host outlive their + // synchronous ABI calls. Activation/processing/destruction follow CLAP order. + unsafe { + let entry = &forge::clap_entry; + assert!(entry.init.unwrap()(c"forge.clap".as_ptr())); + let factory = entry.get_factory.unwrap()(CLAP_PLUGIN_FACTORY_ID.as_ptr()) + as *const clap_plugin_factory; + assert!(!factory.is_null()); + let factory = &*factory; + assert_eq!(factory.get_plugin_count.unwrap()(factory), 1); + let descriptor = factory.get_plugin_descriptor.unwrap()(factory, 0); + assert!(!descriptor.is_null()); + assert_eq!(CStr::from_ptr((*descriptor).name), c"Forge"); + assert_eq!( + CStr::from_ptr((*descriptor).id), + c"io.narl.bass-foundry.forge" + ); + assert!(factory.get_plugin_descriptor.unwrap()(factory, 1).is_null()); + let host = clap_host { + clap_version: CLAP_VERSION, + host_data: ptr::null_mut(), + name: c"Storyboard test host".as_ptr(), + vendor: c"Tests".as_ptr(), + url: c"".as_ptr(), + version: c"1.0".as_ptr(), + get_extension: Some(extension), + request_restart: Some(request), + request_process: Some(request), + request_callback: Some(request), + }; + let plugin = factory.create_plugin.unwrap()(factory, &host, (*descriptor).id); + assert!(!plugin.is_null()); + let p = &*plugin; + assert!(p.init.unwrap()(plugin)); + let ports = p.get_extension.unwrap()(plugin, CLAP_EXT_AUDIO_PORTS.as_ptr()) + as *const clap_plugin_audio_ports; + assert!(!ports.is_null()); + assert_eq!((*ports).count.unwrap()(plugin, false), 1); + assert_eq!((*ports).count.unwrap()(plugin, true), 1); + let latency = p.get_extension.unwrap()(plugin, CLAP_EXT_LATENCY.as_ptr()) + as *const clap_plugin_latency; + assert!(!latency.is_null()); + let state = + p.get_extension.unwrap()(plugin, CLAP_EXT_STATE.as_ptr()) as *const clap_plugin_state; + assert!(!state.is_null()); + let state = &*state; + let save = || { + let mut bytes = Vec::new(); + let stream = clap_ostream { + ctx: &mut bytes as *mut Vec as *mut c_void, + write: Some(write), + }; + assert!(state.save.unwrap()(plugin, &stream)); + bytes + }; + let mut envelope: nih_plug::prelude::PluginState = + serde_json::from_slice(&save()[8..]).unwrap(); + use nih_plug::wrapper::state::ParamValue; + envelope + .params + .insert("lathe_tilt".into(), ParamValue::F32(-3.)); + envelope + .params + .insert("lathe_harmonics".into(), ParamValue::I32(16)); + let mut gains = [0f32; 32]; + gains[2] = -12.; + gains[4] = 6.; + envelope + .fields + .insert("lathe_gains".into(), serde_json::to_string(&gains).unwrap()); + envelope + .params + .insert("lathe_snap".into(), ParamValue::Bool(false)); + // Every module off: the strip passes the input, delayed. + for module in ["lathe", "temper", "knurl"] { + envelope + .params + .insert(format!("{module}_on"), ParamValue::Bool(false)); + } + envelope.params.insert( + "order".into(), + ParamValue::String("knurl-lathe-temper".into()), + ); + envelope + .params + .insert("source".into(), ParamValue::String("midi".into())); + let encoded = serde_json::to_vec(&envelope).unwrap(); + let mut framed = (encoded.len() as u64).to_le_bytes().to_vec(); + framed.extend_from_slice(&encoded); + let mut bytes = Cursor::new(framed); + let stream = clap_istream { + ctx: &mut bytes as *mut Cursor> as *mut c_void, + read: Some(read), + }; + assert!(state.load.unwrap()(plugin, &stream)); + let restored: nih_plug::prelude::PluginState = + serde_json::from_slice(&save()[8..]).unwrap(); + assert_eq!( + serde_json::to_value(&restored.params).unwrap(), + serde_json::to_value(&envelope.params).unwrap() + ); + let saved: [f32; 32] = serde_json::from_str(&restored.fields["lathe_gains"]).unwrap(); + assert_eq!(saved, gains); + for rate in [44100., 48000., 96000.] { + assert!(p.activate.unwrap()(plugin, rate, 1, 512)); + let delay = (*latency).get.unwrap()(plugin) as usize; + // One lookahead (about 67 ms), Temper's oversampling and Knurl's jitter headroom. + assert!((delay as f64 / rate - 0.072).abs() < 0.003, "{delay}"); + assert!(p.start_processing.unwrap()(plugin)); + let total = delay + 9600; + let mut position = 0; + let (mut energy_in, mut energy_out) = (0f64, 0f64); + while position < total { + let frames = [1, 127, 512, 31][position % 4].min(total - position); + // With every module off a 1 kHz tone passes unchanged. + let tone = |n: usize| { + 0.25 * (std::f64::consts::TAU * 1000. * n as f64 / rate).sin() as f32 + }; + let mut input_left = [0f32; 512]; + let mut input_right = [0f32; 512]; + for i in 0..frames { + input_left[i] = tone(position + i); + input_right[i] = -tone(position + i); + } + let mut left = [0f32; 512]; + let mut right = [0f32; 512]; + let mut in_channels = [input_left.as_mut_ptr(), input_right.as_mut_ptr()]; + let mut out_channels = [left.as_mut_ptr(), right.as_mut_ptr()]; + let incoming = clap_audio_buffer { + data32: in_channels.as_mut_ptr(), + data64: ptr::null_mut(), + channel_count: 2, + latency: 0, + constant_mask: 0, + }; + let mut outgoing_audio = clap_audio_buffer { + data32: out_channels.as_mut_ptr(), + data64: ptr::null_mut(), + channel_count: 2, + latency: 0, + constant_mask: 0, + }; + let input = clap_input_events { + ctx: ptr::null_mut(), + size: Some(count), + get: Some(event), + }; + let outgoing = clap_output_events { + ctx: ptr::null_mut(), + try_push: Some(push), + }; + let process = clap_process { + steady_time: position as i64, + frames_count: frames as u32, + transport: ptr::null(), + audio_inputs: &incoming, + audio_outputs: &mut outgoing_audio, + audio_inputs_count: 1, + audio_outputs_count: 1, + in_events: &input, + out_events: &outgoing, + }; + assert_ne!(p.process.unwrap()(plugin, &process), CLAP_PROCESS_ERROR); + for i in 0..frames { + let n = position + i; + if n < delay { + assert!(left[i].abs() < 1e-6, "output before the lookahead"); + } else if n > delay + 4800 { + energy_in += (tone(n - delay) as f64).powi(2); + energy_out += (left[i] as f64).powi(2) + (right[i] as f64).powi(2); + } + } + position += frames; + } + let ratio_db = 10. * (energy_out / (2. * energy_in)).log10(); + assert!(ratio_db.abs() < 0.2, "{ratio_db}"); + p.stop_processing.unwrap()(plugin); + p.deactivate.unwrap()(plugin); + } + p.destroy.unwrap()(plugin); + entry.deinit.unwrap()(); + } +} diff --git a/plugins/forge/ui/Cargo.toml b/plugins/forge/ui/Cargo.toml new file mode 100644 index 0000000..cfc789a --- /dev/null +++ b/plugins/forge/ui/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "forge-ui" +version = "0.1.0" +edition.workspace = true +license.workspace = true + +[dependencies] +egui = "0.31.1" +forge-core = { path = "../core" } +lathe-core = { path = "../../lathe/core" } +temper-core = { path = "../../temper/core" } +knurl-core = { path = "../../knurl/core" } +lathe-ui = { path = "../../lathe/ui" } +temper-ui = { path = "../../temper/ui" } +knurl-ui = { path = "../../knurl/ui" } +common-ui = { path = "../../common/ui" } +common-dsp = { path = "../../common/dsp" } diff --git a/plugins/forge/ui/src/lib.rs b/plugins/forge/ui/src/lib.rs new file mode 100644 index 0000000..5f88313 --- /dev/null +++ b/plugins/forge/ui/src/lib.rs @@ -0,0 +1,175 @@ +//! Forge editor, shared by the CLAP wrapper and the headless renderer. The module pages are +//! the standalone editors' bodies. +use common_ui::*; +use egui::{self, RichText}; +use forge_core::{AnalyzerFrame, Settings, Source, Stage, STAGES}; + +pub use common_ui::style; +pub const WIDTH: u32 = 1040; +pub const HEIGHT: u32 = 730; + +pub struct State { + pub lathe: lathe_ui::State, + pub temper: temper_ui::State, + pub knurl: knurl_ui::State, + /// Module whose page is shown. + pub page: Stage, + latency: u32, + sample_rate: f32, + /// True while a pointer button is held, so knob drags become one host gesture. + pub gesture_active: bool, + pub help: String, +} +impl Default for State { + fn default() -> Self { + Self { + lathe: lathe_ui::State::default(), + temper: temper_ui::State::default(), + knurl: knurl_ui::State::default(), + page: Stage::Lathe, + latency: 0, + sample_rate: 48000., + gesture_active: false, + help: DEFAULT_HELP.into(), + } + } +} +const DEFAULT_HELP: &str = "One tracker for every module. Pick a module to edit it; switch \ + modules on and off and change their order in the chain."; +impl State { + pub fn accept_frame(&mut self, frame: AnalyzerFrame) { + self.lathe.accept_frame(frame.lathe); + self.temper.accept_frame(frame.temper); + self.knurl.accept_frame(frame.knurl); + self.latency = frame.latency; + self.sample_rate = frame.sample_rate; + } +} +fn hint(r: &egui::Response, help: &mut String, text: &str) { + if r.hovered() || r.has_focus() { + *help = text.into(); + } +} + +fn subtitle(stage: Stage) -> &'static str { + match stage { + Stage::Lathe => "harmonic EQ", + Stage::Temper => "tracked distortion", + Stage::Knurl => "cycle texture", + } +} + +/// The chain: modules in order, each with its switch, and the swaps between neighbours. +fn chain(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) { + ui.horizontal(|ui| { + caption(ui, "CHAIN"); + ui.add_space(8.); + for i in 0..STAGES { + if i > 0 { + let r = ui.button(RichText::new("<>").size(12.).color(MUTED)); + if r.clicked() { + settings.order.swap(i - 1, i); + } + hint(&r, &mut state.help, "Swap the two modules next to it."); + } + let stage = settings.order[i]; + let on = settings.on(stage); + let name = RichText::new(stage.name().to_uppercase()).size(14.); + let r = + ui.selectable_label(state.page == stage, if on { name } else { name.color(DIM) }); + if r.clicked() { + state.page = stage; + } + hint( + &r, + &mut state.help, + &format!("Show {} ({}).", stage.name(), subtitle(stage)), + ); + let r = ui.selectable_label(on, RichText::new("ON").size(11.)); + if r.clicked() { + settings.set_on(stage, !on); + } + hint( + &r, + &mut state.help, + "Switch the module on or off. Off, it still delays the audio, so the latency \ + stays.", + ); + } + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + ui.label( + RichText::new(format!( + "{:.0} ms latency, one lookahead", + state.latency as f32 / state.sample_rate.max(1.) * 1000. + )) + .size(12.) + .color(MUTED), + ); + ui.separator(); + match state.page { + Stage::Lathe => lathe_ui::toggles(ui, &mut settings.lathe), + Stage::Temper => temper_ui::toggles(ui, &mut settings.temper), + Stage::Knurl => knurl_ui::toggles(ui, &mut settings.knurl), + } + }); + }); +} + +pub fn show(ui: &mut egui::Ui, settings: &mut Settings, state: &mut State) { + backdrop(ui); + state.help = DEFAULT_HELP.into(); + state.gesture_active = ui.input(|i| i.pointer.any_down()); + settings.share(); + ui.add_space(2.); + header(ui, "FORGE", "TRACKED CHANNEL STRIP", |ui| { + let r = ui + .selectable_label(settings.bypass, RichText::new("BYPASS").size(13.)) + .on_hover_text("Crossfade to the delayed dry signal."); + if r.clicked() { + settings.bypass = !settings.bypass; + } + ui.separator(); + for (source, label) in [(Source::Midi, "MIDI"), (Source::Audio, "AUDIO")] { + let r = ui.selectable_label(settings.source == source, RichText::new(label).size(13.)); + if r.clicked() { + settings.source = source; + } + } + caption(ui, "PITCH FROM"); + }); + ui.add_space(6.); + panel(ui, |ui| { + ui.set_width(ui.available_width()); + chain(ui, settings, state); + }); + // A module page edits the module's own settings. Its Gate knob sets the strip's gate. + let gate = match state.page { + Stage::Lathe => { + state.lathe.help.clear(); + lathe_ui::body(ui, &mut settings.lathe, &mut state.lathe); + module_help(&mut state.help, &state.lathe.help); + settings.lathe.gate + } + Stage::Temper => { + state.temper.help.clear(); + temper_ui::body(ui, &mut settings.temper, &mut state.temper); + module_help(&mut state.help, &state.temper.help); + settings.temper.gate + } + Stage::Knurl => { + state.knurl.help.clear(); + knurl_ui::body(ui, &mut settings.knurl, &mut state.knurl); + module_help(&mut state.help, &state.knurl.help); + settings.knurl.gate + } + }; + settings.gate = gate; + settings.share(); + ui.separator(); + ui.label(RichText::new(&state.help).color(MUTED)); +} +fn module_help(help: &mut String, module: &str) { + if !module.is_empty() { + *help = module.into(); + } +} diff --git a/tools/editor-check/Cargo.lock b/tools/editor-check/Cargo.lock index d5f4398..f3f2d26 100644 --- a/tools/editor-check/Cargo.lock +++ b/tools/editor-check/Cargo.lock @@ -197,6 +197,8 @@ dependencies = [ "crucible-core", "crucible-ui", "egui", + "forge-core", + "forge-ui", "image", "knurl-core", "knurl-ui", @@ -279,6 +281,33 @@ dependencies = [ "zlib-rs", ] +[[package]] +name = "forge-core" +version = "0.1.0" +dependencies = [ + "common-dsp", + "knurl-core", + "lathe-core", + "serde", + "temper-core", +] + +[[package]] +name = "forge-ui" +version = "0.1.0" +dependencies = [ + "common-dsp", + "common-ui", + "egui", + "forge-core", + "knurl-core", + "knurl-ui", + "lathe-core", + "lathe-ui", + "temper-core", + "temper-ui", +] + [[package]] name = "image" version = "0.25.10" diff --git a/tools/editor-check/Cargo.toml b/tools/editor-check/Cargo.toml index 9b168ac..9c697ff 100644 --- a/tools/editor-check/Cargo.toml +++ b/tools/editor-check/Cargo.toml @@ -33,5 +33,7 @@ quench-core = { path = "../../plugins/quench/core" } quench-ui = { path = "../../plugins/quench/ui" } ballast-core = { path = "../../plugins/ballast/core" } ballast-ui = { path = "../../plugins/ballast/ui" } +forge-core = { path = "../../plugins/forge/core" } +forge-ui = { path = "../../plugins/forge/ui" } weld-core = { path = "../../plugins/weld/core" } weld-ui = { path = "../../plugins/weld/ui" } diff --git a/tools/editor-check/src/main.rs b/tools/editor-check/src/main.rs index 1e311b1..fa824c6 100644 --- a/tools/editor-check/src/main.rs +++ b/tools/editor-check/src/main.rs @@ -12,13 +12,13 @@ fn main() { .unwrap_or("rivet"); if ![ "rivet", "patina", "anvil", "crucible", "lathe", "temper", "weld", "knurl", "planish", - "braze", "quench", "ballast", + "braze", "quench", "ballast", "forge", ] .contains(&plugin) { eprintln!( "Use --plugin rivet, patina, anvil, crucible, lathe, temper, weld, knurl, planish, \ - braze, quench or ballast" + braze, quench, ballast or forge" ); std::process::exit(2); } @@ -34,7 +34,10 @@ fn main() { let braze = plugin == "braze"; let quench = plugin == "quench"; let ballast = plugin == "ballast"; - let (width, height) = if ballast { + let forge = plugin == "forge"; + let (width, height) = if forge { + (forge_ui::WIDTH, forge_ui::HEIGHT) + } else if ballast { (ballast_ui::WIDTH, ballast_ui::HEIGHT) } else if quench { (quench_ui::WIDTH, quench_ui::HEIGHT) @@ -195,6 +198,39 @@ fn main() { } knurl_state.accept_frame(engine.take_analyzer()); } + let mut forge_settings = forge_core::Settings::default(); + forge_settings.lathe.gains[1] = -9.; + forge_settings.lathe.gains[3] = 4.; + forge_settings.temper.drive = 9.; + forge_settings.order = [ + forge_core::Stage::Knurl, + forge_core::Stage::Lathe, + forge_core::Stage::Temper, + ]; + let mut forge_state = forge_ui::State::default(); + forge_state.page = match args + .iter() + .position(|a| a == "--page") + .map(|i| args[i + 1].as_str()) + { + Some("temper") => forge_core::Stage::Temper, + Some("knurl") => forge_core::Stage::Knurl, + _ => forge_core::Stage::Lathe, + }; + if forge { + // An F1 saw bass through Knurl's Fry pattern first: Lathe after it still follows F1. + let mut engine = forge_core::Engine::new(48000., 2).unwrap(); + engine.set_settings(forge_settings).unwrap(); + let mut saw = common_dsp::Saw::new(48000., 43.65); + for i in 0..36000 { + let x = (saw.sample() * 2.2).tanh() * 0.5; + engine.process_sample([x, x]); + if i % 1600 == 0 { + forge_state.accept_frame(engine.take_analyzer()); + } + } + forge_state.accept_frame(engine.take_analyzer()); + } let mut planish_settings = planish_core::Settings { depth: 80., gains: [0., 2., 3., -2.], @@ -416,7 +452,9 @@ fn main() { let session_motif = session.motifs[0].id; shared.replace(session).unwrap(); let ctx = egui::Context::default(); - if ballast { + if forge { + forge_ui::style(&ctx); + } else if ballast { ballast_ui::style(&ctx); } else if quench { quench_ui::style(&ctx); @@ -461,7 +499,9 @@ fn main() { }, |ui| { egui::CentralPanel::default().show(ui, |ui| { - if ballast { + if forge { + forge_ui::show(ui, &mut forge_settings, &mut forge_state); + } else if ballast { ballast_ui::show(ui, &mut ballast_settings, &mut ballast_state); } else if quench { quench_ui::show(ui, &mut quench_settings, &mut quench_state); diff --git a/website/src/data/plugins.ts b/website/src/data/plugins.ts index e168e0c..5053a59 100644 --- a/website/src/data/plugins.ts +++ b/website/src/data/plugins.ts @@ -229,6 +229,21 @@ const COPY: Record = { latency: '≈ 172 ms', tracksNotes: true, }, + forge: { + role: 'Tracked channel strip', + metal: 'A forge is the hearth where every piece is heated and worked.', + problem: + 'Lathe, Temper and Knurl in a row each run their own tracker: the lookaheads add up to over 200 ms, and a tracker after Knurl hears its sub-octave and follows the wrong note.', + points: [ + 'One note tracker reads the input; Lathe, Temper and Knurl follow it as modules.', + 'Any order, each module on or off, one latency of about 72 ms.', + 'Every module sounds exactly like its standalone plugin.', + 'The module pages are the standalone editors.', + ], + loadOn: 'Bass, after the synth', + latency: '≈ 72 ms', + tracksNotes: true, + }, }; export interface Plugin extends Copy { @@ -273,11 +288,6 @@ export const PLUGINS: Plugin[] = Object.entries(catalog).map(([slug, entry]) => /** Ideas from docs/ideas.md that are not built yet. */ export const IDEAS: { name: string; role: string; text: string; texture?: boolean }[] = [ - { - name: 'Ballast', - role: 'Switch-up loudness leveller', - text: 'Measures perceived loudness per switch-up and sets gain only, so every patch lands at the same loudness without compression.', - }, { name: 'Gauge', role: 'Low-end mono check',