@pro-gram/flux 1.6.1 → 1.6.4

package/source/Main.cs

@@ -20,7 +20,7 @@ using NAudio.Wave.SampleProviders;
 
 [assembly: AssemblyTitle("Flux")]
 [assembly: AssemblyDescription("PCM/float media player, 16-track audio editor, H5studio recording and R16 control")]
-[assembly: AssemblyVersion("1.6.1.0")]
+[assembly: AssemblyVersion("1.6.4.0")]
 
 namespace DrumBuddy
 {
@@ -79,6 +79,9 @@ namespace DrumBuddy
         private CancellationTokenSource cancel;
         private bool busy, closeWhenIdle, stopping;
         private Recorder recorder;
+        private CancellationTokenSource countIn;
+        private Task recordingStartup;
+        private bool captureActive;
         private readonly ProgressBar[] meters = new ProgressBar[8];
         private readonly TextBlock[] meterLabels = new TextBlock[8];
         private readonly DispatcherTimer timer;
@@ -161,7 +164,7 @@ namespace DrumBuddy
             C<RadioButton>("RecordFloat").Checked += delegate { ShowRecordingFormat(); };
             C<RadioButton>("Record16").Checked += delegate { ShowRecordingFormat(); };
             C<RadioButton>("Record24").Checked += delegate { ShowRecordingFormat(); };
-            C<Button>("StartRecordButton").Click += delegate { StartRecording(); };
+            C<Button>("StartRecordButton").Click += async delegate { await StartRecording(); };
             C<Button>("StopRecordButton").Click += async delegate { await StopRecording(true); };
             C<Button>("HelpButton").Click += delegate { ShowHelp(); };
             C<Button>("InstallDriversButton").Click += delegate { DriverSetup.ShowGuide(window); };
@@ -184,6 +187,7 @@ namespace DrumBuddy
                 e.Handled = true;
             };
             window.Closing += async delegate(object sender, System.ComponentModel.CancelEventArgs e) {
+                if (countIn != null) { e.Cancel = true; await StopRecording(false); window.Close(); return; }
                 if (recorder != null) {
                     e.Cancel = true;
                     if (stopping) return;
@@ -244,6 +248,11 @@ namespace DrumBuddy
         public void Show() { window.Show(); }
         public Window NativeWindow { get { return window; } }
         internal void OpenEditorForTest() { OpenWorkspace(true); }
+        internal Task StartRecordingForTest() { return StartRecording(); }
+        internal Task StopRecordingForTest() { return StopRecording(true); }
+        internal Task RecordingTickForTest() { return Tick(); }
+        internal bool RecordingBusyForTest { get { return recorder != null || countIn != null; } }
+        internal EditorView RecordingEditorForTest { get { return editorView; } }
         internal void OpenHomeForTest() { OpenHome(); }
         internal void EditorFixtureForTest(EditorSession session, IDictionary<string, Clip> clips) { editorView.SetForTest(session, clips); editorView.ShowSelectionForTest(Audio.Rate, Audio.Rate * 4L); }
         internal void RecordingPanelForTest()
@@ -291,7 +300,7 @@ namespace DrumBuddy
                 editorView = new EditorView(window, System.IO.Path.Combine(cache, "editor"), Status, delegate { if (mediaPlayerView != null) mediaPlayerView.Stop(); });
                 C<Grid>("EditorHost").Children.Add(editorView);
                 var panel = C<StackPanel>("RecordPage"); var parent = panel.Parent as Panel; if (parent != null) parent.Children.Remove(panel);
-                panel.Visibility = Visibility.Visible; editorView.AttachRecordingPanel(panel); editorView.RecordRequested = async delegate { if (recorder == null) StartRecording(); else await StopRecording(true); };
+                panel.Visibility = Visibility.Visible; editorView.AttachRecordingPanel(panel); editorView.RecordRequested = async delegate { if (recorder == null) await StartRecording(); else await StopRecording(true); };
                 editorView.StopRequested = async delegate { if (recorder != null) await StopRecording(true); };
                 editorView.RecordingOptionsRequested = delegate { var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice; if (input != null && configuredDriver != input.Key && recorder == null) ConfigureRecordingDevice(); };
                 editorView.GridSettingsRequested = delegate { OpenSettings("timeline"); };
@@ -435,7 +444,7 @@ namespace DrumBuddy
         }
         private void BindMenus()
         {
-            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "ViewControl", "control" }, { "ViewRecording", "recordOptions" }, { "SettingsGeneral", "settings" }, { "SettingsTimeline", "timelineSettings" }, { "SettingsAudio", "audio" }, { "SettingsKeys", "keybinds" } };
+            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "ViewControl", "control" }, { "ViewRecording", "recordOptions" }, { "ViewMixer", "mixer" }, { "SettingsGeneral", "settings" }, { "SettingsTimeline", "timelineSettings" }, { "SettingsAudio", "audio" }, { "SettingsKeys", "keybinds" } };
             for (int i = 0; i < entries.GetLength(0); i++) { string action = entries[i, 1]; C<MenuItem>(entries[i, 0]).Click += async delegate { await ExecuteInterfaceAction(action); }; }
             C<MenuItem>("FileExit").Click += delegate { window.Close(); };
             C<MenuItem>("InstallAudioDrivers").Click += delegate { DriverSetup.ShowGuide(window); };
@@ -444,19 +453,20 @@ namespace DrumBuddy
         }
         private void RefreshMenuGestures()
         {
-            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "SettingsGeneral", "settings" } };
+            string[,] entries = { { "FileNew", "new" }, { "FileOpen", "open" }, { "FileSave", "save" }, { "FileSaveAs", "saveAs" }, { "FileImport", "import" }, { "FileExport", "export" }, { "ViewHome", "home" }, { "ViewEditor", "editor" }, { "ViewConverter", "converter" }, { "ViewPlayer", "player" }, { "ViewMixer", "mixer" }, { "SettingsGeneral", "settings" } };
             for (int i = 0; i < entries.GetLength(0); i++) { string gesture = InterfacePreferences.Gesture(entries[i, 1]); C<MenuItem>(entries[i, 0]).InputGestureText = gesture == "Unassigned" ? "" : gesture; }
         }
         private async void HandleInterfaceKey(object sender, System.Windows.Input.KeyEventArgs e)
         {
             var key = e.Key == System.Windows.Input.Key.System ? e.SystemKey : e.Key;
+            if (key == System.Windows.Input.Key.Escape && countIn != null) { e.Handled = true; await StopRecording(true); return; }
             if (key == System.Windows.Input.Key.Escape && workspace == 3 && editorView != null && editorView.HandleKey(e)) { e.Handled = true; return; }
             string action = InterfacePreferences.Resolve(key, System.Windows.Input.Keyboard.Modifiers);
             if (action == null) return;
             bool text = System.Windows.Input.Keyboard.FocusedElement is TextBox || System.Windows.Input.Keyboard.FocusedElement is ComboBox;
             if (text && !action.StartsWith("zoom", StringComparison.Ordinal) && !new[] { "save", "saveAs", "open", "new", "settings" }.Contains(action)) return;
             if (e.IsRepeat && !action.StartsWith("zoomIn", StringComparison.Ordinal) && !action.StartsWith("zoomOut", StringComparison.Ordinal)) { e.Handled = true; return; }
-            if (workspace != 3 && !(workspace == 2 && new[] { "play", "stop", "start", "end" }.Contains(action)) && !new[] { "home", "editor", "converter", "player", "settings", "timelineSettings", "new", "open", "save", "saveAs", "import", "export" }.Contains(action)) return;
+            if (workspace != 3 && !(workspace == 2 && new[] { "play", "stop", "start", "startAlternate", "end" }.Contains(action)) && !new[] { "home", "editor", "converter", "player", "mixer", "settings", "timelineSettings", "new", "open", "save", "saveAs", "import", "export" }.Contains(action)) return;
             e.Handled = true; await ExecuteInterfaceAction(action);
         }
         private async Task ExecuteInterfaceAction(string action)
@@ -471,8 +481,9 @@ namespace DrumBuddy
                 case "audio": OpenSettings("audio"); return;
                 case "keybinds": OpenSettings("keybinds"); return;
                 case "control": C<Button>("ControlTab").RaiseEvent(new RoutedEventArgs(Button.ClickEvent)); return;
+                case "mixer": if (workspace != 3) OpenWorkspace(true); if (workspace == 3 && editorView != null) editorView.ToggleMixer(); return;
                 case "recordOptions": if (workspace != 3) OpenWorkspace(true); if (editorView != null) editorView.ShowRecordingOptions(true); return;
-                case "record": if (recorder != null) await StopRecording(true); else StartRecording(); return;
+                case "record": if (recorder != null) await StopRecording(true); else await StartRecording(); return;
                 case "play": if (recorder != null) { await StopRecording(true); return; } break;
                 case "stop": if (recorder != null) { await StopRecording(true); return; } break;
             }
@@ -610,83 +621,126 @@ namespace DrumBuddy
             }
             finally { configuringCapture = false; }
         }
-        private async void StartRecording()
+        private Task StartRecording()
         {
-            if (busy || recorder != null) return;
+            if (busy || recorder != null || stopping) return Task.FromResult(0);
+            recordingStartup = StartRecordingCore(); return recordingStartup;
+        }
+        private void LockRecordingControls(bool locked)
+        {
+            foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = !locked;
+            if (!locked) C<Button>("StartRecordButton").IsEnabled = C<ComboBox>("InputDevice").SelectedItem != null;
+            C<Button>("StopRecordButton").IsEnabled = locked;
+        }
+        private async Task StartRecordingCore()
+        {
+            if (workspace != 3 || editorView == null) OpenWorkspace(true);
+            if (editorView == null || editorView.IsBusy) { Status("Finish the editor task before recording."); return; }
             var input = C<ComboBox>("InputDevice").SelectedItem as InputChoice;
-            if (input == null) { Status("Choose a recording input under Audio devices or Record drums, then click Refresh."); return; }
+            if (input == null) { editorView.ShowRecordingOptions(true); editorView.ShowRecordingError("Choose a recording input under Audio devices or Record options, then click Refresh."); return; }
             if (configuredDriver != input.Key) ConfigureRecordingDevice();
-            if (!C<Button>("StartRecordButton").IsEnabled) { Status("Choose a ready recording input in Record options."); return; }
-            string driver = input.Name;
-            
-            int mode = ((ModeChoice)C<ComboBox>("InputMode").SelectedItem).Mode;
+            if (!C<Button>("StartRecordButton").IsEnabled) { editorView.ShowRecordingOptions(true); editorView.ShowRecordingError(C<TextBlock>("CaptureFormatText").Text); return; }
+            var mode = C<ComboBox>("InputMode").SelectedItem as ModeChoice;
+            var rate = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
+            if (mode == null || rate == null) { editorView.ShowRecordingError("Choose input channels and a sample rate in Record options."); return; }
             int bits = C<RadioButton>("RecordFloat").IsChecked == true ? 32 : C<RadioButton>("Record16").IsChecked == true ? 16 : 24;
-            var rateChoice = C<ComboBox>("RecordRate").SelectedItem as RateChoice;
-            if (rateChoice == null) { Status("Choose a sample rate before recording."); return; }
-            if (editorView == null) OpenWorkspace(true);
-            if (editorView == null || editorView.IsBusy) { Status("Finish the editor task before recording."); return; }
-            int files = mode == -1 ? configuredInputChannels : 1;
-            StopWorkspaces();
-            recordingTrack = editorView.SelectedTrack; recordingAnchor = editorView.PlayheadFrame;
-            if (recordingTrack + files > 16) { Status("Select an earlier track so all recording channels fit within the 16-track timeline."); return; }
-            string folder = System.IO.Path.Combine(prefs.RecordFolder,"Take_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff",CultureInfo.InvariantCulture));
-            recorder = new Recorder();
-            Exception startError = null;
+            StopWorkspaces(); RecordingPlan plan;
+            try { plan = editorView.PlanRecording(input, mode.Mode, bits, rate.Rate, configuredInputChannels); }
+            catch (Exception ex) { editorView.ShowRecordingError(ex.Message); return; }
+            recordingTrack = plan.FirstTrack; recordingAnchor = plan.AnchorFrame;
+            string folder = System.IO.Path.Combine(prefs.RecordFolder, "Take_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff", CultureInfo.InvariantCulture) + "_" + Guid.NewGuid().ToString("N").Substring(0, 6));
+            var capture = new Recorder(); recorder = capture; captureActive = false;
+            var countdown = new CancellationTokenSource(); countIn = countdown;
+            LockRecordingControls(true); C<Button>("StopRecordButton").Content = "Cancel count-in";
+            C<TextBlock>("RecordTime").Text = "00:00.00";
+            foreach (var meter in meters) meter.Value = 0;
+            C<TextBlock>("RecordingState").Text = "Preparing input"; C<TextBlock>("RecordingState").Foreground = Brush("#B52C36");
+            editorView.BeginRecordingCountdown(plan);
+            Status("Preparing " + plan.Routing);
+            Exception startError = null; bool cancelled = false;
             try {
-                Status("Connecting to " + driver + "…");
-                recorder.Start(input,mode,bits,folder,rateChoice.Rate); captureStarted = DateTime.UtcNow;
-                editorView.SetRecordingState(true);
-                foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = false;
-                C<Button>("StopRecordButton").IsEnabled = true;
-                C<TextBlock>("RecordingState").Text = "● Recording"; C<TextBlock>("RecordingState").Foreground = Brush("#B52C36");
-                Status("Recording. Click Stop & save when you finish.");
+                // Let the armed tracks and connecting feedback render before a driver call.
+                await window.Dispatcher.InvokeAsync((Action)delegate { }, DispatcherPriority.Background);
+                countdown.Token.ThrowIfCancellationRequested();
+                capture.Prepare(plan.Input, plan.Mode, plan.Bits, folder, plan.SampleRate);
+                if (capture.ChannelCount != plan.InputChannels) throw new IOException("The device's input layout changed. Refresh Record options, check the destination tracks, and try again.");
+                await RecordingCountdown.Run(plan.Beats, plan.BeatSeconds, delegate(int remaining) {
+                    editorView.ShowCountdownBeat(remaining);
+                    C<TextBlock>("RecordingState").Text = "Recording in " + remaining;
+                    C<TextBlock>("RecordTime").Text = remaining.ToString(CultureInfo.InvariantCulture);
+                    Status("Count-in: " + remaining + " | " + plan.Routing + " | Stop or Escape cancels.");
+                }, countdown.Token);
+                countdown.Token.ThrowIfCancellationRequested();
+                capture.BeginCapture(); captureStarted = DateTime.UtcNow; captureActive = true;
+                editorView.BeginRecordingCapture();
+                C<Button>("StopRecordButton").Content = "Stop & save";
+                C<TextBlock>("RecordingState").Text = "Recording"; C<TextBlock>("RecordTime").Text = "00:00.00";
+                Status("Recording | " + plan.Routing + " | Click Stop & save when you finish.");
             }
+            catch (OperationCanceledException) { cancelled = true; }
             catch (Exception ex) { startError = ex; }
-            if (startError != null) {
-                if (editorView != null) editorView.SetRecordingState(false);
-                Recorder failed = recorder; recorder = null; failed.Stop(); await failed.Finish();
-                // Keep any partial audio from a failed start; never delete a take.
-                Status("Could not start recording: " + startError.Message + " Check Audio Interface mode and close other audio apps.");
-                RefreshDevices();
+            finally { if (ReferenceEquals(countIn, countdown)) countIn = null; countdown.Dispose(); }
+            if (startError == null && !cancelled) return;
+            captureActive = false; capture.Stop(); await capture.Finish();
+            recorder = null; editorView.SetRecordingState(false); LockRecordingControls(false);
+            C<Button>("StopRecordButton").Content = "Stop & save";
+            C<TextBlock>("RecordTime").Text = "00:00.00";
+            C<TextBlock>("RecordingState").Text = cancelled ? "Count-in cancelled" : "Could not start recording";
+            if (cancelled) Status("Count-in cancelled. No recording was started.");
+            else {
+                editorView.ShowRecordingError(startError.Message);
+                Status("Could not start recording: " + startError.Message + " Check the selected input and close other audio apps.");
             }
         }
         private async Task StopRecording(bool addFiles)
         {
+            if (countIn != null) {
+                var startup = recordingStartup; countIn.Cancel(); if (startup != null) await startup; return;
+            }
             if (recorder == null || stopping) return;
-            stopping = true; C<Button>("StopRecordButton").IsEnabled = false;
+            stopping = true; captureActive = false; C<Button>("StopRecordButton").IsEnabled = false;
             Recorder finished = recorder;
-            Status("Saving your recording…");
-            finished.Stop(); await finished.Finish(); recorder = null;
+            Status("Saving your recording...");
+            finished.Stop();
+            long frames = Interlocked.Read(ref finished.Frames);
+            if (editorView != null) { editorView.UpdateRecordingProgress(frames, finished.SampleRate); editorView.ShowRecordingSaving(); }
+            await finished.Finish(); recorder = null;
             if (editorView != null) editorView.SetRecordingState(false);
-            foreach (string name in new[] { "RecordTab", "StartRecordButton", "InputDevice", "InputMode", "Record16", "Record24", "RecordFloat", "RecordRate", "RefreshDevicesButton", "ChangeRecordFolderButton" }) C<Control>(name).IsEnabled = true;
-            C<TextBlock>("RecordingState").Text = finished.Error == null ? "Take saved" : "Recording stopped - check status";
+            LockRecordingControls(false); C<Button>("StopRecordButton").Content = "Stop & save";
+            C<TextBlock>("RecordingState").Text = finished.Error != null ? "Recording stopped - check status" : frames > 0 ? "Take saved" : "No audio captured";
             C<TextBlock>("RecordingState").Foreground = Brush(finished.Error == null ? "#006D68" : "#B52C36");
             stopping = false;
-            if (Interlocked.Read(ref finished.Frames) > 0 && finished.Paths.Count > 0 && editorView != null) {
-                try { await editorView.AddRecordedFiles(finished.Paths, recordingAnchor, recordingTrack); }
-                catch (Exception ex) { Status("Take saved to its folder, but could not be added to the timeline: " + ex.Message); return; }
+            if (addFiles && frames > 0 && finished.Paths.Count > 0 && editorView != null) {
+                try { await editorView.AddRecordedFiles(finished.Paths, recordingAnchor, recordingTrack, true); }
+                catch (Exception ex) { editorView.ShowRecordingError("Take saved to its folder, but could not be added to the timeline: " + ex.Message); return; }
             }
-            Status(finished.Error == null ? "Take saved and added to the timeline. Original recording files are preserved." : "Recording stopped: " + finished.Error.Message + " Captured audio was kept.");
+            if (finished.Error != null) {
+                editorView.ShowRecordingError(finished.Error.Message);
+                Status("Recording stopped: " + finished.Error.Message + " Captured audio was kept.");
+            }
+            else Status(frames == 0 ? "No audio was captured. Check the selected input device and microphone permissions." : addFiles ? "Take saved and added to the timeline. Original recording files are preserved." : "Take saved. Original recording files are preserved.");
         }
         private async Task Tick()
         {
             if (closeWhenIdle && !busy && !WorkspacesBusy && recorder == null) { closeWhenIdle = false; window.Close(); return; }
-            if (recorder == null || stopping) return;
+            if (recorder == null || stopping || !captureActive) return;
             long frames = Interlocked.Read(ref recorder.Frames);
             C<TextBlock>("RecordTime").Text = WorkspaceUi.Clock(frames / (double)recorder.SampleRate);
+            if (editorView != null) editorView.UpdateRecordingProgress(frames, recorder.SampleRate);
             if (frames == 0 && (DateTime.UtcNow - captureStarted).TotalSeconds > 8 && recorder.Error == null)
                 recorder.Error = new IOException("No audio arrived from the selected input. Check its connection, microphone permissions and selected channels.");
             if (recorder.SourceFormat != null)
                 C<TextBlock>("CaptureFormatText").Text = "Input: " + (recorder.SourceIsFloat ? "native 32-bit float" : recorder.SourceFormat) + " | WAV: " + recorder.Bits + (recorder.Bits == 32 ? "-bit float" : "-bit PCM") + " | " + recorder.SampleRate + " Hz";
-            bool tooLoud = false;
+            bool tooLoud = false; var mixerInputs = new float[8];
             for (int i = 0; i < 8; i++) {
-                float peak = Interlocked.Exchange(ref recorder.Peaks[i],0);
+                float peak = Interlocked.Exchange(ref recorder.Peaks[i],0); mixerInputs[i] = peak;
                 double db = peak > 0 ? 20 * Math.Log10(peak) : -60;
                 meters[i].Value = Math.Max(0,Math.Min(1,(db + 60) / 60));
                 meters[i].Foreground = Brush(peak >= .99 ? "#B52C36" : "#007A6B");
                 meterLabels[i].Text = peak > .001 ? db.ToString("0",CultureInfo.InvariantCulture) + " dB" : "—";
                 tooLoud |= peak >= .99;
             }
+            if (editorView != null) editorView.UpdateRecordingInputMeters(mixerInputs);
             C<TextBlock>("RecordHint").Text = recorder.Bits == 32 && recorder.SourceIsFloat
                 ? (tooLoud ? "Peaks above 0 dBFS are kept in the float master. Enable Prevent PCM clipping when making a PCM copy." : "Recording the original float samples. Monitor through the recorder's headphones.")
                 : (tooLoud ? "Input is near full scale. Turn down the recorder's input level to prevent clipping." : "Set input levels on the recorder. Adjust a copy in Media Player.");
@@ -711,7 +765,8 @@ namespace DrumBuddy
                 "HOME AND CONVERTER\nOpen Converter from View or Home. Drop audio or video, choose an output type and click Convert files. WAV PCM, WAV float, AIFF, FLAC, MP3 and AAC copies are supported. Output settings can be resized, collapsed, or displayed on the side or bottom. The source is preserved.\n\n" +
                 "Set safe level brings the loudest peak to −1 dBFS. Prevent clipping caps excessive gain evenly; it preserves the dynamics of your drums.\n\n" +
                 "ZOOM R16\nExports are 44.1 kHz PCM WAV, mono or stereo, with names up to 8 uppercase characters. Use the bit depth of your R16 project. Copy WAVs to that project's AUDIO folder, then assign them to tracks on the R16.\n\n" +
-                "EDITOR + RECORD\nThe Editor opens by default. Record options contains input, channels, WAV format and sample rate. Record or R starts a take at the playhead on the selected track. Stop & save preserves the take and adds it to the timeline. All inputs uses consecutive tracks. Use hardware direct monitoring while recording; software overdub synchronisation is not provided.\n\n" +
+                "EDITOR + RECORD\nThe Editor opens by default. Record options contains input, channels, WAV format and sample rate. Record or R arms the selected track and shows one bar of countdown at the project tempo. Separate inputs reserve consecutive tracks. Stop, Record again or Escape cancels the countdown. Capture then starts through the selected input; the red playhead and elapsed timer follow captured audio. Stop & save preserves the take and adds it at the original starting point, leaving the playhead at its end. Use hardware direct monitoring while recording; software overdub synchronisation is not provided.\n\n" +
+                "MIXER\nOpen Mixer in the Editor or View menu. Track faders, pan, mute/solo and a master fader affect playback and exported mixes. File peak and Before fader meters help identify quiet sources; After fader shows the adjusted signal. Red peak indicators latch at 0 dBFS; click to clear. Monitor changes listening volume only. During recording, meters show the selected raw inputs; set capture gain on the input device.\n\n" +
                 "H5STUDIO FLOAT\nOn the recorder choose USB > Audio Interface > Connect. Audio I/F Only supports 44.1, 48 and 96 kHz. Stereo mix exposes a mixed stereo signal; Multi Track exposes separate inputs. Choose 32-bit float to keep the original float samples, including peaks above 0 dBFS. The app checks that the H5studio driver is actually sending float samples.\n\n" +
                 "PLAYBACK COMPATIBILITY\nSome players reject float or multichannel WAV files. Open Converter from View, enable Prevent PCM clipping and choose 16-bit or 24-bit WAV PCM. The original float master remains unchanged.\n\n" +
                 "FULL CONTROL\nAn R16 front-panel view with PC multitrack playback, mixer, EQ, recording and Mackie MIDI control. Open Menu reveals files, track settings, saved effects and devices. Escape returns home.\n\n" +
@@ -719,9 +774,9 @@ namespace DrumBuddy
                 "Use the R16 gain knobs to set recording levels. Listen through the R16's direct headphone monitoring.\n\n" +
                 "Install Drivers opens a short guide and links to Zoom's official driver download pages.\n\n" +
                 "MEDIA PLAYER\nOpen audio or video to listen. Gain / Save amplifies or reduces playback and saves adjusted WAV copies; Playback volume changes listening level only. Reset, Set safe level and Prevent clipping are available. Choose speakers/headphones under Audio output. Gain / Save can be resized, collapsed, or displayed on the side or bottom.\n\n" +
-                "EDITOR\nA 16-track audio timeline. Drag the upper ruler and release to place the playhead. The left edge snaps to zero; Home/To start goes to zero and End goes to the timeline end. Hold Alt to bypass snapping. Drag across a track to select time; two thinner blue sticks mark the selection start/end. Drag their lower-ruler handles to adjust the boundaries. Cut/copy/paste, split, undo/redo, Space to play/pause and Ctrl+S to save. Cuts leave a gap. Choose Selected track or All 16 tracks for edits. Save .dbedit sessions and export PCM or float WAV mixes. Original source files are preserved.\n\n" +
+                "EDITOR\nA 16-track audio timeline. Drag the upper ruler and release to place the playhead. The left edge snaps to zero; Home, Enter and To start go to zero; End goes to the timeline end. Ctrl+Left/Right jumps to the nearest bar line strictly left/right using the project tempo and time signature. Hold Alt to bypass snapping. Drag across a track to select time; two thinner blue sticks mark the selection start/end. Drag their lower-ruler handles to adjust the boundaries. Cut/copy/paste, split, undo/redo, Space to play/pause and Ctrl+S to save. Cuts leave a gap. Choose Selected track or All 16 tracks for edits. Save .dbedit sessions and export PCM or float WAV mixes. Original source files are preserved.\n\n" +
                 "THEME AND SETTINGS\nUse the top-right switch for dark or light theme. Settings has categories for General, Audio and Keybinds. Click Edit on a keybind and press the new shortcut immediately. Save writes the changes; leaving with pending changes asks whether to save them. S splits at the playhead; V returns to the selection cursor.\n\n" +
-                "Basic tools run locally without an account. This release is for Windows; macOS is planned.\n\nFlux 1.6.1 · FFmpeg + NAudio",
+                "Basic tools run locally without an account. This release is for Windows; macOS is planned.\n\nFlux 1.6.4 · FFmpeg + NAudio",
                 "Flux — quick help",MessageBoxButton.OK,MessageBoxImage.Information);
         }
     }
@@ -735,6 +790,8 @@ namespace DrumBuddy
         {
             if (args.Length > 0 && args[0] == "--self-test") return SelfTest.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--float-self-test") return FloatRecordingTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--recording-self-test") return RecordingTests.Run(args.Skip(1).ToArray());
+            if (args.Length > 0 && args[0] == "--mixer-self-test") return EditorMixerTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--grid-self-test") return TempoGridTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--zoom-self-test") return ZoomTests.Run(args.Skip(1).ToArray());
             if (args.Length > 0 && args[0] == "--selection-self-test") return EditorSelectionTests.Run(args.Skip(1).ToArray());

package/source/Main.xaml

@@ -84,6 +84,7 @@
         <MenuItem x:Name="ViewHome" Header="Home" />
         <MenuItem x:Name="ViewEditor" Header="Editor + Record" />
         <MenuItem x:Name="ViewRecording" Header="Recording options" />
+        <MenuItem x:Name="ViewMixer" Header="Mixer" />
         <MenuItem x:Name="ViewConverter" Header="Converter" />
         <MenuItem x:Name="ViewPlayer" Header="Media Player" />
         <MenuItem x:Name="ViewControl" Header="R16 Full Control" />
@@ -261,7 +262,7 @@
                   <TextBlock x:Name="RecordTime" Grid.Column="1" Text="00:00" FontSize="22" FontFamily="Consolas" />
                 </Grid>
                 <UniformGrid x:Name="MeterPanel" Columns="4" Margin="0,7,0,8" />
-                <TextBlock x:Name="RecordHint" Text="Recordings are added at the timeline playhead on the selected track." FontSize="11" Foreground="{DynamicResource Theme526771}" TextWrapping="Wrap" Margin="0,0,0,10" />
+                <TextBlock x:Name="RecordHint" Text="One bar count-in at the project tempo, then record at the playhead on the selected track. Stop or Escape cancels the count-in." FontSize="11" Foreground="{DynamicResource Theme526771}" TextWrapping="Wrap" Margin="0,0,0,10" />
                 <Grid>
                   <Grid.ColumnDefinitions>
                     <ColumnDefinition />

package/source/MediaPlayerView.cs

@@ -187,7 +187,7 @@ namespace DrumBuddy
                 case "import": await ChooseFiles(); break;
                 case "play": PlayPause(); break;
                 case "stop": Stop(); break;
-                case "start": Seek(0); break;
+                case "start": case "startAlternate": Seek(0); break;
                 case "end": if (Selected != null) Seek(Selected.Duration); break;
                 default: return false;
             }

package/source/Quick Start.txt

@@ -1,4 +1,4 @@
-FLUX 1.6.1
+FLUX 1.6.4
 
 INSTALL / UPDATE
 Close the app. Run npm.cmd install -g @pro-gram/flux@latest
@@ -32,10 +32,29 @@ Fit shows the full project; Selection fills the view with the selected range.
 Ctrl+= / Ctrl+- zoom; Ctrl+0 fits the project; Ctrl+Shift+0 fits the selection.
 Zoom can reveal individual samples. Close-up waveforms load in the background.
 Record options opens the sidebar. Select input, channels, rate and format.
-The take is saved at the playhead on the selected track; separate inputs use
-consecutive tracks. Stop saves and inserts it. Source files are preserved.
+Record or R arms the selected track (consecutive tracks for separate inputs),
+then shows a one-bar countdown at the project tempo and time signature.
+Record again, Stop, or Escape cancels the countdown without starting capture.
+Capture begins after the last beat using the selected input device.
+The red playhead, growing recording highlights and elapsed timer follow the
+captured audio. Stop saves and inserts the take at its original starting point,
+leaving the playhead at its end. Source files are preserved.
+Bar lines are labeled 1, 2, 3; beat labels remain available when zoomed in.
 Use direct headphone monitoring. Software overdub synchronization is not included.
 
+MIXER
+Open Mixer from the Editor toolbar or View menu. Scroll through all 16 tracks;
+the master stays visible. Drag the divider to resize, or choose Side/Bottom.
+Track faders (-60 to +24 dB), pan, mute and solo apply during playback and export.
+The master fader (-60 to +12 dB) changes the entire mix. Settings save in .dbedit
+sessions and support Undo/Redo. Original audio files stay unchanged.
+File peak shows the source level independently of gain. Before fader shows
+source signal, including muted tracks; After fader shows the adjusted level.
+Red peak readouts latch at 0 dBFS; click a readout or Clear peaks to reset.
+Monitor is listening volume only and does not affect exports or meter readings.
+During recording the strips show the registered raw inputs. Set capture gain
+on your input device; the mixer does not change the recorded original.
+
 AUDIO DEVICES
 Audio devices at the top right opens Settings > Audio. Save device changes.
 Windows default shows and follows the current Windows speakers/headphones.
@@ -75,7 +94,9 @@ Ctrl+D: duplicate. Ctrl+L: repeat selected clips/range. M: clip mute. X: crossfa
 Right-click audio for the editing menu. Edits, fades and mute support Undo.
 Ctrl+X/C/V: cut/copy/paste. Backspace/Delete: remove selection. Ctrl+Z/Y: undo/redo.
 Ctrl+S: save session. Ctrl+Shift+S: save as. Ctrl+O/N: open/new.
-Ctrl+I/E: import/export. Home/End: timeline beginning/end.
+Ctrl+I/E: import/export. Home or Enter: timeline beginning. End: timeline end.
+Ctrl+Left/Right: nearest bar line strictly left/right using the project tempo
+and time signature. From a bar line, jump to the previous/next bar.
 Ctrl+1/2/3/4: Home/Editor/Converter/Player. Ctrl+comma: Settings.
 
 MEDIA PLAYER / R16

package/source/RecordingSession.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DrumBuddy
+{
+    // Snapshot the routing before the count-in; later selection changes cannot reroute a take.
+    public sealed class RecordingPlan
+    {
+        private readonly string inputName, inputDriver, inputEndpoint;
+        public readonly int Mode, Bits, SampleRate, FirstTrack, TrackCount, InputChannels, Beats;
+        public readonly long AnchorFrame;
+        public readonly double BeatSeconds;
+        public InputChoice Input { get { return new InputChoice { Name = inputName, Driver = inputDriver, EndpointId = inputEndpoint }; } }
+        public string Tracks { get { return TrackCount == 1 ? "Track " + (FirstTrack + 1) : "Tracks " + (FirstTrack + 1) + "-" + (FirstTrack + TrackCount); } }
+        public string Routing { get; private set; }
+
+        public RecordingPlan(InputChoice input, int mode, int bits, int rate, int availableInputs, int firstTrack, long anchor, TempoGridOptions grid)
+        {
+            if (input == null) throw new IOException("Choose a recording input in Record options.");
+            grid.Validate(); var layout = CaptureLayout.Create(availableInputs, mode);
+            if (bits != 16 && bits != 24 && bits != 32) throw new IOException("Choose a WAV recording format.");
+            if (rate <= 0) throw new IOException("Choose a recording sample rate.");
+            int tracks = layout.Separate ? layout.Channels : 1;
+            if (firstTrack < 0 || firstTrack + tracks > 16) throw new IOException("Select an earlier track so all recording channels fit within the 16-track timeline.");
+            if (anchor < 0 || anchor >= EditorSession.MaxFrame) throw new IOException("Move the playhead before the end of the timeline to record.");
+            inputName = input.Name; inputDriver = input.Driver; inputEndpoint = input.EndpointId;
+            Mode = mode; Bits = bits; SampleRate = rate; FirstTrack = firstTrack; TrackCount = tracks; InputChannels = layout.Channels; AnchorFrame = anchor;
+            Beats = grid.BeatsPerBar; BeatSeconds = TempoGrid.BeatSeconds(grid);
+            string channels = layout.Channels == 1 ? "Input " + (layout.FirstInput + 1) : "Inputs " + (layout.FirstInput + 1) + "-" + (layout.FirstInput + layout.Channels);
+            Routing = Tracks + " | " + channels + " | " + inputName + " | " + (rate / 1000.0).ToString("0.#", CultureInfo.InvariantCulture) + " kHz";
+        }
+        public long TimelineFrame(long capturedFrames, int sampleRate)
+        {
+            if (sampleRate <= 0) throw new ArgumentOutOfRangeException("sampleRate");
+            double elapsed = Math.Max(0, capturedFrames) * (double)Audio.Rate / sampleRate;
+            return AnchorFrame + (long)Math.Round(Math.Min(EditorSession.MaxFrame - AnchorFrame, elapsed));
+        }
+    }
+
+    public static class RecordingCountdown
+    {
+        public static async Task Run(int beats, double beatSeconds, Action<int> showBeat, CancellationToken token)
+        {
+            if (beats < 1 || beats > 32 || beatSeconds <= 0 || double.IsNaN(beatSeconds) || double.IsInfinity(beatSeconds))
+                throw new ArgumentOutOfRangeException("beats");
+            var clock = Stopwatch.StartNew();
+            for (int beat = 0; beat < beats; beat++) {
+                token.ThrowIfCancellationRequested(); showBeat(beats - beat);
+                double remaining = (beat + 1) * beatSeconds - clock.Elapsed.TotalSeconds;
+                if (remaining > 0) await Task.Delay(TimeSpan.FromSeconds(remaining), token);
+            }
+            token.ThrowIfCancellationRequested();
+        }
+    }
+}

package/source/RecordingTests.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+
+namespace DrumBuddy
+{
+    public static class RecordingTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string message) { if (!value) throw new Exception(message); log.Add("PASS  " + message); }
+        private static void RunUi(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current; var dispatcher = Dispatcher.CurrentDispatcher;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(dispatcher));
+            try {
+                var task = action(); var frame = new DispatcherFrame();
+                task.ContinueWith(delegate { dispatcher.BeginInvoke((Action)delegate { frame.Continue = false; }); });
+                if (!task.IsCompleted) Dispatcher.PushFrame(frame); task.GetAwaiter().GetResult();
+            }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        private static void Picture(FrameworkElement view, string file, int width, int height)
+        {
+            view.Measure(new Size(width, height)); view.Arrange(new Rect(0, 0, width, height)); view.UpdateLayout();
+            var image = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32); image.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(image)); using (var stream = File.Create(file)) encoder.Save(stream);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxRecording_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var old = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); ThemePalette.Apply(true);
+                var input = new InputChoice { Name = "Selected USB microphone", EndpointId = "selected-endpoint" };
+                var grid = new TempoGridOptions();
+                var plan = new RecordingPlan(input, -1, 32, 48000, 2, 5, Audio.Rate * 2L, grid);
+                input.EndpointId = "other-endpoint"; grid.Tempo = 200; grid.BeatsPerBar = 3;
+                Check(plan.Input.EndpointId == "selected-endpoint" && plan.FirstTrack == 5 && plan.TrackCount == 2 && plan.InputChannels == 2 && plan.Beats == 4 && plan.BeatSeconds == .5,
+                    "Freeze the selected endpoint, input layout, destination tracks, anchor and project tempo before counting in");
+                var stereo = new RecordingPlan(plan.Input, 0, 24, 96000, 2, 15, 0, grid);
+                Check(stereo.TrackCount == 1 && stereo.Beats == 3 && Math.Abs(stereo.BeatSeconds - .3) < 1e-12,
+                    "Route a stereo file to one track and use one bar of the actual project meter");
+                bool rejected = false;
+                try { new RecordingPlan(plan.Input, -1, 24, 48000, 8, 10, 0, grid); } catch (IOException) { rejected = true; }
+                Check(rejected, "Reject an overflowing multitrack take before countdown or capture");
+                Check(plan.TimelineFrame(48000, 96000) == plan.AnchorFrame + Audio.Rate / 2 && plan.TimelineFrame(long.MaxValue, 48000) == EditorSession.MaxFrame,
+                    "Convert captured frames to the editor rate without exceeding the timeline limit");
+                RunUi(async delegate {
+                    var beats = new List<int>(); var watch = Stopwatch.StartNew(); bool began = false;
+                    await RecordingCountdown.Run(4, .04, value => beats.Add(value), CancellationToken.None); began = true;
+                    Check(began && beats.SequenceEqual(new[] { 4, 3, 2, 1 }) && watch.Elapsed.TotalSeconds >= .145,
+                        "Display every count-in beat and wait the full bar before starting capture");
+                    var cancelled = new CancellationTokenSource(); began = false; bool stopped = false;
+                    try { await RecordingCountdown.Run(4, .02, value => { if (value == 1) cancelled.Cancel(); }, cancelled.Token); began = true; }
+                    catch (OperationCanceledException) { stopped = true; }
+                    Check(stopped && !began, "Cancelling on the last countdown beat prevents recording from starting"); cancelled.Dispose();
+                    cancelled = new CancellationTokenSource(); cancelled.Cancel(); beats.Clear();
+                    try { await RecordingCountdown.Run(4, .02, beats.Add, cancelled.Token); } catch (OperationCanceledException) { }
+                    Check(beats.Count == 0, "A cancelled startup cannot display another beat or restart capture"); cancelled.Dispose();
+
+                    // Prepare a real Windows endpoint, but cancel before it is ever opened for capture.
+                    var main = new MainWindow(Path.Combine(root, "shell-preferences.xml"), true);
+                    main.OpenEditorForTest(); main.RecordingPanelForTest();
+                    if (((Button)main.NativeWindow.FindName("StartRecordButton")).IsEnabled) {
+                        var startup = main.StartRecordingForTest();
+                        await main.RecordingTickForTest();
+                        Check(main.RecordingBusyForTest && main.RecordingEditorForTest.IsBusy,
+                            "Lock the actual recording controller and editor before driver preparation or the first countdown beat");
+                        await main.StartRecordingForTest();
+                        await main.NativeWindow.Dispatcher.InvokeAsync((Action)delegate { }, DispatcherPriority.Background);
+                        Check(main.RecordingEditorForTest.CountdownForTest == "4", "The actual Record action displays the first countdown beat");
+                        Picture((FrameworkElement)main.NativeWindow.Content, Path.Combine(root, "countdown-shell-dark.png"), 1280, 800);
+                        await main.StopRecordingForTest(); await startup;
+                        Check(!main.RecordingBusyForTest && !main.RecordingEditorForTest.IsBusy && ((TextBlock)main.NativeWindow.FindName("RecordingState")).Text == "Count-in cancelled",
+                            "Stop cancels the actual startup, releases the prepared device and restores the recording controls");
+                    }
+                    else log.Add("SKIP  No ready Windows endpoint for the controller preparation/cancellation check; generated-buffer coverage still runs.");
+                    main.NativeWindow.Close();
+
+                    var owner = new Window(); ThemePalette.Install(owner);
+                    using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate(string message) { }, delegate { })) {
+                        owner.Content = editor; editor.BeginRecordingCountdown(plan); editor.ShowCountdownBeat(4);
+                        Check(editor.IsBusy && editor.CountdownForTest == "4" && editor.ArmedTracksForTest.SequenceEqual(new[] { 5, 6 }) && editor.RoutingForTest.Contains("Selected USB microphone"),
+                            "Show the countdown and exact armed tracks with the selected device in the editor");
+                        Picture(editor, Path.Combine(root, "countdown-dark.png"), 1280, 760);
+                        Check(!await editor.ExecuteAction("start") && editor.PlayheadFrame == plan.AnchorFrame,
+                            "Protect the recording anchor from transport edits during count-in");
+                        Check(!await editor.ExecuteAction("previousBar") && !await editor.ExecuteAction("nextBar") && !await editor.ExecuteAction("startAlternate") && editor.PlayheadFrame == plan.AnchorFrame,
+                            "Ignore bar navigation and Enter during count-in so the registered recording anchor cannot move");
+                        editor.SetRecordingState(false);
+                        Check(!editor.IsBusy && editor.ArmedTracksForTest.Length == 0 && editor.RecordingOverlaysForTest == 0,
+                            "Release reserved tracks and recording visuals after cancellation");
+                        editor.BeginRecordingCountdown(plan); editor.BeginRecordingCapture();
+                        var capture = new Recorder(); capture.StartBuffered(CaptureLayout.Create(2, -1), 32, Path.Combine(root, "take"), 48000, false);
+                        byte[] pcm = new byte[48000 * 2 * 2];
+                        for (int frame = 0; frame < 48000; frame++) {
+                            Buffer.BlockCopy(BitConverter.GetBytes((short)8192), 0, pcm, frame * 4, 2);
+                            Buffer.BlockCopy(BitConverter.GetBytes((short)-4096), 0, pcm, frame * 4 + 2, 2);
+                        }
+                        editor.UpdateRecordingProgress(0, 48000);
+                        Check(editor.PlayheadFrame == plan.AnchorFrame, "Keep the playhead still until input frames actually arrive");
+                        for (int second = 1; second <= 3; second++) {
+                            capture.ProcessWindowsPcm(pcm, pcm.Length, 2); editor.UpdateRecordingProgress(Interlocked.Read(ref capture.Frames), capture.SampleRate);
+                            Check(editor.PlayheadFrame == plan.AnchorFrame + second * Audio.Rate, "Advance the recording playhead by captured audio at second " + second);
+                        }
+                        Check(editor.RecordingOverlaysForTest == 2 && editor.RecordingHeadlineForTest.Contains("00:03.00"),
+                            "Show a growing recording on both destination tracks and the elapsed take time");
+                        Picture(editor, Path.Combine(root, "recording-dark.png"), 1280, 760);
+                        Picture(editor, Path.Combine(root, "recording-compact-dark.png"), 850, 560);
+                        ThemePalette.Apply(false); Picture(editor, Path.Combine(root, "recording-light.png"), 1280, 760); ThemePalette.Apply(true);
+                        capture.Stop(); await capture.Finish(); editor.ShowRecordingSaving();
+                        var originals = capture.Paths.Select(File.ReadAllBytes).ToArray();
+                        editor.SetRecordingState(false); await editor.AddRecordedFiles(capture.Paths, plan.AnchorFrame, plan.FirstTrack, true);
+                        var session = editor.SessionForTest;
+                        Check(capture.Error == null && session.Regions.Count == 2 && session.Regions.All(r => r.Start == plan.AnchorFrame && r.Length == Audio.Rate * 3L) && session.Regions.Select(r => r.Track).OrderBy(t => t).SequenceEqual(new[] { 5, 6 }),
+                            "Save and insert both recorded inputs at the registered start and tracks");
+                        Check(editor.PlayheadFrame == plan.AnchorFrame + Audio.Rate * 3L && editor.RecordingOverlaysForTest == 0 && !editor.IsBusy,
+                            "Leave the playhead at the end of the saved take and clear live recording state");
+                        Check(capture.Paths.Select((file, index) => File.ReadAllBytes(file).SequenceEqual(originals[index])).All(value => value),
+                            "Preserve original recording files while importing the take");
+                        await editor.ExecuteAction("undo");
+                        Check(editor.SessionForTest.Regions.Count == 0 && capture.Paths.All(File.Exists), "Undo the recording insertion without deleting captured audio");
+                    }
+                    owner.Content = null; owner.Close();
+                });
+                log.Add("Generated audio buffers and offscreen UI. A physical microphone/ASIO device still requires an acceptance recording.");
+                File.WriteAllLines(Path.Combine(root, "recording-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "recording-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = old; ThemePalette.Apply(old.Theme == "Dark"); }
+        }
+    }
+}