mirror of
https://github.com/storytold/soundcraft.git
synced 2026-11-19 16:45:09 +00:00
main
77
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
0acf57228b |
Import external-WAV AAF as editable session data (pure Rust) (#799)
* Import external-WAV AAF as editable session data File > Import > Session Data analyzes an AAF and imports the selected audio tracks as new tracks, one clip per edit. Clips keep their offset into the complete source, so handles stay available; the import is one undo step and Save collects the full sources. crates/interchange (layer 3, no filesystem/process/UI access): - build_session(Plan): versioned rational-time plan -> Session. Endpoints are rounded to samples independently, so adjacent edits never drift. - aaf::read_aaf: reads the AAF object model from structured storage with the cfb crate (MIT): properties streams, strong reference vectors/sets and dictionary weak references. Media goes through a MediaResolver trait. crates/engine: file.preview_aaf (read-only) and file.import_aaf (undoable). The resolver opens only files named in the chosen media folder, checks file_access and reads WAV headers without loading samples; import re-probes and decodes before touching the session. crates/ui-egui: Session Data window with track selection, media folder, absolute/relative mapping, sample offset and report. Supported: SourceClip/Filler sequences resolved through MasterMobs to WAVEDescriptor SourceMobs with one external locator; mono/stereo PCM WAV; composition timecode including 24000/1001 and drop-frame. Gain, fades, transitions, selectors, nested sequences, embedded essence, split channels, mixed sample rates and non-local locators fail explicitly. Addresses #40. * AAF import: resolve each source once, offer composition choice, start folder picker - file_source returns early for a known source, so each WAV is probed and each relink is reported once however many edits use it. The per-slot PhysicalTrackNumber check still runs first. - When an AAF holds several compositions, the Session Data window lists them and passes the chosen MobID to file.preview_aaf. - "Choose media folder..." opens at the current media folder instead of receiving a label as its start path. * AAF import: lock the composition selector while analysis runs A selection change during analysis could leave a plan for the previous composition in the window and enable Import with it. * AAF import: drop a running analysis when the file or media folder changes window.import_aaf (and opening an .aaf) can set a new path while the previous file is still being analyzed; its late plan could then be shown and imported for the new path. * AAF import: forget the chosen composition when the path is edited * AAF import: keep the media folder with a typed AAF path A typed path now moves a media folder that was derived from the previous AAF, so same-named WAVs are not taken from the old folder. A folder the user chose elsewhere is kept. * AAF import: bound hostile input, confine locators, report missing media Review follow-up for the AAF reader (untrusted input): - Cap the structured-storage directory at MAX_DIRECTORY_ENTRIES on open; document every bound (sector chains via cfb, 32 MiB streams, MAX_ITEMS collections, 32-link source chains with cycle detection). - Locators are data: refuse `..` anywhere (also percent-encoded and inside absolute paths), NUL bytes, paths that name no file, and relative locators with a root or drive prefix; relative ones stay under the AAF's folder. - A missing media file no longer aborts the import: it is reported with the number of edits skipped, the other edits keep their positions, and the import fails only when no referenced file exists. - Tests: looped directory, mini-FAT and mini-stream chains terminate with an error; locators patched into the fixture cannot leave the AAF folder; an absolute locator is only looked up in the chosen media folder; missing media is reported per file. - Provenance statement in the module docs and README. * AAF import: confine the plan's media to the media folder at import too file.import_aaf takes the plan from its caller (UI, MCP, automation), so the media-folder rule applied while analysing is checked again before any source is read: the import requires `media_dir`, and every source must be a file directly inside it once both paths are canonical (symlinks resolved). The UI passes the folder it analysed with. Test: a plan edited to point outside the folder (absolute path, `..` traversal, symlink) or without `media_dir` is refused without an edit. * AAF reader: decode UTF-16 with as_chunks for clippy 1.99 clippy::chunks_exact_to_as_chunks (Rust 1.99, used by the gate) rejects chunks_exact(2) with a constant size. as_chunks is stable since 1.88, below the workspace minimum. * AAF reader: state its provenance accurately The storage layout, class and property identifiers and MobID text form were learned by reading pyaaf2 (MIT), not from the published AAF specifications. No pyaaf2, AAF SDK or copyleft code was copied. * aaf: bound property expansion Cache parsed objects and share property payloads. Enforce a 128 MiB aggregate property budget and reject duplicate local references before expansion, with a compact AAF regression. Migrate AAF media handling to craft-audio after integrating current main. * docs: record strict AAF import support |
||
|
|
a02d892f83 |
MIDI input devices: live play-through and MIDI recording (#493)
* MIDI input devices: live play-through and MIDI recording Keyboards and pads could not be used at all: there was no MIDI device layer (G-02). - crates/playback/src/midi.rs opens every MIDI input port through midir (ALSA sequencer, CoreMIDI, WinMM), follows devices that are plugged in or removed, and passes channel messages to the audio thread over a lock-free ring, each with the time it arrived. - The mix engine plays them on the instruments of record-enabled and input-monitored MIDI and instrument tracks (crates/mix/src/live_midi.rs): notes at their sample offset, the sustain pedal holding note-offs back. - While recording, the events are kept with their timeline position and become MIDI clips on the record-enabled tracks (crates/engine/src/io/midi_take.rs), with controllers, pitch bend and aftertouch. A pass can be MIDI only: the audio input is opened for audio tracks alone. - A MIDI or instrument track chooses a device and a channel at its input selector (kept in the track's input route as `MIDI:<channel>:<device>`). - Setup > Playback Engine lists the input ports with a switch each and, on request, what arrives from one; Setup > MIDI > MIDI Input Devices opens it. The switches are app preferences. Note lifecycle: - A strip keeps the keys and the sustain pedal of every owner (input port and channel) apart. A pitch held by two devices or channels sounds until the last one releases it, and one owner's pedal does not hold another's notes. A strip follows 16 owners at a time; further ones share the last place (documented in live_midi.rs). - A full queue is never silent. An event that does not reach the audio thread (the 1,024-entry input ring or the 256 events a callback takes) marks its port; the audio thread then drops what it still has queued from that port and the engine releases the notes and pedal the port holds. A port that closes, a replaced feed and events skipped while nothing listens take the same path. - A take records where input was dropped: the notes that port held end there, and the status line says the take is incomplete. Recorded events the UI thread did not collect in time are counted and reported too. Recorded notes are told apart by device as well as channel and pitch. On Linux, live play was checked with a hardware keyboard (Akai MPK mini 3) and recording with a virtual one (crates/playback/examples/midi_keys.rs), before the note-lifecycle work; that part is covered by tests only. macOS and Windows are type-checked only; there is no MIDI input on FreeBSD or the web. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * midi real device tests * midi device drop test * midi device fix pr review comments * MIDI input: review fixes for note ownership, lost input and takes Live notes (crates/mix/src/live_midi.rs): - An owner without a place of its own joins the shared place while it is in use, even when another place has come free. It could get a second place before, and the release of its key in the shared place was then not found: the note stayed on. The same held for the pedal. - A change of the track's input releases the shared place when the input no longer takes any one of the owners in it, not only the first. - The strip remembers which port and channel last set each controller. When that source loses its input or the track stops listening to it, the instrument's controllers are set again from the clips and from the sources that are left, so a bend from an unplugged device does not stay. - When playback runs out under monitoring, the clips' sustain pedal goes up with their notes. Capture (crates/playback): - A loss carries its time. What a port sends after it is played and comes after the mark in the take; before, it was dropped and recorded ahead of the mark. - The age of an event is counted at the transport speed. - Loop recording writes a mark where the loop goes round, and a key played with the playhead at the end of the loop stays inside the loop. - The end of a record pass is acknowledged by its number, so the late answer to an earlier pass does not end the wait for a later one. - A connection the backend closes marks its port, also when a device with the same name is opened in its place. Takes (crates/engine/src/io/midi_take.rs, crates/ui-egui): - A note held into the next round of a loop is split there, also when its release is later on the timeline than its press. - A track taken out of record during a pass keeps what it recorded. - A pass whose end the audio engine did not confirm is reported as incomplete in the status line. - An inactive record-enabled audio track no longer turns a MIDI pass into an audio one that is then refused. docs/midi-input.md: Windows drivers that allow one program per device, and the new status text. * MIDI input: review follow-ups on loss order, controllers and loop takes - Each port has its own time of loss. One port's later loss no longer takes along what another port sent after its own: that is played, and comes after that port's mark in the take. - A retired connection is closed before its port is marked as lost. Marked first, a note-on delivered while it closed carried a later time than the loss and could be played after the release. - The strip keeps the last controller value of every source, not only the newest. When one of two sources that set the same controller goes away, the controller goes back to the value of the one that stays. 64 values are kept; past that the oldest is forgotten. - A take can say where the pass stopped (MidiTakeEvent::END), and the UI says so for loop passes. A key still down then ends at the stop in the round it is in: held over a round or more it covers the loop, where it used to end at the loop end of its first round. - A pass that records MIDI does not start while the audio engine has not confirmed the end of the previous one. It takes the MIDI since its last callback with the state of the pass it knows, so a pass started and stopped meanwhile had its notes written at the old position. * MIDI input: loss marks in the queue, connection gate, stop position - A loss from a full queue is also written into the queue, ahead of the first event that fits again. The audio thread deals with it at that place. Before, a loss flagged after the callback had read the flags was seen one callback late and ended a note played after it. The flag for a loss already met in the queue is not a second loss. - A connection is shut off under the feed's lock when it is closed (MidiFeed::close_port), and what its device thread still delivers is discarded. Dropping a connection joins that thread on ALSA; CoreMIDI (MIDIPortDispose) and WinMM (midiInStop, midiInReset, midiInClose) do not promise to, so the order of drop and mark is no longer relied on. - When the controller table is full and forgets a value, the strip keeps the port and channel it came from. The controllers are still reset when that source goes away, where a bend pushed out of the table used to stay. - A loop pass ends where the audio engine is. The larger of the engine's and the UI's position was used, and just after the loop went round the UI's is still near the loop end: a short held note covered the loop. - The end of a pass waits for the audio engine by what the pass set out to record, not by the devices connected at Stop. A pass whose last device was unplugged before Stop left nothing pending, and a new pass could start before the engine was done with it. * MIDI input: stop at the loop end, and passes owed by the audio engine - A key played while the playhead stands at the end of the loop is the last thing of that round. It was written as the first of the next round, with a mark that the loop had gone round; a pass stopped right there never went round, and a note held to the stop grew a second part. - The feed knows whether an ended pass is still owed by the audio engine (MidiFeed::pass_owed), and the UI asks it before a pass that records MIDI starts. The UI kept that itself, where no test could stall the audio callback against it. * MIDI input: stop boundary, loop rounds, loss marks and shared owners - A pass ends at a time on the feed's clock (MidiFeed::end_pass). Only what arrived up to it is written to the take, however late the audio thread hears of the Stop, and the callback takes the queue in once more after the command before it confirms: a note that arrived between its reading the queue and the Stop was missing from a confirmed take. - The confirmation carries where the playhead stood (MidiFeed::stopped_at). A loop pass ends there; the player's position read afterwards could be a round further on, which the take knows nothing about. Without a confirmation no stop position is used. - The take builder is told whether the pass looped (MidiPass). In a pass that did not, a release stamped before its key press (a late callback) is one short note, where it was split around the ends of the clip. The stop position is a parameter, not an entry that the event cap could cut. - A pass records the tracks that were in record when it started, and only those: the same list the end of the pass waits by. A track put in record during the pass got what was played before that, without a wait. - A short loop goes round several times in a callback: each entry is put in the round it arrived in, so two entries a round apart have one mark between them. - A mark in the queue is stamped with the time of its loss. A port that overflowed, played on and was then closed keeps a mark for the close (the new note was held to the end of the take), and a loss told by the port's flag is not written again when its mark arrives. - Live events stay in order of arrival when they are played: a release taken by a shorter callback was due before its note-on. - A callback reads the transport speed once, for rendering and for the ages of the next callback's events. - The shared owner place is left alone by a source that never joined it: its note-off no longer ends another owner's note there, and its loss no longer releases the place. - When a live source goes away, the instrument's controllers are restored before the block's clip events are sent, so a clip controller at the start of that block keeps its new value. - Tests that assert MIDI positions use a clock the test sets. * MIDI input: pass boundaries, loop punch-in and review follow-ups - A pass begun while the transport runs has a start time on the feed (MidiFeed::begin_pass): what is played after Record is written down also when the audio thread takes it in before it reads the command. - A pass goes on through a transport stop until the command that ends it. The UI sends the two one after the other; when they reached two callbacks, a note played just before the stop was left out of a confirmed take. - The end of a pass is asked for every entry, so a Stop that comes while the queue is being read still cuts off what follows it. - A mark in the queue carries the time its events were dropped, kept apart from a later close of the port. An overflow before Stop is in the take when the port closes after it. - A pass punched in while a loop plays is a loop take over that loop. In a line from the punch-in to a stop in the next round nothing fell inside the range. - In a loop take with marks, only the marks say that the loop went round: a release stamped before its press within one round is one short note. - A key pressed in the last samples of the range starts at the last tick the clip plays, not at the tick of its end. - When the clips' controllers are sent again while stopped, their sustain pedal goes up again: no pedal-up of theirs would follow. - The render step is taken after the commands, so a session at another sample rate is rendered at that rate from the callback that installs it. - The stop position and the incomplete-take warning go by one answer from the audio engine. * MIDI input: test that a callback renders at the speed it keeps A speed change that arrives while a callback runs takes effect from the next one: the callback renders at the speed it read, and the next callback counts the ages of its events at that same speed. * MIDI input: volume and pan go back to MIDI's defaults with their device The reset sent when a live source goes away is Reset All Controllers, which leaves the channel volume (CC 7) and the pan (CC 10) alone. A device that turned the volume down to nothing and was unplugged left the track silent. When the source that went away had set one of the two, and neither the clips nor a source that is still there gives it a value, the instrument is sent the value MIDI names as the default (100, and 64). The same when the track stops playing live input. * MIDI input: third round of review follow-ups - The stop cutoff is one value on the feed, in force from the store that ends the pass and gone when the audio thread confirms it. - The start of a pass holds for the whole pass: what was played before Record stays out also when it is taken in after the start command. - What is played just before a Stop is put inside the range that ends at the stop, not on its end. - A port closed while the queue is read is met through the mark of its overflow; the flag of that close, a callback later, is not a second loss (it ended a key the new connection played). - An overflow and the loss it is have one time. Read apart, they could differ by a microsecond and count as two losses. - A volume or pan the full controller table forgot goes back to its default when its own device goes, not when another does. - The chase of the clips' controllers uses the track's MIDI delay, as playing them does. - Recorded controllers in the last samples of the range stay where the clip plays; in a take without marks the press as played, not the note's start, says whether the loop went round; a take cut at the event cap does not use the stop position. - The loop the MIDI of a punched-in pass goes to is the loop the audio engine plays: not a range too short to loop, nor one that Play From dropped. - The audio input stops taking in before the wait for the MIDI. * MIDI input: fourth round of review follow-ups - A record pass goes on through the natural end of playback until the UI ends it, up to the time playback ran out: what was played as it reached the end is in the take, what follows is not. - Before the end of a pass is confirmed, the device threads are kept out of the queue while it is read once more, so a message stamped before the Stop is not put in after the answer. The audio thread does not wait for a device thread that is in there. - A later loss of a port is noted as dealt with only at the end of the callback: with two overflow marks of one port in the queue, the second was skipped and the key played between them had no end. - Whether a pass was begun is read before when: a pass seen as begun has its own start time. - The volume and the pan go back to their defaults when the source that set them last goes, also when the controller table forgot its value, and not when an earlier setter goes. - A clip's note-off that is held back because a live key holds the pitch is remembered for the block: the key going up earlier in the block no longer ends the note before the clip would have. - In a take without marks, whether the loop went round between a press and its release is judged by their samples, not their ticks. - The stop position of a loop pass is not used when recorded entries did not reach the take: one may be the mark of a round. - Loop recording over a selection too short to loop is recorded as a punch, as the transport plays it. * MIDI input: fifth round of review follow-ups - Whether a pass was begun is asked for every event: a pass begun while the callback is reading the queue records from when it began. - The ages of a pass's last events are counted up to when the transport stopped. Counted up to the callback that takes them in, the time the playhead stood still moved them back. - An overflow the port's flag told of keeps its time when an older mark in the queue shows a later close: its own mark may never come. - What becomes of the clips' held back note-offs is settled after the block's live events. A key that goes down again before the clip's note would have ended is not ended by it, and with two clip notes of a pitch in a block the one that sounds when the key goes up lasts to its end. - When the source that set the volume or the pan last goes and another one's value is sent again, that one is the last setter from then on. * MIDI input: sixth round of review follow-ups - A loss is followed whenever the transport runs, and written to the take by when it happened, like an event: a port lost in a pass that began while the queue was being read ends its notes in the take. - A pass started and ended by the commands of one callback is still that pass in the last read of the queue: what was played in it is kept. - When a live key takes a pitch again, the clips' held back note-offs from since the last key went up are sent where they were, so the instrument lets go of the clip's note before the new press. --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com> |
||
|
|
19acf6f21a | chore(score): pin writers to merged shared revision | ||
|
|
9676d492db | refactor(score): use shared MusicXML and SVG writers with contributor tie fixes (#1598) | ||
|
|
d0479e609c | video: pin craft-video to craft-libs main ddbe7823 (Adobe APP14 transform fix, craft-libs#1847) | ||
|
|
fc4dddd7c7 |
video: decode Motion JPEG with craft-video's shared mjpeg codec
Movie frames from MJPEG tracks were decoded with the image crate's JPEG decoder, and the synthetic MJPEG fixtures were encoded with its encoder. Both now go through craft_video::mjpeg (storytold/craft-libs#1757), a frame-level wrapper over craft-jpeg. The picture size is still checked from the header against MAX_PIXELS before any pixel is decoded, and grey and 12-bit pictures map to RGBA8. soundcraft-video no longer depends on the image crate. craft-video is pinned at craft-libs main 341020b2 with the mjpeg feature. Refs storytold/craft-libs#778, storytold/craft-libs#781. |
||
|
|
559c2b9fc2 | Merge main into extract/shared-score-xml | ||
|
|
498849745a | Reuse shared Base64 for control responses | ||
|
|
4bdda5ffad | Reuse shared XML escaping for score exports | ||
|
|
2688ccac88 |
io: import a MIDI file with stray bytes after its last track (#1528) (#1540)
* io: import a MIDI file with stray bytes after its last track (#1528) Importing a MIDI file read it with craft-midi's strict read_smf, which refuses any damage. The file in #1528 is whole, its one track ending with End of Track at its declared length, but two line feeds follow it. The strict reader took them for the start of another chunk and refused the file with "unexpected end of data at byte 45281". Read imported files with read_smf_lenient instead, as other MIDI readers do: it reads a sound file exactly as read_smf does, ignores bytes after the last chunk, and keeps what makes sense of a damaged track, bounded by the same event and track limits. Its warnings are logged. Something that is not a Standard MIDI File is still refused, and the file is still read in full before the session changes (#911). Test: a complete file followed by two line feeds imports its note; it failed with the issue's error before. * io: a MIDI file past the reader's limits stays refused (#1528) Read leniently, a file with more events or tracks than craft-midi reads kept what came before the limit and left the rest out with only a log warning, where the strict reader refused it. Import now reads a file strictly first: a sound file reads as before, a file past the event or track limit is refused as before, and only other damage (stray bytes after the last track) falls back to the lenient reader. Test: a file one track past the limit, its last track holding a note and stray bytes after it, is refused and leaves the session empty. * io: refuse a MIDI file past the event limit after a damaged track (#1528) The strict reader stops at the first damage. When a damaged track came before the one that goes past MAX_EVENTS, the strict error was not a limit error, the import fell back to the lenient read, and that read kept what came before the limit and left the rest out with a warning: the file was imported cut short. The lenient read now says when a limit left part of the file out (LenientRead::over_limit, storytold/craft-libs#1308), and the import refuses such a file before the session changes, warnings full or not. The six craft-libs crates pinned at 6a86adb move together to that PR's commit, as craft-scraft-format uses craft-midi's and craft-audio's types. They move to its merge commit once it merges. * deps: keep only the craft-libs source changes in Cargo.lock (#1528) Moving the craft-libs pins also re-resolved several windows-sys edges (0.61.2 to 0.52.0) and tempfile's getrandom edge (0.4.3 to 0.3.4). Restore main's resolution for those, so the lockfile only changes the source of the craft-libs crates. * deps: pin craft-libs to the merge of craft-libs#1308 (#1528) Move the six craft-libs crates from the PR's commit 4db60c4 to its merge into craft-libs main, 45a8e16. None of these crates, nor craft-zip which craft-scraft-format uses, changed between the two. |
||
|
|
ff66d48326 | chore: pin shared session format to merged release | ||
|
|
48ea8ecfe4 |
Merge remote-tracking branch 'origin/main' into codex/soundcraft-session-format
# Conflicts: # Cargo.lock # Cargo.toml |
||
|
|
2aa2f66fd3 | pin SoundCraft format to merged shared release | ||
|
|
869db7dc6a | Pin shared video codecs to merged revision | ||
|
|
ff9c9114f0 | pin SoundCraft time to shared consolidation | ||
|
|
acb547286d | Move SoundCraft session format into craft-libs | ||
|
|
935505bb07 | Move SoundCraft H.264 and ProRes codecs to craft-libs | ||
|
|
6a0949d9d0 |
Review fixes after the craft-audio switch; MIDI files from craft-midi (#1513)
* Review fixes after the craft-audio switch; pin craft-audio at craft-libs main Follow-up to #1506, for its review comments: - convert: a decode that concealed damaged packets is reported as a warning, and --in-place refuses to replace the source with it. - convert: the decoded speaker layout goes to the encoder, so 5.1 with side surrounds stays side surrounds in WAV and FLAC. - FileFormat::of names an MP4 or QuickTime file by its codec: AAC or HE-AAC is Aac, ALAC is Alac, anything else (Opus, AC-3, PCM) is Other. - Bounce keeps a picked extension that already names the format (Mix.aifc, Mix.AIFF), so the file written is the one the save dialog confirmed. - rust-version is 1.95: craft-audio, craft-media and craft-ui declare it, so 1.90 was not a version the workspace builds with. craft-audio and craft-media move to craft-libs main 7db4645d. * MIDI: take Standard MIDI Files and the sequence model from craft-midi craft-midi in craft-libs was moved from this crate (storytold/craft-libs#884): smf.rs, sequence.rs, the error type and their tests. soundcraft-midi now re-exports them, so every caller keeps its imports, and keeps what is SoundCraft's own: the editing operations, the display names and XorShift. The SMF and Sequence tests are deleted here; they run in craft-midi, which also adds one for the track limit. The serde names do not change (the same derives behind craft-midi's serde feature), so sessions read as before. |
||
|
|
4782cfa600 | chore: bump to 0.20.1 for the Flatpak updater patch release (#1512) | ||
|
|
91952090ec |
Take audio file formats from craft-audio; remove crates/audio-io (#1506)
craft-audio in craft-libs was built from audio-io and FilmCraft's codecs, so each format has one implementation that every Craft app shares. Call sites use its API directly: EncodeOptions::new(format).with_*(), EncodeFormat, DECODE_EXTENSIONS, ENCODE_EXTENSIONS, encode_format_for, AudioInfo's container, codec and layout. soundcraft_model::FileFormat stays as the kind of file a session records for each source: its variant names are part of the session format. It maps from craft-audio's AudioInfo. craft-audio and craft-media are pinned to the craft-libs branch of storytold/craft-libs#824, which adds the extension tables SoundCraft had in FileFormat and fixes the quadratic WAV chunk scan (#893). Behaviour that changes: AAC, ALAC, Opus, AC-3/E-AC-3 and MP2 decode with craft-audio's own decoders; MP4 and Matroska tracks import at their presentation length; .opus, .ac3, .eac3, .ec3, .mov, .mka and .mpa are importable names; .aifc is a writable name; FLAC files come from craft-audio's encoder. |
||
|
|
55c89b364d |
Release: SoundCraft v0.20.0 on main (#1511)
Co-authored-by: FredApps <FredApps@users.noreply.github.com> |
||
|
|
60f97a99a5 | chore: bump version to 0.19.1 for the Flatpak update fix (#1507) | ||
|
|
17649aa693 | Updates: take craft-update from craft-libs main at 6e03f65bf | ||
|
|
c4c09ca789 | Updates: take craft-update from craft-libs main at 1b34eba41 | ||
|
|
20338e0832 |
Updates: the updater reports installing, ready, installed and failed, and installs at exit
Moves the craft-libs crates (craft-update, craft-docpath, craft-media, craft-ui) from c5a1cbfb5f to a branch that merges storytold/craft-libs #687 and #696. - The result dialog shows whenever the updater reports a status, so the first start after an update says whether it installed or failed. Closing it dismisses the status; the startup prompt still takes over. - Restart to Update in the dialog asks the app to close through the usual close path. - on_exit starts the helper of a ready update, since the system Quit ends the process before the updater is dropped. |
||
|
|
1db9563379 |
fix(ui): About credits tables fit without side-scrolling and their columns resize (#1342)
* fix(ui): About credits tables fit without side-scrolling and their columns resize The Contributors table and the Models table were egui Grids inside a two-way scroll area: they opened wider than the dialog, so they scrolled sideways, and Company and Model sat almost touching. Both are now egui_extras tables. Each column opens at the width of its header and widest cell, the spare width goes to the text columns (Name; Company and Model), and every column edge can be dragged. Widening a column grows the table like a spreadsheet, and only then does it scroll sideways; the header stays put while the rows scroll. Counts and dates are right-aligned and every cell is vertically centred. The sorted column stays highlighted and its direction shows on the toolbar's sort-order button, so headers no longer reserve room for an arrow. The opening widths come from fit_widths, a pure function with unit tests that a fitted table fills its room exactly and that only the text columns give way when room is short. The About dialog opens 820 points wide, so every column fits at its natural width. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Let every credits column be dragged, and refit changed tables The last column was egui's remainder column, which has no drag handle, so it could only be resized from the edge before it. It is now an ordinary column with its own handle. A table keeps its column widths, so switching to a longer name left the Name column at its old width and clipped the text. The table now goes back to the opening fit whenever that fit changes: a longer widest cell or a resized window. Dragged widths are dropped at that point. fit_widths could overflow the room when one column hit the minimum, because the other columns did not take up its share. Columns now give way in proportion to their width above the minimum. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Refit credits tables on what they measure, not the fitted widths Comparing the fitted widths missed the case it was meant for. Name is the only growing column, so a longer name takes its extra width from the spare room and the fit comes out the same: a dragged Name width stayed, clipping the longer name. It could also drop dragged widths by accident. The fit comes from the available width inside the scroll area, which scrolling can nudge, so scrolling a widened table could reset it. The table now compares the natural widths and the clip rect's width, which scrolling does not move. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
b35dd0f9eb |
Release 0.17.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
db51dd1739 |
Release 0.16.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
4c31f2884b | updates: show check results with craft-update's CheckResultDialog | ||
|
|
a97ce7556c |
Release 0.15.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
7902d59b47 | UPD.1: honor app pretend versions in update checks (#1199) | ||
|
|
92e74f6e00 |
Update prompt shows the app icon and accent color instead of a letter (#1198)
UPDATE_APP (native builds; craft-update is a native-only dependency) carries our 128 px icon and accent (#1fa5c9, its colour in ArtCraft Launcher). The updater, the self-update helper and craft-update's startup prompt all get them through crate::UPDATE_APP; the prompt draws the icon, the accent and "by ArtCraft" (craft-update's default developer). craft-update is pinned to storytold/craft-libs main at 1065653e7 (#434). |
||
|
|
c6befe57af |
Release 0.14.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
9f2be37e36 |
Enforce Rust coding standards via Clippy (#1129)
* chore(lints): apply strict workspace Clippy rules * refactor(h264): split decoding work by operation * refactor(h264): clarify prediction and filter inputs * docs: require workspace lint inheritance * refactor(audio): clarify host FFI imports and inputs * docs: clarify crate lint placement * refactor(audio): replace wildcard imports in I/O modules * refactor(mix): extract strip and routing stages * refactor(ui): split edit window event handlers * refactor(ui): clarify app and dialog actions * refactor(ui): simplify mixer and panel workflows * fix(ui): apply track resize only once |
||
|
|
e82c1689b3 |
refactor(cli): parse soundcraft-cli arguments with clap, following RFC-0012 (#1136)
* test(cli): pin today's argument handling
Run the real binary and record how the hand-written parser behaves for every
subcommand: help and version spellings, no arguments, unknown subcommands and
flags, value flags in both spellings, missing and repeated values, positional
order, exit codes and which stream carries each message.
No behaviour change. Later parser changes update these assertions on purpose.
* refactor(cli): split main.rs into modules
Move only: args, error, output, convert, info, session, catalog, app and
mcp each get their functions and unit tests; main.rs keeps the usage doc,
help_text and the dispatch. Moved items become pub(crate) where other
modules call them. No behaviour change.
* refactor(cli): typed errors and run(args, out, err)
soundcraft-cli is now a library plus a thin binary. `soundcraft_cli::run(args,
out, err) -> i32` is the whole program; main.rs only passes the real streams
and shuts the plugin hosts down afterwards (process teardown, not part of run,
which tests call repeatedly in one process). Subcommands write to the given
writers, return `Result<(), CliError>`, and `fail` is gone. CliError wraps
engine, audio-io, io (with the path), serde_json and the control channel
errors; UsageError, ConvertError and RootFlagError cover the subcommands' own
failures. No Result<_, String> is left except where a dependency reports a
string (control-channel call, AutomationRoots::new), wrapped in a variant.
The tests that need no files, working directory, environment or stdin now call
`run` in-process (tests/it/run.rs); the rest still run the binary.
Behaviour changes:
- Error messages start with `error: ` instead of `soundcraft-cli: `.
- A script line that stops the run now prints `error: FILE:N: ID: ...` (it had
no prefix). With --keep-going the line stays bare.
- A convert encode or write failure now names the output path.
- An empty or help-less call still prints the one-line usage to stderr without
a prefix and exits 1; `files confined:` keeps its `soundcraft-cli:` prefix
(it is a note, not an error).
* refactor(cli): parse arguments with clap
Replace the hand parser (arg_value, check_options, ENGINE_OPTIONS, the
lib.rs dispatch, the per-subcommand positional handling and the root
flags' consume) with clap derive types in args.rs: a Parser, a
Subcommand enum and one Args struct per subcommand, with the run/script
engine flags flattened. main passes args_os(); run takes OsString-like
arguments and renders clap's help, version and usage errors (help and
version on stdout, exit 0; usage errors on stderr, exit 2). Add
command() returning the clap definition. The usage block in the module
doc and help_text are gone: the doc comments are the help.
Behaviour changes:
- Usage errors exit 2 with clap's message and the --help hint on
stderr, instead of exit 1 with hand-written text: unknown subcommand,
unknown flag, missing value, missing or extra positional, a value on
a boolean flag (--demo=1, --normalize=1).
- No arguments prints the help to stderr, exit 2 (was a one-line usage,
exit 1).
- --help, -h and help print clap's generated help, and every subcommand
has its own (SUB --help, SUB -h, help SUB). Before, info and script
read --help as a file name, describe as an id, commands as a filter,
run rejected --help and ignored -h, convert and app printed their
usage error, mcp, parity and plugins ignored it, and app --port P -h
called the method -h.
- --help or -h before -- shows the subcommand's help even after a
mistake on the same line (run --bounce --help).
- --version, -V and version print "soundcraft-cli X.Y.Z" (was
"SoundCraft CLI X.Y.Z").
- Unknown flags on info, commands, describe, app, mcp, parity and
plugins are usage errors; they were ignored or read as a positional.
mcp --automation-bogus exits 2 (was exit 1).
- Extra positionals are usage errors on every subcommand (were ignored).
- A single-dash word (-x) is a flag, so an unknown one is a usage
error; a value starting with - is written --flag=-value.
- Flags may come before or between the positionals: convert IN --rate
44100 OUT, convert --rate 44100 IN OUT and script --keep-going FILE
parse (the flag word was taken as a file name).
- A repeated single-value flag keeps its last value (was the first):
--rate, --bit-depth, --save, --port and the others.
- parity --write without a value is a usage error (printed the report).
- mcp --connect without a value, or followed by a flag, is a usage
error (was exit 1, or took the flag as the port).
- mcp --demo=1 is a usage error (was ignored, without the demo).
- A root flag without a folder, with an empty one, or followed by a
flag is a usage error with clap's message (was exit 1).
- A non-Unicode argument is a usage error where text is expected and
accepted as a root folder (std::env::args panicked).
- The help lists --sample as --demo's alias.
Unchanged: --dither with --no-dither, bad --rate and --bit-depth values,
the roots with --connect and the SOUNDCRAFT_CONTROL_PORT fallback are
still checked after parsing (exit 1).
* refactor(cli): reject repeated flags, clap --version (photocraft#7071 decisions)
Behaviour changes:
- A flag given twice is a usage error (exit 2), in either spelling, including
an alias pair such as --demo and --sample. Before, the last one won. Only
run's --cmd and mcp's --automation-read-root / --automation-write-root
repeat; they accumulate in order.
- --version and -V print the long version, "soundcraft-cli 0.13.1 (linux
x86_64)": the version and the platform the binary was built for.
- The hidden `version` subcommand is gone; `soundcraft-cli version` is an
unrecognized-subcommand usage error.
- --start and --end accept a negative number (`--start -1`, as the engine
counts positions before 0); any other value starting with `-` needs `=`
and otherwise is an unexpected-argument usage error. No flag has
allow_hyphen_values.
- `help <subcommand>` is unchanged (tested).
* refactor(cli): typed values and flag relations
Handlers receive typed values: convert --bit-depth is a ValueEnum, --rate a
NonZeroU32, file arguments PathBuf, --start/--end a TimeArg, --cmd a parsed
(id, JSON) spec, app's JSON a serde_json::Value, app --port and mcp --connect
a validated port or host:port. Relations (--dither/--no-dither, --in/--demo,
--start/--end needing --bounce) are declared on the flags. describe ID,
commands FILTER and app METHOD refuse an empty string. parse_rate,
parse_bit_depth, parse_dither, parse_cmd_spec, time_arg and the Rate,
BitDepth, DitherConflict and CmdJson errors are gone.
Behaviour changes:
- --dither with --no-dither is a usage error (exit 2) instead of exit 1.
- --rate 0 / non-numeric and an unknown --bit-depth are usage errors (exit 2)
with clap's wording, naming the flag. --bit-depth help lists the values.
- --in with --demo (or --sample) is a usage error; --in used to win silently.
- --start/--end without --bounce are a usage error; they used to be ignored.
- Malformed JSON in --cmd ID=JSON and in app's JSON argument is a usage error
(exit 2) at parse time. Before, run opened the engine and executed every
earlier --cmd (printing their results) before the bad one failed with exit 1.
- An empty --start/--end, an empty command id (--cmd =1), and an empty
describe ID, commands FILTER or app METHOD are usage errors. An empty
commands FILTER used to list everything.
- app --port and mcp --connect accept only a port (0-65535) or host:port;
junk used to be accepted and failed at connect time (exit 1).
- Non-Unicode file names are accepted wherever the callee takes a Path (info
audio files, convert, script, parity --write). Session and bounce/save paths
go to the engine as text, so a non-Unicode one fails with exit 1, "the path
is not valid Unicode", after any earlier --cmd ran.
* refactor(cli): shared launch flags and SOUNDCRAFT_CONTROL_PORT as clap env
soundcraft_automation::args holds the launch flags as clap Args structs:
ControlClientArgs (`app --port`, env SOUNDCRAFT_CONTROL_PORT, default
7979), ControlServerArgs (the desktop `--control`, same variable, wired
in a later step; its ControlPort value is a port, also from a loopback
host:port, or another host's host:port, which the app decides on, so one
export serves both), AutomationArgs (the two root flags, repeatable, flags
only), the ControlTarget value parser, and the blank_env_is_unset,
name_env_vars and conflict helpers. The module and its clap/thiserror
dependencies are left out of the wasm build. `app` and `mcp` flatten
them; the hand fallback to the variable in `app` is gone.
Behaviour changes:
- An empty or blank SOUNDCRAFT_CONTROL_PORT counts as unset, so `app`
uses 7979; before, it tried to connect to `127.0.0.1:` (exit 1).
- A bad SOUNDCRAFT_CONTROL_PORT is a usage error naming the variable
(exit 2); before, the connection failed (exit 1).
- Spaces around the `app --port` or `mcp --connect` value, or the
variable's, are ignored; before, the connection failed (exit 1).
- An IPv6 host in `app --port`, `mcp --connect` or the variable goes in
brackets (`[::1]:7979`); `::1:7979` is a usage error (exit 2), as the
host and port can't be told apart; before, the connection failed
(exit 1).
- `app --help` shows `[env: SOUNDCRAFT_CONTROL_PORT=]` and
`[default: 7979]` instead of the hand-written default note.
- `mcp` with a root flag and --connect is clap's conflict error (exit 2,
"the argument '...' cannot be used with '...'"), reported before any
root folder is opened; before, a custom message with exit 1, after the
roots were opened.
* refactor(app): move launch flag parsing into launch_args
The parsing moves out of main unchanged, into a LaunchArgs struct and a
parse function that takes SOUNDCRAFT_CONTROL_PORT as a parameter. Tests pin
the flags, the file list, ignored unknown flags and the fallback of a bad
--control to the variable. No behaviour change.
* refactor(app): parse launch flags with clap
soundcraft --help now comes from the LaunchArgs doc comments and ends with the
environment variables the app reads, and the shared ControlServerArgs supplies
--control and SOUNDCRAFT_CONTROL_PORT. Process tests cover the variable (bad
value, blank value, loopback host:port, another host).
Behaviour changes:
- An unknown flag (--bogus, -x) is a usage error on stderr, exit 2. It was
ignored, and a single-dash word was opened as a file; after `--` it is a file.
- A bad --control (out of range, not a number, missing value) is a usage error,
exit 2. It was ignored and the variable used instead.
- A bad SOUNDCRAFT_CONTROL_PORT is a usage error naming the variable, exit 2.
It was ignored. An empty or blank variable still counts as unset.
- A loopback host:port (127.0.0.1, localhost or [::1]) in --control or
SOUNDCRAFT_CONTROL_PORT gives its port, so the value `soundcraft-cli app`
takes from the variable works for both. The control server listens on
127.0.0.1 only, so another host in --control is a usage error. In the
variable, which may point `soundcraft-cli app` at another machine, it is
ignored with a log warning and the app opens without a control server.
Both were ignored before.
- A repeated flag is a usage error (--demo twice, --control twice).
- --control=PORT and a port with surrounding spaces are accepted; a value that
starts with `-` is not taken as the value, except a negative number, which is
a bad port (`--control -1`).
- --help ends with an Environment section listing SOUNDCRAFT_CONTROL_PORT,
SOUNDCRAFT_CONFIG_DIR, SOUNDCRAFT_NO_PREFS, SOUNDCRAFT_NO_SYSTEM_FONTS,
SOUNDCRAFT_WAYLAND (Linux) and RUST_LOG.
- --help and -h print the help, exit 0. They were ignored.
- --version and -V print `soundcraft 0.13.1 (linux x86_64)`, as soundcraft-cli
does. It printed `SoundCraft 0.13.1`.
- -V and --version are read in order with the other arguments: an earlier
error comes first.
- macOS -psn_… process serial numbers are dropped, as before they were
opened as files.
- A file whose name is not valid Unicode is skipped with a log warning. It
used to panic in std::env::args.
* feat(cli): shell completions and man pages
An example, `cargo run -p soundcraft-cli --example man-and-completions -- <out-dir>`,
writes bash, zsh, fish, elvish and PowerShell completions and soundcraft-cli.1 plus a
page per subcommand, using clap_complete and clap_mangen (dev-dependencies of
soundcraft-cli only, not in the binary).
The Linux package (deb, rpm, tar.gz, AppImage) installs the pages in
/usr/share/man/man1 and the bash, zsh and fish completions in their standard
directories; the deb also links the zsh completion into Debian's
vendor-completions. A cross build runs the example through $EMULATOR and
leaves the files out without one. The FreeBSD tarball carries them in the
ports layout; a cross build builds the example for the host as well.
No change to the CLI's behaviour. A test pins the files the example writes.
* ci(cli): check the command-line code with ast-grep rules
Adds lint/ast-grep (rules for clap errors built from strings, String as an
error type, and std::env::args) and a workflow that runs the rule tests and a
scan over the CLI code through the shared craft-common-actions workflow. No
behaviour change; the scan has no hits.
* docs(cli): document soundcraft-cli and RFC-0012
Add docs/cli.md: the subcommands, exit codes, environment variables, the
desktop app's launch flags, man pages and completions, and the RFC-0012 rules
not followed yet (convert can overwrite its input; no --compact/--json).
Link it from the README and the MCP and control-protocol guides. No code change.
* feat(cli): refuse an output that replaces an input
An output that is one of the subcommand's inputs is a usage error (exit 2,
`error: …` on stderr, clap's usage line), reported while parsing, before
the engine loads or any --cmd runs. Paths are compared by file identity
(device and inode, through same-file), or, when neither exists yet, by
where they would be created, so `a.wav`, `./a.wav`, an absolute path and a
symbolic or hard link all count as the same file.
Inputs and outputs per subcommand:
- convert: input IN, output OUT. --in-place lets OUT replace IN.
- run: input --in, outputs --bounce and --save. --in-place lets --save
replace the --in session; it requires --in. A --bounce naming the --in
session is always refused.
- script: inputs FILE and --in, outputs --bounce and --save. --in-place
lets --save replace the --in session; a --bounce naming it is always
refused, and neither may ever replace FILE.
- run and script: --bounce and --save naming one file is refused with or
without --in-place (the save would replace the bounce).
- info, commands, describe, app, mcp, plugins write no file; parity
--write has no input. Paths inside --cmd parameters are not checked.
With --in-place, an output that is a symbolic link to the input is written
to the file the link names, so convert and --save both replace the input
and leave the link in place (a save renames a new file over its path,
which would otherwise replace the link and leave the input unchanged).
Behaviour changes:
- `convert a.wav a.wav`, `run --in s.scraft --save s.scraft`,
`run --in s.scraft --bounce s.scraft` and the other cases above exit 2
instead of replacing the input.
- New flag --in-place on convert, run and script.
- An existing file that is not an input is still replaced without asking.
* feat(cli): --compact for JSON output
RFC-0012 rule 1.3: JSON is pretty-printed by default and --compact prints
one line. Every pretty-printed JSON output now goes through
output::print_json.
Changed outputs:
- info <audio file>, describe, app: new --compact flag.
- run and script: new --compact flag, which requires --inspect and applies
to the --inspect JSON only.
Unchanged on purpose:
- The `ID: JSON` result lines of run and script and the --bounce and --save
results stay one line each. The prefix makes them text records, and the
RFC lets a command document its own layout; scripts that parse them keep
working.
- commands, plugins, parity and the .scraft summary of info are text and get
no --json flag (an open question in the RFC); mcp speaks JSON-RPC lines.
Pretty output is byte-identical to before.
* fix(app): one Switch parser for boolean environment switches
SOUNDCRAFT_NO_PREFS, SOUNDCRAFT_NO_SYSTEM_FONTS and SOUNDCRAFT_WAYLAND each
counted any value, including 0, as on. They now share
soundcraft_ui_egui::switch::Switch: 1/on/true/yes is On, 0/off/false/no is
Off (case- and space-insensitive), unset or blank is Default, and any other
value is Default and logged with the variable name. The ENVIRONMENT help
text, docs/cli.md and the README say the same.
Behaviour changes (old -> new):
- SOUNDCRAFT_NO_PREFS=0 disabled preferences (any value did); now only On
does.
- SOUNDCRAFT_NO_SYSTEM_FONTS=0 disabled system fonts (any value did); now
only On does.
- SOUNDCRAFT_WAYLAND=0 kept native Wayland (any value did); now only On does.
- An empty value of any of the three counted as set; it now means the
default (off).
- An unknown value of any of the three is logged.
* refactor(app): read the environment once into Env
The desktop app reads SOUNDCRAFT_CONFIG_DIR, SOUNDCRAFT_NO_PREFS,
SOUNDCRAFT_NO_SYSTEM_FONTS and SOUNDCRAFT_WAYLAND once at startup into
env::Env (typed fields, Switch for the on/off ones), after the logger is
installed so malformed switches are logged. The --help Environment
section is generated from the same VARS table, with a test that it lists
every name.
ui-egui no longer reads the app's variables: fonts::install and
definitions take system_fonts, set through SoundApp::set_system_fonts
(default on, so the web app is unchanged). The XWayland and prefs
decisions are methods on Env, tested on literals. logging::install takes
the RUST_LOG value, which stays outside Env because the logger needs it
before anything can log.
No behaviour change beyond help column spacing.
* refactor(cli): one long_version for both binaries
* refactor(audio-io): one FileFormat table for extensions
FileFormat gains the extension table every caller matches on:
from_extension / from_path (ASCII case-insensitive) over extensions,
from_write_extension over write_extensions, default_extension, name,
mime_type, the READ and WRITE lists, and readable_extensions /
writable_extensions for dialog filters, help and messages. Reading
takes every extension the decoder knows; writing takes only the names
whose readers expect what the encoder writes (no rf64 or aifc, whose
files would get plain RIFF and AIFF headers).
detect_format, bounce (mix and stems), convert, the bounce dialog, the
desktop and web file pickers, the workspace browser, the Sampler, web
downloads and the MCP bounce schema all use it; ENCODE_EXTENSIONS and
encode_format_for are gone. convert's IN/OUT and info's FILE help name
the extensions from the read and write lists.
Behaviour changes, where the lists disagreed:
- The bounce dialog's Browse result, the bounce save filter and the MCP
bounce enum take wav, wave, bwf, aif, aiff and flac: wave and bwf are
new to all three, and aif is new to the MCP enum. convert and
file.bounce_mix already took these. The "supported:" list in the
cannot-write errors is "wav, wave, bwf, aif, aiff, flac".
- file.bounce_stems reads its format name case-insensitively: `AIFF`
or `FLAC` meant WAV before. Unknown names still mean WAV.
- The bounce dialog sends the format as its file extension (aif for
AIFF); the engine accepts both spellings.
- File pickers, the workspace browser and the Sampler's drop and Load
Sample filter list every extension the decoder reads: the workspace
browser gains wave, bwf, rf64, aifc, mp1, mp2, oga, aac, mp4, adts,
mkv and webm; the Sampler gains rf64, mp1, mp2, m4b, adts, mkv and
webm; the desktop and web open filters gain rf64, mp1, mp2 and adts.
- Web downloads get a media type for every audio format, not only WAV,
AIFF and FLAC.
* refactor(app): resolve the settings folder once in Env
* fix(app): keep paths as paths until the engine needs text
A path is text only where an engine command takes `"path": string`; a
name that is not valid Unicode is reported there instead of being opened
under a lossy rendering (another file, or a confusing "can't read").
- ui-egui: dialogs::unicode() and NotUnicode ("<path:?> is not valid
Unicode"); dialogs::open_path(app, &Path), moved from the desktop app,
is the one open-by-extension path for dropped, command-line and
Workspace files.
- Services: the file dialogs return PathBuf (pick_save and pick_folder
start from a &Path); callers convert where the text field or command
takes the path.
- Sampler drops and Load Sample pass the path to mix.sampler_load
through unicode(); the audio test checks the Path.
- Workspace panel keeps entry paths; names are shown lossily only as
labels. workspace_dir stays a String (serialized preferences).
- soundcraft-cli: utf8() is unicode(), CliError::NonUnicodePath is
NotUnicode; it is called only for info's session, --in, --bounce and
--save. convert's output format test no longer treats a non-Unicode
extension as "no extension".
- docs/cli.md: sessions and bounces the engine opens or writes must be
valid Unicode.
Behaviour changes:
- A dropped, command-line, picked or Workspace file whose name is not
valid Unicode is not opened: the status line (and log) says
"<path:?> is not valid Unicode", with the bytes escaped. Dropped files
used to be opened under a U+FFFD rendering.
- A file dialog result that is not valid Unicode leaves the path field
unchanged and shows the same warning.
- Double-clicking a Workspace file opens it like a dropped file:
.MID/.MIDI/.SCRAFT in any case open as MIDI/session (they used to
import as audio), and a failed open is logged.
- convert OUT with an extension that is not valid Unicode is refused as
an unsupported format instead of being written as WAV.
* fix(app): read Env after the launch flags; tidy Switch and Env
* fix(audio-io): decode every extension the format table lists
* fix(cli): write convert output atomically; tighten --connect and loopback
- convert writes every output to a new file in the output's folder, flushes it and renames it
over the target, removing the new file on failure. A failed write (disk full, unwritable
folder) no longer truncates the input under --in-place (RFC-0012 rule 1.6). A link output
still writes the linked file.
- --save in place already goes through the engine's replace_file (tmp + rename), and
file.bounce_mix renders to <name>.part and renames it when complete, so both are atomic.
- The desktop's --control / SOUNDCRAFT_CONTROL_PORT no longer treat [::1] as loopback: the
control server binds 127.0.0.1 only. [::1]:P is a usage error from the flag and is ignored
with a warning from the variable. The CLI's --connect / app --port still accept [::1]:P.
Error tip and docs/cli.md updated.
- mcp --connect conflicts with --demo (exit 2): the demo session belongs to the in-process
server. Help and docs/cli.md say so.
* test(audio-io): list the decode fixtures in ATTRIBUTION.md
cargo xtask assets needs a row for every committed audio file; one
directory row covers crates/audio-io/tests/fixtures/.
* fix(cli): refuse non-finite --start and --end values
* refactor(cli): parse the control target once; open sessions by path; keep error sources
- A1: ControlTarget { host, port } is parsed once by args::control_target; is_loopback() replaces
control_port/ControlPort, and Remote::new takes &ControlTarget.
- A2: engine::io::open_session takes impl AsRef<Path>; the CLI no longer requires a Unicode path
to open a session, only for the --bounce and --save paths that go into JSON.
- A3: ValueError::Json keeps the serde_json::Error; Remote::request returns RemoteError and
AutomationRoots::new returns RootError, both carried by CliError.
* test(engine): pass session paths to open_session without a borrow
* test(cli): info opens a session at a non-Unicode path
* refactor(app): log the shared long version; info: session extension in any case; Switch beside Env
|
||
|
|
1e6310f85b |
fix(ui): dropdown menus grow back after a search with no matches (#1140)
* feat(ui): use craft-libs' ComboBox so menus grow back, and its menu for the send destination list Repin craft-libs to 62bb0e1d (includes craft-libs#384 and #387). Every egui::ComboBox becomes craft_ui::ComboBox, and clippy.toml disallows the egui one. The send destination menu moves to craft_ui::combo::Menu with the title and search in the header and "new bus..." / "Remove send" in a footer. * chore(deps): craft-libs 6af63481 (dropdown fixes) * chore(deps): craft-libs 4d7b82f7 (dropdown fixes) * chore(deps): craft-libs 92d392cf (#387 merged) |
||
|
|
7dc56a4dbe |
ui: Tracks and Groups and Clips in full-height dock columns (#1088)
* ui: keep SoundCraft's beside-the-session-view place for panels craft-ui has no record of * ui: Tracks and Groups and Clips in full-height dock columns The Edit window docks Tracks and Groups (168 pt) at its start edge and Clips (230 pt) at its end edge, with the MIDI editor under the session view between them; Mix docks Tracks and Groups at its start edge. Panels dragged to an empty window edge make a dock there. Saved preferences and window configurations carry docking_version. Split-frame layouts saved without it load as the new defaults, keeping every other setting. A list with no recorded place reopens in its dock group, making the dock again at its side and width when it is gone. Pins craft-ui, craft-docpath and craft-media to craft-libs#312. * Pin craft-libs at d24e4bc for the Mac round 3 * ui: test that a floating list reopens floating while its dock is shown; ui-parity revision |
||
|
|
5bbefeae62 |
build: pin craft-update to craft-libs main (495e597) (#1092)
Picks up the update prompt fix that draws its close mark and version pill without glyphs a font may lack, so the prompt no longer takes the app down when a bundled face has no ✕ or →. Part of tracking issue storytold/craft-libs#319 🤖 Generated with Codebuff Co-authored-by: Codebuff <noreply@codebuff.com> |
||
|
|
eec559f057 |
build: pin craft-update to craft-libs main (db19c37) (#1090)
Picks up the fix that keeps the close request pending while the app holds unsaved work, the executable-name check in the Windows update helper, and the zip 9 / dirs-free build. Part of tracking issue storytold/craft-libs#319 |
||
|
|
b854771251 |
feat: startup update prompt modal and direct self-updating (#1073)
* feat: startup update prompt modal and direct self-updating Integrate `craft-update` pinned to storytold/craft-libs fe61243 to check for updates on startup, display the standard suite update modal with changelog notes, and support one-click in-app updating and restart. Ref: storytold/craft-libs#319 * wip * build: refresh the lock * refactor(updates): drive the flow with craft-update's Updater The check at start is opt-in for the desktop app, a successful update closes through the app's own close path, and no update starts over unsaved work. * fix(updates): register the update command and hold the install back during a recording Help ▸ Check for Updates… goes through the shared command id, and an active recording counts as work the update must not interrupt. |
||
|
|
e0951aecf9 |
Migrate SoundCraft to egui 0.37 (#1063)
* fix(ui): preserve host keys during scripted input and clarify mixer labels * Preserve host input while expiring scripted gestures * Document migrated audio and UI behavior and regression invariants |
||
|
|
01b39850ad |
Release 0.13.1
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
106678471f |
Release 0.13.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |
||
|
|
ee050db59c |
ui: move panel docking onto craft-ui's shared Workspace and DockCommand (#1035)
* ui: move panel docking onto craft-ui's shared Workspace and DockCommand Pin every craft-libs crate at 16fb3d4 (craft-libs main after #285). The Edit and Mix workspaces are craft_ui::docking::Workspace<Panel>. ui.dock and ui.dock.reset parse into DockCommand; the app keeps its panels, permissions, defaults, the document-view and Mix rules, the beside-the-canvas fallback for panels without a recorded place, and Arrange. The canvas accepts splits so panels still open beside it. Saved v1 workspaces (no version, floating windows as {panels, active, rect}) load unchanged. Tests cover loading one and dragging a group by its drag bar. * ui: test that activating a hidden panel shows it * ui: name the field in ui.dock operation errors; document the shared panel menu and zones |
||
|
|
67865b23e8 |
Build: use craft-media for bitstream and isobmff (#776)
* Build: use craft-media for bitstream and isobmff
soundcraft-video re-exports craft_media::{bitstream, isobmff} from
craft-libs instead of carrying a copy of FilmCraft's crates. The module
paths stay, so crate::bitstream and crate::isobmff resolve as before.
The shared copy is newer: it adds APV, .mp2 as MPEG audio, AAC channel
configurations 11-14, SampleEntry::av1/flac, Mp4Writer::set_sample_entry
and the se(v) fix for i32::MIN.
* Build: pin craft-media to craft-libs f0ad6c1e
|
||
|
|
e8abd44712 |
CI: one test binary per crate, nextest, line tables only (#985)
* Build: line tables only for workspace crates, no debug info for dependencies Full debug info made most of the dev and test target size and link time. Line tables keep file and line numbers in backtraces; dependency frames lose them. * Tests: build each crate's integration tests as one binary Each tests/*.rs file was its own test binary: 98 binaries, each linking the crate and its dependencies. The files are now modules of tests/it/main.rs, one binary per crate, which cuts link time and target size. Filter by module: `cargo test -p <crate> --test it <module>::`. Binaries with their own main (harness = false) in clap-host and vst3-host stay separate, as do the ui-egui tests that switch the process-wide Light/Dark palette and recovery.rs, whose autosave locks leak into child processes other tests start. * Xtask: run tests with nextest, doctests apart, and no examples in the test build cargo xtask ci runs the tests with cargo nextest when it is installed, else cargo test with a notice, and doctests with cargo test --doc. The test build leaves out examples (--lib --bins --tests); clippy --all-targets still compiles them. Test binaries with harness = false run under cargo test: their own main cannot answer nextest's --list. clippy and the wasm check keep going past a failing crate. cargo xtask test runs the test step alone. |
||
|
|
f0d5acb800 |
Deps: fix the workspace build after the dependency bump (#954)
* Audio: migrate file decoding to symphonia 0.6
Upstream bumped symphonia to 0.6 without adapting crates/audio-io, so
`soundcraft-audio-io` no longer built: the probe module, codec parameters
and decoded-buffer APIs all moved.
- Probe with `default::get_probe().probe(&Hint, …)`. The 0.5 prober's
detection-only path is gone, so scan for the container marker ourselves
before instantiating a reader, and keep running the existing size checks
(CAF/MP4/FLAC/WAV) on the first marker — the damaged-file regression
tests depend on those checks firing before any allocation.
- Skip leading ID3v2 tags with `ReadBytes::ignore_bytes` as before.
- Read `Track::codec_params` (now an `Option`), decode through
`make_audio_decoder` and `GenericAudioBufferRef::copy_to_vecs_planar`,
and read the new public `Packet` fields.
- Keep the per-packet frame limit and the sample sanitisation.
* Playback: migrate the audio device layer to cpal 0.18
- Sample rates are plain `u32` now: drop `.0` and the `cpal::SampleRate`
constructor.
- One `cpal::Error` replaces the build/stream/play/pause error types;
detect `DeviceNotAvailable` through `error.kind()`.
- Stream builders take `StreamConfig` by value, and device names come
from `Device::description()` (the deprecated `name()` is gone).
- The test `Fake` implements the new `StreamTrait::{buffer_size, now}`.
* Deps: pin egui back to 0.36 until craft-ui supports 0.37
The dependabot group bump (#767) moved the workspace to egui, eframe and
egui_kittest 0.37, but the pinned `craft-ui` revision still builds against
egui 0.36, so the graph carries two incompatible egui versions and
`soundcraft-ui-egui` does not compile. craft-libs#199 updates craft-ui to
0.37 and is still open; pin 0.36 and refresh the lockfile meanwhile. The
other version bumps from #767 stay.
Re-land egui 0.37 together with the craft-ui update.
* Audio: refuse a size-checked container the probe did not validate
The dependency-migration review showed the preflight size checks can
validate one container marker while symphonia's probe selects a different
container, so a misleading marker could skip the FLAC/MP4/CAF/WAVE checks.
Probe 0.6 reports the selected format only through the reader it returns,
so `open()` now records which container's checks ran (including the
RF64/BW64 RIFF forms) and refuses the stream when a size-checked reader
was chosen without its checks, before any packet is decoded. Markers found
in audio data of non-container streams (MP3, Ogg, AIFF) do not reject
valid files.
Adds a regression test with a fake RIFF prefix followed by a valid FLAC
stream, and doc comments for the functions touched by the dependency
migration (the review's docstring-coverage warning).
|
||
|
|
d47abe484d |
Use chrono instead of hand-rolled UTC conversion (#844)
* Use chrono for UTC/calendar conversion instead of hand-rolled copies Replaces the civil_from_days copy behind the desktop app's log timestamp with chrono as a workspace dependency. The output format is unchanged and pinned by the existing test. AGENTS.md now says time goes through chrono. Follow-up to storytold/cadcraft#1785 * Never panic logging on a clock outside chrono's range chrono's From<SystemTime> unwraps internally, so a clock past year 262143 panicked inside the logger. timestamp now reads the duration since the epoch and goes through the fallible DateTime::from_timestamp, reading an out-of-range clock as the epoch, exactly as the pre-epoch clamp already did. The year is written with {:04} rather than %Y, which would prefix a '+' past year 9999. Tests cover the far-future and year-10000 cases. * Don't build an unrepresentable SystemTime in the far-future test UNIX_EPOCH + Duration::from_secs(u64::MAX / 2) overflows Windows' SystemTime and panicked before timestamp() ran, failing the Windows test job. Build it with checked_add and only assert where it exists. * time: preserve old out-of-range log timestamp (no epoch fallback) `DateTime::from_timestamp(...).unwrap_or_default()` silently reset any clock past chrono's year range to 1970-01-01, changing output the old hand-rolled `civil_from_days` converted exactly. Restore the old conversion domain with a cycle-based helper that routes the calendar through chrono (the calendar repeats every 400 years = 146_097 days, so month/day/time come from chrono and only the year is carried in i128, keeping every i64 exact). Keep the pre-1970 epoch clamp; u64 seconds past i64::MAX saturate rather than falling back. Pinned old outputs in the test (replacing the u64::MAX/2 -> epoch assertion): u64::MAX/2 s -> 292277026596-12-04T15:30:07.000Z 10_000_000_000_000 s -> 318857-05-20T17:46:40.000Z * Don't build a year-318857 SystemTime unchecked in the logging test Windows' SystemTime only reaches about year 30828, so UNIX_EPOCH + Duration::from_secs(10_000_000_000_000) panicked before timestamp() ran and failed the Windows test job. Build it with checked_add and assert where the platform can hold it. The year-10000 case fits everywhere and stays unconditional. * Name the 400-year range extension as the one exception to the time rule The rule said never to hand-roll calendar math, but the range fix (shifting by whole 400-year Gregorian cycles so dates past chrono's year range keep their old output) is cycle arithmetic, so the rule and the code disagreed. The rule now names that exception: the library still computes month, day and time, and only whole cycles are carried in the year. * Say the library computes month and day; time-of-day is plain arithmetic Narrows the range-extension wording: the date library computes the calendar fields, and splitting seconds into hours, minutes and seconds is ordinary arithmetic, which is what the code does. |
||
|
|
52471b37e9 |
chore(deps): bump the cargo-dependencies group across 1 directory with 11 updates (#767)
Bumps the cargo-dependencies group with 11 updates in the / directory: | Package | From | To | | --- | --- | --- | | [serde_json](https://github.com/serde-rs/json) | `1.0.151` | `1.0.154` | | [proptest](https://github.com/proptest-rs/proptest) | `1.11.0` | `1.12.0` | | [symphonia](https://github.com/pdeljanov/Symphonia) | `0.5.5` | `0.6.1` | | [zip](https://github.com/zip-rs/zip2) | `9.0.1` | `9.0.5` | | [cpal](https://github.com/RustAudio/cpal) | `0.16.0` | `0.18.2` | | [egui](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [eframe](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [egui_kittest](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [libloading](https://github.com/nagisa/rust_libloading) | `0.8.9` | `0.9.0` | | [muda](https://github.com/tauri-apps/muda) | `0.19.3` | `0.21.2` | | [winresource](https://github.com/BenjaminRi/winresource) | `0.1.31` | `0.1.34` | Updates `serde_json` from 1.0.151 to 1.0.154 - [Release notes](https://github.com/serde-rs/json/releases) - [Commits](https://github.com/serde-rs/json/compare/v1.0.151...v1.0.154) Updates `proptest` from 1.11.0 to 1.12.0 - [Release notes](https://github.com/proptest-rs/proptest/releases) - [Changelog](https://github.com/proptest-rs/proptest/blob/main/CHANGELOG.md) - [Commits](https://github.com/proptest-rs/proptest/compare/v1.11.0...v1.12.0) Updates `symphonia` from 0.5.5 to 0.6.1 - [Release notes](https://github.com/pdeljanov/Symphonia/releases) - [Commits](https://github.com/pdeljanov/Symphonia/compare/v0.5.5...v0.6.1) Updates `zip` from 9.0.1 to 9.0.5 - [Release notes](https://github.com/zip-rs/zip2/releases) - [Changelog](https://github.com/zip-rs/zip2/blob/master/CHANGELOG.md) - [Commits](https://github.com/zip-rs/zip2/compare/v9.0.1...v9.0.5) Updates `cpal` from 0.16.0 to 0.18.2 - [Release notes](https://github.com/RustAudio/cpal/releases) - [Changelog](https://github.com/RustAudio/cpal/blob/master/CHANGELOG.md) - [Commits](https://github.com/RustAudio/cpal/compare/v0.16.0...v0.18.2) Updates `egui` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `eframe` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `egui_kittest` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `libloading` from 0.8.9 to 0.9.0 - [Commits](https://github.com/nagisa/rust_libloading/compare/0.8.9...0.9.0) Updates `muda` from 0.19.3 to 0.21.2 - [Release notes](https://github.com/tauri-apps/muda/releases) - [Changelog](https://github.com/tauri-apps/muda/blob/dev/CHANGELOG.md) - [Commits](https://github.com/tauri-apps/muda/compare/muda-v0.19.3...muda-v0.21.2) Updates `winresource` from 0.1.31 to 0.1.34 - [Commits](https://github.com/BenjaminRi/winresource/commits) --- updated-dependencies: - dependency-name: cpal dependency-version: 0.18.2 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: eframe dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: egui dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: egui_kittest dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: libloading dependency-version: 0.9.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: muda dependency-version: 0.21.2 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: proptest dependency-version: 1.12.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: serde_json dependency-version: 1.0.154 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-dependencies - dependency-name: symphonia dependency-version: 0.6.1 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: winresource dependency-version: 0.1.34 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-dependencies - dependency-name: zip dependency-version: 9.0.3 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-dependencies ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> |
||
|
|
e85a4801e9 |
Release 0.12.1
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> |