@pro-gram/flux 1.5.0 → 1.6.0

package/source/Timeline.cs

@@ -22,6 +22,8 @@ namespace DrumBuddy
         public string Id = Guid.NewGuid().ToString("N"), Source = "", Name = "";
         public int Track;
         public long Start, SourceStart, Length;
+        public long FadeIn, FadeOut, FadeInOffset, FadeOutOffset;
+        public bool Muted;
         public long End { get { return Start + Length; } }
         public TimelineRegion Copy() { return (TimelineRegion)MemberwiseClone(); }
     }
@@ -48,7 +50,7 @@ namespace DrumBuddy
                     throw new IOException("The session has an invalid track level.");
             foreach (var r in Regions)
                 if (r == null || r.Track < 0 || r.Track >= 16 || string.IsNullOrWhiteSpace(r.Source) ||
-                    r.Start < 0 || r.SourceStart < 0 || r.Length <= 0 || r.Start > MaxFrame || r.SourceStart > MaxFrame || r.Length > MaxFrame || r.End > MaxFrame)
+                    r.Start < 0 || r.SourceStart < 0 || r.Length <= 0 || r.Start > MaxFrame || r.SourceStart > MaxFrame || r.Length > MaxFrame || r.End > MaxFrame || r.FadeIn < 0 || r.FadeOut < 0 || r.FadeIn > MaxFrame || r.FadeOut > MaxFrame || r.FadeInOffset < 0 || r.FadeOutOffset < 0 || r.FadeInOffset > MaxFrame || r.FadeOutOffset > MaxFrame)
                     throw new IOException("The session has an invalid audio region.");
         }
 
@@ -82,39 +84,43 @@ namespace DrumBuddy
 
     public static class TimelineEdits
     {
-        private static bool Included(TimelineRegion region, int track, bool all) { return all || region.Track == track; }
-        public static TimelineClipboard Copy(EditorSession session, int track, bool all, long from, long to)
+        private static bool Included(TimelineRegion region, int track, bool all, ISet<string> ids = null) { return ids != null ? ids.Contains(region.Id) : all || region.Track == track; }
+        private static TimelineRegion Slice(TimelineRegion region, long from, long to)
+        {
+            var part = region.Copy(); part.Start = from; part.SourceStart += from - region.Start; part.Length = to - from;
+            part.FadeInOffset += from - region.Start; part.FadeOutOffset += region.End - to; return part;
+        }
+        public static TimelineClipboard Copy(EditorSession session, int track, bool all, long from, long to, ISet<string> ids = null)
         {
             if (from < 0 || to <= from) throw new ArgumentException("Select a time range first.");
             var copied = new TimelineClipboard { AllTracks = all, Length = to - from };
-            foreach (var r in session.Regions.Where(r => Included(r, track, all) && r.Start < to && r.End > from)) {
+            foreach (var r in session.Regions.Where(r => Included(r, track, all, ids) && r.Start < to && r.End > from)) {
                 long left = Math.Max(from, r.Start), right = Math.Min(to, r.End);
-                var part = r.Copy(); part.Id = Guid.NewGuid().ToString("N");
-                part.Start = left - from; part.SourceStart += left - r.Start; part.Length = right - left;
+                var part = Slice(r, left, right); part.Id = Guid.NewGuid().ToString("N"); part.Start -= from;
                 if (!all) part.Track = 0;
                 copied.Regions.Add(part);
             }
             return copied;
         }
-        public static bool Delete(EditorSession session, int track, bool all, long from, long to)
+        public static bool Delete(EditorSession session, int track, bool all, long from, long to, ISet<string> ids = null)
         {
             if (from < 0 || to <= from) return false;
             var result = new List<TimelineRegion>(); bool changed = false;
             foreach (var r in session.Regions) {
-                if (!Included(r, track, all) || r.Start >= to || r.End <= from) { result.Add(r); continue; }
+                if (!Included(r, track, all, ids) || r.Start >= to || r.End <= from) { result.Add(r); continue; }
                 changed = true;
-                if (r.Start < from) { var left = r.Copy(); left.Length = from - r.Start; result.Add(left); }
-                if (r.End > to) { var right = r.Copy(); right.Id = Guid.NewGuid().ToString("N"); right.Start = to; right.SourceStart += to - r.Start; right.Length = r.End - to; result.Add(right); }
+                if (r.Start < from) result.Add(Slice(r, r.Start, from));
+                if (r.End > to) { var right = Slice(r, to, r.End); right.Id = Guid.NewGuid().ToString("N"); result.Add(right); }
             }
             session.Regions = result; return changed;
         }
-        public static bool Split(EditorSession session, int track, bool all, long frame)
+        public static bool Split(EditorSession session, int track, bool all, long frame, ISet<string> ids = null)
         {
             var result = new List<TimelineRegion>(); bool changed = false;
             foreach (var r in session.Regions) {
-                if (!Included(r, track, all) || frame <= r.Start || frame >= r.End) { result.Add(r); continue; }
-                var left = r.Copy(); left.Length = frame - r.Start;
-                var right = r.Copy(); right.Id = Guid.NewGuid().ToString("N"); right.Start = frame; right.SourceStart += left.Length; right.Length -= left.Length;
+                if (!Included(r, track, all, ids) || frame <= r.Start || frame >= r.End) { result.Add(r); continue; }
+                var left = Slice(r, r.Start, frame);
+                var right = Slice(r, frame, r.End); right.Id = Guid.NewGuid().ToString("N");
                 result.Add(left); result.Add(right); changed = true;
             }
             session.Regions = result; return changed;
@@ -185,7 +191,7 @@ namespace DrumBuddy
                 long blockEnd = position + frames;
                 foreach (var r in session.Regions) {
                     var track = session.Tracks[r.Track];
-                    if (track.Mute || (solo && !track.Solo) || r.Start >= blockEnd || r.End <= position) continue;
+                    if (r.Muted || track.Mute || (solo && !track.Solo) || r.Start >= blockEnd || r.End <= position) continue;
                     long from = Math.Max(r.Start, position), to = Math.Min(r.End, blockEnd);
                     int take = (int)(to - from), skip = (int)(from - position);
                     var asset = assets[r.Source]; int channels = asset.Reader.WaveFormat.Channels;
@@ -198,8 +204,9 @@ namespace DrumBuddy
                     Buffer.BlockCopy(asset.Bytes, 0, asset.Samples, 0, got);
                     float gain = (float)Math.Pow(10, track.GainDb / 20);
                     for (int f = 0; f < take; f++) {
-                        float left = asset.Samples[f * channels] * gain;
-                        float right = asset.Samples[f * channels + (channels == 1 ? 0 : 1)] * gain;
+                        float envelope = (float)EditorTools.Envelope(r, from + f - r.Start);
+                        float left = asset.Samples[f * channels] * gain * envelope;
+                        float right = asset.Samples[f * channels + (channels == 1 ? 0 : 1)] * gain * envelope;
                         output[offset + (skip + f) * 2] += left; output[offset + (skip + f) * 2 + 1] += right;
                         TrackPeaks[r.Track] = Math.Max(TrackPeaks[r.Track], Math.Max(Math.Abs(left), Math.Abs(right)));
                     }

package/source/TimelineZoom.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace DrumBuddy
+{
+    internal static class TimelineZoom
+    {
+        public const double Minimum = .01, Maximum = Audio.Rate * 2;
+        public static double Clamp(double value)
+        { return double.IsNaN(value) || double.IsInfinity(value) ? 40 : Math.Max(Minimum, Math.Min(Maximum, value)); }
+        public static double Offset(double oldScale, double newScale, double offset, double pointer)
+        { return Math.Max(0, (Math.Max(0, offset) + Math.Max(0, pointer)) / oldScale * newScale - Math.Max(0, pointer)); }
+        public static double Fit(long frames, double width)
+        { return Clamp(Math.Max(1, width - 32) * Audio.Rate / Math.Max(1, frames)); }
+        public static double SecondStep(double scale)
+        {
+            double desired = 70 / scale, power = Math.Pow(10, Math.Floor(Math.Log10(desired)));
+            double unit = desired / power;
+            return (unit <= 1 ? 1 : unit <= 2 ? 2 : unit <= 5 ? 5 : 10) * power;
+        }
+    }
+}

package/source/WaveformDetail.cs

@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Threading;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    internal sealed class WaveformEnvelope
+    {
+        public float[] Low, High;
+    }
+
+    // Small viewport envelopes are read from the decoded float cache off the UI thread.
+    // The full-file overview remains available immediately while detail is loading.
+    internal sealed class WaveformDetail : IDisposable
+    {
+        private readonly Dispatcher dispatcher;
+        private readonly Action refresh;
+        private readonly SemaphoreSlim gate = new SemaphoreSlim(2);
+        private readonly Dictionary<string, WaveformEnvelope> ready = new Dictionary<string, WaveformEnvelope>();
+        private readonly Queue<string> order = new Queue<string>();
+        private readonly HashSet<string> pending = new HashSet<string>(), failed = new HashSet<string>();
+        private CancellationTokenSource cancellation = new CancellationTokenSource();
+        private string view;
+        private volatile bool disposed;
+        public WaveformDetail(Dispatcher dispatcher, Action refresh) { this.dispatcher = dispatcher; this.refresh = refresh; }
+        public void BeginView(string key)
+        {
+            if (view == key) return;
+            view = key; cancellation.Cancel(); cancellation.Dispose(); cancellation = new CancellationTokenSource(); failed.Clear();
+        }
+        public WaveformEnvelope Get(string file, long start, long end, int columns)
+        {
+            if (disposed || string.IsNullOrEmpty(file) || end <= start || end - start > Audio.Rate * 12L) return null;
+            columns = Math.Max(2, Math.Min(2000, columns));
+            string key = file + "|" + start + "|" + end + "|" + columns;
+            WaveformEnvelope result;
+            if (ready.TryGetValue(key, out result)) return result;
+            if (pending.Contains(key) || failed.Contains(key)) return null;
+            pending.Add(key); var token = cancellation.Token;
+            Load(key, file, start, end, columns, token);
+            return null;
+        }
+        private async void Load(string key, string file, long start, long end, int columns, CancellationToken token)
+        {
+            WaveformEnvelope result = null; bool error = false;
+            try {
+                await gate.WaitAsync(token).ConfigureAwait(false);
+                try { result = await Task.Run(() => Read(file, start, end, columns, token), token).ConfigureAwait(false); }
+                finally { gate.Release(); }
+            }
+            catch (OperationCanceledException) { }
+            catch (Exception) { error = true; }
+            if (disposed || dispatcher.HasShutdownStarted) return;
+            try { await dispatcher.InvokeAsync((Action)delegate {
+                pending.Remove(key);
+                if (disposed) return;
+                if (result != null) {
+                    ready[key] = result; order.Enqueue(key);
+                    while (order.Count > 64) ready.Remove(order.Dequeue());
+                }
+                if (!token.IsCancellationRequested) { if (error) failed.Add(key); refresh(); }
+            }).Task.ConfigureAwait(false); }
+            catch (TaskCanceledException) { }
+        }
+        internal static WaveformEnvelope Read(string file, long start, long end, int columns, CancellationToken token)
+        {
+            token.ThrowIfCancellationRequested();
+            if (start < 0 || end <= start || end - start > Audio.Rate * 12L || columns < 2 || columns > 2000) throw new ArgumentOutOfRangeException("start");
+            using (var reader = new WaveFileReader(file)) {
+                int channels = reader.WaveFormat.Channels;
+                if (reader.WaveFormat.BitsPerSample != 32 || reader.WaveFormat.SampleRate != Audio.Rate || channels < 1 || channels > 2) throw new IOException("Unexpected waveform cache format.");
+                long frames = reader.Length / (4 * channels), count = end - start;
+                var result = new WaveformEnvelope { Low = new float[columns], High = new float[columns] };
+                for (int i = 0; i < columns; i++) { result.Low[i] = float.PositiveInfinity; result.High[i] = float.NegativeInfinity; }
+                reader.Position = Math.Min(start, frames) * 4 * channels;
+                var bytes = new byte[32768]; var values = new float[bytes.Length / 4];
+                long position = start, limit = Math.Min(end, frames);
+                while (position < limit) {
+                    token.ThrowIfCancellationRequested();
+                    int requested = (int)Math.Min(bytes.Length, (limit - position) * 4 * channels);
+                    int read = reader.Read(bytes, 0, requested); if (read == 0) break;
+                    Buffer.BlockCopy(bytes, 0, values, 0, read);
+                    int readFrames = read / (4 * channels);
+                    for (int i = 0; i < readFrames; i++, position++) {
+                        int first = (int)((position - start) * columns / count);
+                        int last = (int)Math.Min(columns - 1, Math.Ceiling((position - start + 1) * (double)columns / count) - 1);
+                        for (int ch = 0; ch < channels; ch++) {
+                            float value = values[i * channels + ch];
+                            if (float.IsNaN(value) || float.IsInfinity(value)) continue;
+                            for (int bin = first; bin <= last && bin < columns; bin++) { result.Low[bin] = Math.Min(result.Low[bin], value); result.High[bin] = Math.Max(result.High[bin], value); }
+                        }
+                    }
+                }
+                for (int i = 0; i < columns; i++) if (float.IsInfinity(result.Low[i])) result.Low[i] = result.High[i] = 0;
+                return result;
+            }
+        }
+        public void Dispose() { disposed = true; cancellation.Cancel(); cancellation.Dispose(); ready.Clear(); }
+    }
+}

package/source/WindowsAudioPlayer.cs

@@ -0,0 +1,137 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Runtime.InteropServices;
+using NAudio.CoreAudioApi;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    // One COM apartment owns activation, initialization, rendering and release.
+    // Audio is already converted to the endpoint's exact mix format: ask Windows
+    // for a normal shared stream, without a second automatic converter or WinMM.
+    internal sealed class WindowsAudioPlayer : IWavePlayer, IWavePosition
+    {
+        [DllImport("avrt.dll", CharSet = CharSet.Unicode)] private static extern IntPtr AvSetMmThreadCharacteristics(string task, out uint index);
+        [DllImport("avrt.dll")] private static extern bool AvRevertMmThreadCharacteristics(IntPtr handle);
+        private readonly ISampleProvider source;
+        private readonly string endpointId;
+        private readonly bool events;
+        private readonly int latency;
+        private readonly Thread worker;
+        private readonly AutoResetEvent command = new AutoResetEvent(false), available = new AutoResetEvent(false);
+        private readonly ManualResetEvent initialized = new ManualResetEvent(false), started = new ManualResetEvent(false);
+        private volatile PlaybackState state;
+        private volatile bool stopping, disposed, closed;
+        private Exception failure;
+        private GainProvider deviceGain;
+        private long played;
+        private bool playedOnce;
+        public CountedPlayback Counter { get; private set; }
+        public WaveFormat OutputFormat { get; private set; }
+        public WaveFormat OutputWaveFormat { get { return OutputFormat; } }
+        public string Description { get; private set; }
+        public event EventHandler<StoppedEventArgs> PlaybackStopped;
+        public PlaybackState PlaybackState { get { return state; } }
+        public float Volume { get { return deviceGain == null ? 1 : (float)deviceGain.Gain; } set { if (deviceGain != null) deviceGain.Gain = Math.Max(0, Math.Min(1, value)); } }
+        internal static AudioClientStreamFlags Flags(bool eventDriven)
+        { return eventDriven ? AudioClientStreamFlags.EventCallback : AudioClientStreamFlags.None; }
+        public WindowsAudioPlayer(ISampleProvider source, string endpointId, bool events, int latency)
+        {
+            this.source = source; this.endpointId = endpointId; this.events = events; this.latency = Math.Max(40, Math.Min(250, latency));
+            worker = new Thread(Render) { IsBackground = true, Name = "Flux Windows audio" };
+            worker.SetApartmentState(ApartmentState.MTA); worker.Start();
+            if (!initialized.WaitOne(8000)) { Dispose(); throw new IOException("Windows audio did not finish opening the selected device."); }
+            if (failure != null) { var error = failure; Dispose(); throw error; }
+        }
+        public void Init(IWaveProvider provider) { throw new InvalidOperationException("This output is initialized from the editor's sample source."); }
+        public void Play()
+        {
+            if (disposed || closed) throw failure ?? new ObjectDisposedException("Windows audio output");
+            state = PlaybackState.Playing; command.Set();
+            if (!playedOnce) {
+                playedOnce = true;
+                if (!started.WaitOne(8000)) { Stop(); throw new IOException("Windows audio did not start the selected device."); }
+                if (failure != null) throw failure;
+            }
+        }
+        public void Pause() { if (!disposed && !closed) { state = PlaybackState.Paused; command.Set(); } }
+        public void Stop()
+        {
+            if (closed) return;
+            stopping = true; command.Set();
+            if (Thread.CurrentThread != worker) worker.Join(2500);
+        }
+        public long GetPosition() { return Interlocked.Read(ref played) * (OutputFormat == null ? 0 : OutputFormat.BlockAlign); }
+        private void Render()
+        {
+            bool running = false, wasInitialized = false, attemptedPlay = false;
+            string stage = "activate selected endpoint";
+            MMDevice device = null; AudioClient client = null; AudioRenderClient render = null;
+            IntPtr scheduling = IntPtr.Zero;
+            try {
+                uint taskIndex; scheduling = AvSetMmThreadCharacteristics("Audio", out taskIndex);
+                using (var enumerator = new MMDeviceEnumerator()) device = string.IsNullOrEmpty(endpointId)
+                    ? enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console) : enumerator.GetDevice(endpointId);
+                if (device.State != DeviceState.Active) throw new IOException("The selected audio device is disconnected or disabled.");
+                stage = "read device mix format"; client = device.AudioClient; OutputFormat = client.MixFormat;
+                Counter = new CountedPlayback(AudioOutputs.Adapt(source, OutputFormat.SampleRate, OutputFormat.Channels));
+                deviceGain = new GainProvider(Counter) { Gain = 1 };
+                var wire = new EndpointWaveProvider(deviceGain, OutputFormat);
+                stage = "initialize native shared stream";
+                client.Initialize(AudioClientShareMode.Shared, Flags(events), latency * 10000L, 0, OutputFormat, Guid.Empty);
+                if (events) client.SetEventHandle(available.SafeWaitHandle.DangerousGetHandle());
+                render = client.AudioRenderClient;
+                int capacity = client.BufferSize, align = OutputFormat.BlockAlign;
+                var bytes = new byte[checked(capacity * align)];
+                var wait = events ? new WaitHandle[] { command, available } : new WaitHandle[] { command };
+                long submitted = 0; bool eof = false;
+                Description = device.FriendlyName + " — Windows shared audio — " + OutputFormat.SampleRate + " Hz";
+                wasInitialized = true; initialized.Set();
+                while (!stopping && !disposed) {
+                    if (state != PlaybackState.Playing) {
+                        if (running) { stage = "pause shared stream"; client.Stop(); running = false; Interlocked.Exchange(ref played, Math.Max(0, submitted - client.CurrentPadding)); }
+                        command.WaitOne(); continue;
+                    }
+                    attemptedPlay = true;
+                    stage = "query render buffer";
+                    int padding = client.CurrentPadding;
+                    Interlocked.Exchange(ref played, Math.Max(0, submitted - padding));
+                    if (eof && padding == 0) break;
+                    int frames = capacity - padding;
+                    if (!eof && frames > 0) {
+                        stage = "read decoded audio";
+                        int read = wire.Read(bytes, 0, frames * align);
+                        if (read % align != 0) throw new IOException("The decoded audio ended inside an output frame.");
+                        int filled = read / align;
+                        if (filled == 0) eof = true;
+                        else {
+                            stage = "submit audio buffer";
+                            IntPtr buffer = render.GetBuffer(filled);
+                            Marshal.Copy(bytes, 0, buffer, read); render.ReleaseBuffer(filled, AudioClientBufferFlags.None); submitted += filled;
+                        }
+                    }
+                    if (!running && submitted > 0) { stage = "start shared stream"; client.Start(); running = true; started.Set(); }
+                    if (eof && submitted == 0) break;
+                    WaitHandle.WaitAny(wait, events ? latency : Math.Max(2, Math.Min(10, latency / 4)));
+                }
+            }
+            catch (Exception ex) { failure = new IOException("Windows audio failed at " + stage + ": " + ex.Message + " (0x" + ex.HResult.ToString("X8") + ")", ex); }
+            finally {
+                if (running && client != null) try { client.Stop(); } catch { }
+                if (render != null) try { render.Dispose(); } catch { }
+                if (client != null) try { client.Dispose(); } catch { }
+                if (device != null) try { device.Dispose(); } catch { }
+                if (scheduling != IntPtr.Zero) AvRevertMmThreadCharacteristics(scheduling);
+                state = PlaybackState.Stopped; closed = true; initialized.Set(); started.Set();
+                if (wasInitialized && attemptedPlay) { var handler = PlaybackStopped; if (handler != null) handler(this, new StoppedEventArgs(failure)); }
+            }
+        }
+        public void Dispose()
+        {
+            if (disposed) return;
+            disposed = true; Stop();
+            if (!worker.IsAlive) { command.Dispose(); available.Dispose(); initialized.Dispose(); started.Dispose(); }
+        }
+    }
+}

package/source/WorkspaceTests.cs

@@ -53,16 +53,20 @@ namespace DrumBuddy
                     using (var read = new StringReader(xml.ToString())) {
                         var reopenedPreference = (Preferences)serializer.Deserialize(read);
                         Check(reopenedPreference.AudioInputKey == preference.AudioInputKey && reopenedPreference.AudioOutputKey == preference.AudioOutputKey,
-                            "Save and reload both microphone and compatibility-output selections");
+                            "Read legacy microphone/output preferences before migrating retired output identifiers");
                     }
                 }
                 var pickerA = new AudioOutputPicker(delegate { }, delegate(string text) { }); var pickerB = new AudioOutputPicker(delegate { }, delegate(string text) { });
                 string previousOutput = AudioOutputs.PreferredKey;
                 pickerA.RaiseEvent(new RoutedEventArgs(FrameworkElement.LoadedEvent)); pickerB.RaiseEvent(new RoutedEventArgs(FrameworkElement.LoadedEvent));
                 try {
+                    string namedKey = AudioOutputs.Choices().First(c => c.EndpointId != null).Key;
+                    AudioOutputs.PreferredKey = namedKey;
+                    Check(pickerA.Selected != null && pickerB.Selected != null && pickerA.Selected.Key == namedKey && pickerB.Selected.Key == namedKey,
+                        "Synchronize both loaded playback selectors to a real Windows endpoint");
                     AudioOutputs.PreferredKey = "compat:default";
-                    Check(pickerA.Selected != null && pickerB.Selected != null && pickerA.Selected.Key == "compat:default" && pickerB.Selected.Key == "compat:default",
-                        "Synchronize loaded playback selectors when the shared output changes");
+                    Check(pickerA.Selected != null && pickerB.Selected != null && pickerA.Selected.Key == "default" && pickerB.Selected.Key == "default",
+                        "Migrate a retired compatibility selection to the displayed Windows default in both selectors");
                 }
                 finally { AudioOutputs.PreferredKey = previousOutput; pickerA.RaiseEvent(new RoutedEventArgs(FrameworkElement.UnloadedEvent)); pickerB.RaiseEvent(new RoutedEventArgs(FrameworkElement.UnloadedEvent)); }
                 float[] precise = Enumerable.Range(0, 500).Select(i => (float)(i + 1) / 100).ToArray();

package/source/ZoomTests.cs

@@ -0,0 +1,95 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+
+namespace DrumBuddy
+{
+    public static class ZoomTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string name) { if (!value) throw new Exception(name); log.Add("PASS  " + name); }
+        private static void Wait(Func<bool> ready)
+        {
+            var watch = Stopwatch.StartNew(); var frame = new DispatcherFrame();
+            var timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(10) };
+            timer.Tick += delegate { if (ready() || watch.ElapsedMilliseconds > 5000) { timer.Stop(); frame.Continue = false; } };
+            timer.Start(); Dispatcher.PushFrame(frame);
+        }
+        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 bitmap = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); 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(), "FluxZoom_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var previous = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); ThemePalette.Apply(true);
+                Check(TimelineZoom.Clamp(double.PositiveInfinity) == 40 && TimelineZoom.Clamp(-1) == .01 && TimelineZoom.Clamp(1e8) == Audio.Rate * 2, "Bound invalid and extreme zoom levels without invalid WPF dimensions");
+                Check(TimelineZoom.Fit(Audio.Rate * 86400L, 1000) * 86400 <= 1000, "Fit a 24-hour session into the viewport");
+                Check(TimelineZoom.SecondStep(Audio.Rate * 2) < .002, "Use fractional-second ruler marks at sample-level zoom");
+                Check(InterfacePreferences.Resolve(Key.OemPlus, ModifierKeys.Control) == "zoomIn" && InterfacePreferences.Resolve(Key.D0, ModifierKeys.Control | ModifierKeys.Shift) == "zoomSelection", "Expose editable zoom and fit shortcuts");
+                var legacy = InterfacePreferences.Defaults(); legacy.Keybinds.RemoveAll(b => b.Action.StartsWith("zoom"));
+                legacy.Keybinds.First(b => b.Action == "play").Key = "D0"; legacy.Keybinds.First(b => b.Action == "play").Modifiers = (int)ModifierKeys.Control; InterfacePreferences.Upgrade(legacy);
+                Check(legacy.Keybinds.First(b => b.Action == "zoomFit").Key == "None" && legacy.Keybinds.First(b => b.Action == "play").Key == "D0", "Preserve a custom binding that conflicts with the new Fit shortcut");
+                string file = Path.Combine(root, "Original stereo float.wav"); var samples = new float[Audio.Rate * 4 * 2];
+                for (int i = 0; i < samples.Length / 2; i++) { samples[i * 2] = (float)(.4 * Math.Sin(i * .05)); samples[i * 2 + 1] = -samples[i * 2]; }
+                samples[2000] = .8f; samples[2001] = -.6f; samples[2002] = .1f; samples[2003] = -1.2f;
+                using (var writer = new FloatWaveWriter(file, 2, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+                byte[] original = File.ReadAllBytes(file);
+                var detail = WaveformDetail.Read(file, 1000, 1002, 8, CancellationToken.None);
+                Check(detail.High.Take(4).All(v => v == .8f) && detail.Low.Take(4).All(v => v == -.6f), "Read actual positive and negative stereo samples at the requested source offset");
+                Check(detail.Low.Skip(4).All(v => v == -1.2f) && detail.High.Skip(4).All(v => v == .1f), "Preserve float headroom and opposite-phase channel detail when zoomed in");
+                var cancelled = new CancellationTokenSource(); cancelled.Cancel(); bool stopped = false;
+                try { WaveformDetail.Read(file, 0, 100, 10, cancelled.Token); } catch (OperationCanceledException) { stopped = true; }
+                Check(stopped, "Cancel an obsolete waveform request before reading samples");
+                bool bounded = false; try { WaveformDetail.Read(file, 0, Audio.Rate * 13L, 100, CancellationToken.None); } catch (ArgumentOutOfRangeException) { bounded = true; }
+                Check(bounded, "Bound each detailed waveform read instead of loading the full recording");
+                var clip = new Clip { Source = file, Cache = file, Name = "Stereo hit", Channels = 2, Duration = 4, Peak = 1.2, Waveform = Enumerable.Repeat(1.2f, 900).ToArray(), Ready = true };
+                var session = new EditorSession { Name = "Zoom detail" };
+                session.Regions.Add(new TimelineRegion { Source = file, Name = "Stereo hit", Track = 0, Start = Audio.Rate * 5L, SourceStart = 1000, Length = Audio.Rate * 2L });
+                var owner = new Window(); ThemePalette.Install(owner);
+                using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate { }, delegate { })) {
+                    owner.Content = editor; editor.SetForTest(session, new Dictionary<string, Clip> { { file, clip } });
+                    Picture(editor, Path.Combine(root, "zoom-overview.png"), 1100, 650);
+                    editor.ZoomForTest(80); editor.OffsetForTestSet(300); double before = (editor.OffsetForTest + 205) / editor.ZoomPixelsForTest;
+                    editor.ZoomAtForTest(640, 205);
+                    Check(Math.Abs((editor.OffsetForTest + 205) / editor.ZoomPixelsForTest - before) < 1.0 / Audio.Rate, "Keep the exact time under the pointer while zooming a scrolled timeline");
+                    Wait(() => editor.DetailsForTest > 0);
+                    Check(editor.DetailsForTest > 0, "Replace the overview with a real sample envelope asynchronously");
+                    editor.ShowSelectionForTest(Audio.Rate * 5L + 10000, Audio.Rate * 5L + 11000);
+                    editor.ExecuteAction("zoomSelection").GetAwaiter().GetResult();
+                    double first = (Audio.Rate * 5L + 10000) / (double)Audio.Rate * editor.ZoomPixelsForTest - editor.OffsetForTest;
+                    double last = (Audio.Rate * 5L + 11000) / (double)Audio.Rate * editor.ZoomPixelsForTest - editor.OffsetForTest;
+                    Check(first >= 0 && last <= editor.WidthForTest && last - first >= editor.WidthForTest - 34, "Fit the selected hit into the visible timeline with a small margin");
+                    Wait(() => editor.DetailsForTest > 0); Picture(editor, Path.Combine(root, "zoom-selected-hit.png"), 1100, 650);
+                    editor.ExecuteAction("zoomIn").GetAwaiter().GetResult(); editor.ExecuteAction("zoomOut").GetAwaiter().GetResult();
+                    Check(!editor.Dirty && editor.PlayheadFrame == 0 && editor.SessionForTest.Regions[0].SourceStart == 1000, "Zoom leaves the playhead, source offsets and undo/dirty state unchanged");
+                    editor.ExecuteAction("zoomFit").GetAwaiter().GetResult();
+                    Check(editor.OffsetForTest == 0 && session.End / (double)Audio.Rate * editor.ZoomPixelsForTest <= editor.WidthForTest, "Fit all project audio and return the view to the start");
+                    Picture(editor, Path.Combine(root, "zoom-compact.png"), 700, 480);
+                    Check(editor.WidthForTest > 300, "Keep an accessible timeline and zoom strip in a compact editor");
+                    editor.ZoomForTest(Audio.Rate * 2); editor.OffsetForTestSet(Audio.Rate * 5 * editor.ZoomPixelsForTest / Audio.Rate);
+                    Wait(() => editor.DetailsForTest > 0); Picture(editor, Path.Combine(root, "zoom-samples.png"), 1100, 650);
+                }
+                owner.Content = null; owner.Close();
+                Check(original.SequenceEqual(File.ReadAllBytes(file)), "Preserve the original audio bytes through detailed reads and zoom operations");
+                File.WriteAllLines(Path.Combine(root, "zoom-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "zoom-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = previous; ThemePalette.Apply(previous.Theme == "Dark"); }
+        }
+    }
+}