Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.
C# audioaudio-unitavaloniacpp20cross-platformdawdigital-audio-workstationdspjucelinux-audiomcp-servermidimusicmusic-productionpiano-rollplugin-hostsequencersynthesizervstvst3
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
// Live / Linked Freeze (v1.1). Unlike the in-place Freeze (MainWindow.Freeze.cs), this
// bounces a source track into a *separate linked audio track* placed right below it, then
// puts the source to sleep (implicit-mute → the engine skips its instrument/devices, so its
// CPU is freed). The link stays live: "Edit" wakes the source (unmute) so you can change
// notes/devices, "Done" re-renders the linked audio and puts the source back to sleep.
//
// v1 slice of the spec: core loop (Live Freeze · Edit session · Commit/Discard · Unfreeze ·
// Flatten) + link persistence. Deferred: plugin RAM unload (§7.3), Live/Manual auto-render
// (§5B), revision cache/GC (§5B.7-8), dependency-graph cascade / Commit All (§14), partial /
// segment scope (§4.1-3), session-as-one-undo-step (§5A.6), realtime render for external
// inputs (§8.3), preserving frozen-clip edits across re-commit (§6.2).
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Interactivity;
using Nota.Application.Localization;
namespace Nota.App;
public partial class MainWindow
{
private enum LinkState { Frozen, Editing }
private sealed class FreezeLink
{
public int SourceId;
public int FrozenId;
public int Revision;
public LinkState State = LinkState.Frozen;
}
// Keyed by source track id (ids are stable within a session; the sidecar maps by index).
private readonly Dictionary<int, FreezeLink> _links = new();
private FreezeLink? LinkForSource(int id) => _links.TryGetValue(id, out var l) ? l : null;
private FreezeLink? LinkForFrozen(int id)
{ foreach (var l in _links.Values) if (l.FrozenId == id) return l; return null; }
// 0 = unrelated, 1 = a live-freeze source (sleeping), 2 = a linked frozen track.
private int FreezeRoleOf(int trackId)
=> _links.ContainsKey(trackId) ? 1 : LinkForFrozen(trackId) is not null ? 2 : 0;
private const string FrozenSuffix = " (frozen)";
// Drop links whose tracks no longer exist (deleted, cut, or undone away) — runs before
// every full arrangement refresh. A lost frozen track wakes its sleeping source; a lost
// source leaves the frozen audio as a plain track, un-silenced if it was mid-edit.
private void PruneFreezeLinks()
{
if (_links.Count == 0) return;
List<int>? dead = null;
foreach (var l in _links.Values)
{
bool hasSrc = TrackIndexOf(l.SourceId) >= 0, hasFrz = TrackIndexOf(l.FrozenId) >= 0;
if (hasSrc && hasFrz) continue;
if (hasSrc && l.State == LinkState.Frozen) Engine.SetTrackMute(l.SourceId, false);
if (hasFrz && l.State == LinkState.Editing) Engine.SetTrackMute(l.FrozenId, false);
(dead ??= new()).Add(l.SourceId);
}
if (dead is null) return;
foreach (int s in dead) _links.Remove(s);
if (_vm is not null) _vm.StatusText = Loc.T("main.live_freeze.live_freeze_link_removed_its");
UpdateFreezeButton(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
}
// --- button cluster (next to the in-place Freeze button) ---------------
// Reflect the shown track's live-freeze state onto the header buttons.
private void UpdateLiveFreezeButtons(int trackId)
{
if (LiveFreezeBtn is null) return;
var srcLink = LinkForSource(trackId);
var frzLink = LinkForFrozen(trackId);
var link = srcLink ?? frzLink;
bool plainFreezable = IsFreezable(trackId) && link is null && !Engine.IsTrackFrozen(trackId);
// A frozen (in-place) track or a return/group can't be live-frozen either.
LiveFreezeBtn.IsVisible = plainFreezable;
bool editing = link is { State: LinkState.Editing };
EditBtn.IsVisible = link is not null && !editing;
DoneBtn.IsVisible = editing;
DiscardBtn.IsVisible = editing;
}
// The source track a header action targets (following a frozen track back to its source).
private int LinkSourceFor(int trackId)
=> LinkForSource(trackId)?.SourceId ?? LinkForFrozen(trackId)?.SourceId ?? -1;
private async void OnLiveFreezeClick(object? sender, RoutedEventArgs e)
{ if (_freezeTrackId > 0) await LiveFreezeAsync(_freezeTrackId); }
private void OnEditClick(object? sender, RoutedEventArgs e)
{ int s = LinkSourceFor(_freezeTrackId); if (s > 0) BeginEditSession(s); }
private async void OnDoneClick(object? sender, RoutedEventArgs e)
{ int s = LinkSourceFor(_freezeTrackId); if (s > 0) await CommitEditSessionAsync(s); }
private void OnDiscardClick(object? sender, RoutedEventArgs e)
{ int s = LinkSourceFor(_freezeTrackId); if (s > 0) DiscardEditSession(s); }
// --- commands ----------------------------------------------------------
private async Task LiveFreezeAsync(int sourceId)
{
if (_vm is null || !IsFreezable(sourceId) || LinkForSource(sourceId) is not null) return;
double endBeats = ProjectEndBeats();
if (endBeats <= 0.0) { _vm.StatusText = Loc.T("main.nothing_to_freeze_the_arrangement"); return; }
string? wav = await RenderSourceToWavAsync(sourceId, Loc.T("main.live_freeze"));
if (wav is null) { _vm.StatusText = Loc.T("main.couldnt_freeze_this_track"); return; }
try
{
// Frozen track inherits the source's name/colour + static mixer strip so the mix
// sounds identical while the source sleeps. Placed directly under the source.
int srcIndex = TrackIndexOf(sourceId);
float vol = 1f, pan = 0f;
for (int i = 0; i < Engine.TrackCount; i++)
if (Engine.TryGetTrackInfo(i, out var ti) && ti.Id == sourceId) { vol = ti.Volume; pan = ti.Pan; break; }
string srcName = Engine.GetTrackName(sourceId);
int color = Engine.GetTrackColorIndex(sourceId);
var sends = new float[4];
for (int b = 0; b < 4; b++) sends[b] = Engine.GetTrackSend(sourceId, b);
int frozenId = Engine.AddAudioTrack();
Engine.SetTrackName(frozenId, (srcName is { Length: > 0 } ? srcName : $"Track {sourceId}") + FrozenSuffix);
if (color >= 0) Engine.SetTrackColorIndex(frozenId, color);
Engine.SetTrackVolume(frozenId, vol);
Engine.SetTrackPan(frozenId, pan);
for (int b = 0; b < 4; b++) Engine.SetTrackSend(frozenId, b, sends[b]);
Engine.AddAudioClip(frozenId, wav, 0);
if (srcIndex >= 0) Engine.MoveTrack(frozenId, srcIndex + 1); // sit directly below the source
Engine.SetTrackMute(sourceId, true); // implicit mute: engine skips its instrument/devices
_links[sourceId] = new FreezeLink { SourceId = sourceId, FrozenId = frozenId };
_vm.StatusText = Loc.T("main.live_freeze.track_live_frozen_press_edit");
}
catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.live_freeze_failed", ex.Message); }
finally { try { File.Delete(wav); } catch { } }
Timeline.Refresh();
if (Engine.TryGetTrackInfo(TrackIndexOf(sourceId), out _)) ShowDevices(sourceId); // keep Edit reachable
}
private void BeginEditSession(int sourceId)
{
var link = LinkForSource(sourceId);
if (link is null || _vm is null) return;
Engine.SetTrackMute(sourceId, false); // wake the source — it plays live now
Engine.SetTrackMute(link.FrozenId, true); // silence the stale bounce
link.State = LinkState.Editing;
_vm.StatusText = Loc.T("main.live_freeze.editing_the_frozen_source_press");
Timeline.Refresh();
UpdateLiveFreezeButtons(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
}
private async Task CommitEditSessionAsync(int sourceId)
{
var link = LinkForSource(sourceId);
if (link is null || _vm is null) return;
string? wav = await RenderSourceToWavAsync(sourceId, "Re-freeze");
if (wav is null) { _vm.StatusText = Loc.T("main.live_freeze.re_freeze_failed_the_source"); return; }
try
{
// Replace the frozen track's clips wholesale with the new bounce (v1: frozen-clip
// edits aren't preserved across a re-commit — see the deferred list).
if (Engine.TryGetTrackInfo(TrackIndexOf(link.FrozenId), out var fi))
for (int c = fi.ClipCount - 1; c >= 0; c--) Engine.TryDeleteClip(link.FrozenId, c);
Engine.AddAudioClip(link.FrozenId, wav, 0);
Engine.SetTrackMute(sourceId, true); // back to sleep
Engine.SetTrackMute(link.FrozenId, false); // the fresh bounce plays
link.State = LinkState.Frozen;
link.Revision++;
_vm.StatusText = "Re-frozen.";
}
catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.re_freeze_failed", ex.Message); }
finally { try { File.Delete(wav); } catch { } }
Timeline.Refresh();
UpdateLiveFreezeButtons(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
}
private void DiscardEditSession(int sourceId)
{
var link = LinkForSource(sourceId);
if (link is null || _vm is null) return;
Engine.SetTrackMute(sourceId, true);
Engine.SetTrackMute(link.FrozenId, false);
link.State = LinkState.Frozen;
_vm.StatusText = Loc.T("main.live_freeze.left_edit_mode_the_frozen");
Timeline.Refresh();
UpdateLiveFreezeButtons(_freezeTrackId);
ApplyFrozenChainDim(_freezeTrackId);
}
// Remove the frozen track and wake the source (back to a normal live track).
private void UnfreezeLink(int sourceId)
{
var link = LinkForSource(sourceId);
if (link is null) return;
Engine.RemoveTrack(link.FrozenId);
Engine.SetTrackMute(sourceId, false);
_links.Remove(sourceId);
if (_vm is not null) _vm.StatusText = Loc.T("main.live_freeze.unfrozen_the_source_is_live");
Timeline.Refresh();
Timeline.Select(sourceId, -1); // the frozen track may have been selected — it's gone now
}
// Make permanent: keep the frozen audio track, drop the link, and remove the sleeping source.
private async void FlattenLinkAsync(int sourceId)
{
var link = LinkForSource(sourceId);
if (link is null || _vm is null) return;
bool ok = await new ConfirmWindow(Loc.T("main.flatten_track"),
Loc.T("main.live_freeze.flatten_keeps_the_frozen_audio"),
Loc.T("main.flatten"), Loc.T("common.cancel")).ShowDialog<bool>(this);
if (!ok) return;
int frozenId = link.FrozenId;
_links.Remove(sourceId);
Engine.RemoveTrack(sourceId);
Engine.SetTrackMute(frozenId, false); // flattened mid-edit: the bounce was silenced
string name = Engine.GetTrackName(frozenId);
if (name.EndsWith(FrozenSuffix, StringComparison.Ordinal))
Engine.SetTrackName(frozenId, name[..^FrozenSuffix.Length]); // no longer a "frozen" copy
_vm.StatusText = Loc.T("main.live_freeze.flattened_the_frozen_audio_is");
Timeline.Refresh();
if (Engine.TryGetTrackInfo(TrackIndexOf(frozenId), out _)) Timeline.Select(frozenId, -1);
}
// Render the source's pre-fader chain to a temp WAV behind the progress dialog, reusing the
// in-place freeze capture (we take its PCM, then clear the transient in-place frozen flag).
private async Task<string?> RenderSourceToWavAsync(int sourceId, string title)
{
if (_vm is null) return null;
double endBeats = ProjectEndBeats();
if (endBeats <= 0.0) return null;
bool ok = false;
_vm.SuspendEnginePolling = true;
try
{
await RunBlockingAsync(title, Loc.T("main.rendering"), async prog =>
{
var frac = new Progress<double>(f => prog.Report(ProgressReport.At(f, Loc.F("main.rendering_n", f * 100))));
ok = await Task.Run(() => _freezer.Freeze(Engine, sourceId, endBeats,
_vm.Transport.LoopOn, _vm.Transport.MetronomeOn, frac));
});
}
catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.failed", title, ex.Message); }
finally { _vm.SuspendEnginePolling = false; }
if (!ok) { Engine.UnfreezeTrack(sourceId); return null; }
byte[] blob = Engine.GetFreezeState(sourceId);
Engine.UnfreezeTrack(sourceId); // we only wanted the PCM; the link owns the audio
try { return WriteFreezeBlobToWav(blob); }
catch (Exception ex) { _vm.StatusText = Loc.F("main.live_freeze.failed", title, ex.Message); return null; }
}
// --- context menu (Live freeze switch / Flatten), shared by source + frozen tracks ---
private bool _liveFreezeMenuBuilt;
private void EnsureLiveFreezeMenu()
{
if (_liveFreezeMenuBuilt) return;
_liveFreezeMenuBuilt = true;
// The same switch the track menu shows: on while linked; switching it off unfreezes.
var unfreeze = MenuKit.SwitchItem(Loc.T("main.live_freeze"), GlyphKind.ChainLink, true,
() => { int s = LinkSourceFor(_freezeTrackId); if (s > 0) UnfreezeLink(s); });
var flatten = MenuKit.Danger(Loc.T("main.flatten_remove_source"), GlyphKind.Flatten,
() => { int s = LinkSourceFor(_freezeTrackId); if (s > 0) FlattenLinkAsync(s); });
var menu = new ContextMenu();
menu.Items.Add(unfreeze);
menu.Items.Add(new Separator());
menu.Items.Add(flatten);
EditBtn.ContextMenu = menu;
DoneBtn.ContextMenu = menu;
}
// --- helpers + persistence (bundle sidecar, mirrors MidiLearnService) ---
private int TrackIndexOf(int id)
{
for (int i = 0; i < Engine.TrackCount; i++)
if (Engine.TryGetTrackInfo(i, out var ti) && ti.Id == id) return i;
return -1;
}
private int TrackIdAt(int index)
=> index >= 0 && Engine.TryGetTrackInfo(index, out var ti) ? ti.Id : -1;
private const string FreezeLinkSidecar = "freeze-links.json";
private sealed class LinkDto { public int Source { get; set; } = -1; public int Frozen { get; set; } = -1; public int Revision { get; set; } }
private void SaveFreezeLinks(string bundleDir)
{
string path = Path.Combine(bundleDir, FreezeLinkSidecar);
if (_links.Count == 0) { try { if (File.Exists(path)) File.Delete(path); } catch { } return; }
var list = new List<LinkDto>(_links.Count);
foreach (var l in _links.Values)
list.Add(new LinkDto { Source = TrackIndexOf(l.SourceId), Frozen = TrackIndexOf(l.FrozenId), Revision = l.Revision });
File.WriteAllText(path, JsonSerializer.Serialize(list, new JsonSerializerOptions { WriteIndented = true }));
}
private void LoadFreezeLinks(string bundleDir)
{
_links.Clear();
string path = Path.Combine(bundleDir, FreezeLinkSidecar);
if (!File.Exists(path)) return;
try
{
var list = JsonSerializer.Deserialize<List<LinkDto>>(File.ReadAllText(path)) ?? new();
foreach (var d in list)
{
int src = TrackIdAt(d.Source), frz = TrackIdAt(d.Frozen);
if (src <= 0 || frz <= 0) continue; // a linked track was deleted meanwhile
_links[src] = new FreezeLink { SourceId = src, FrozenId = frz, Revision = d.Revision, State = LinkState.Frozen };
Engine.SetTrackMute(src, true); // re-sleep the source (state re-opens as Frozen)
}
}
catch { /* corrupt sidecar: start with no links */ }
}
}