@pro-gram/flux 0.0.0-stage → 1.6.0

package/source/Uninstall.cs

@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Diagnostics;
+using System.Threading;
+using System.Windows.Forms;
+using Microsoft.Win32;
+
+public static class Uninstall
+{
+    private static string Target { get { return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),"Programs","DrumBuddy"); } }
+    [STAThread]
+    public static int Main(string[] args)
+    {
+        if (args.Length == 1 && args[0] == "--remove-installed-files") {
+            Thread.Sleep(1500);
+            if (!File.Exists(Path.Combine(Target,".drumbuddy-installed"))) return 1;
+            try {
+                string root = Path.GetFullPath(Target).TrimEnd('\\') + "\\";
+                string[] files = File.ReadAllLines(Path.Combine(Target,"installed-files.txt"));
+                foreach (string relative in files) {
+                    string full = Path.GetFullPath(Path.Combine(root,relative));
+                    if (!full.StartsWith(root,StringComparison.OrdinalIgnoreCase) || relative.Contains(":")) continue;
+                    for (int retry = 0; retry < 20; retry++) {
+                        try { if (File.Exists(full)) File.Delete(full); break; }
+                        catch (IOException) { Thread.Sleep(250); }
+                    }
+                }
+                foreach (string dir in Directory.GetDirectories(root,"*",SearchOption.AllDirectories).OrderByDescending(d => d.Length))
+                    if (!Directory.EnumerateFileSystemEntries(dir).Any()) Directory.Delete(dir);
+                if (!Directory.EnumerateFileSystemEntries(root).Any()) Directory.Delete(root);
+                Registry.CurrentUser.DeleteSubKeyTree(@"Software\Microsoft\Windows\CurrentVersion\Uninstall\DrumBuddy",false);
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),"Flux.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),"Programs","Flux.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),"Flux Audio.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),"Programs","Flux Audio.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),"FluxTempo.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),"Programs","FluxTempo.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory),"Drum Buddy.lnk"));
+                RemoveShortcut(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu),"Programs","Drum Buddy.lnk"));
+                return 0;
+            }
+            catch (Exception ex) { MessageBox.Show("Some program files could not be removed. Your audio files were kept.\n\n" + ex.Message,"Flux"); return 1; }
+        }
+        if (!string.Equals(Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory).TrimEnd('\\'),Target,StringComparison.OrdinalIgnoreCase) || !File.Exists(Path.Combine(Target,".drumbuddy-installed"))) {
+            MessageBox.Show("This uninstaller can only remove the installed copy of Flux.","Flux"); return 1;
+        }
+        if (Process.GetProcessesByName("DrumBuddy").Length > 0) { MessageBox.Show("Close Flux before uninstalling.","Flux"); return 1; }
+        if (MessageBox.Show("Remove Flux?\n\nYour recordings, exported WAV files, and Zoom driver will be kept.","Uninstall Flux",MessageBoxButtons.YesNo,MessageBoxIcon.Question) != DialogResult.Yes) return 0;
+        string temporary = Path.Combine(Path.GetTempPath(),"DrumBuddy-Uninstall-" + Guid.NewGuid().ToString("N") + ".exe");
+        File.Copy(Assembly.GetExecutingAssembly().Location,temporary);
+        Process.Start(new ProcessStartInfo(temporary,"--remove-installed-files") { UseShellExecute = false, CreateNoWindow = true }); return 0;
+    }
+    private static void RemoveShortcut(string path)
+    {
+        if (!File.Exists(path)) return;
+        object shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell"));
+        try {
+            object link = shell.GetType().InvokeMember("CreateShortcut",BindingFlags.InvokeMethod,null,shell,new object[] { path });
+            try {
+                string target = (string)link.GetType().InvokeMember("TargetPath",BindingFlags.GetProperty,null,link,null);
+                if (string.Equals(target,Path.Combine(Target,"DrumBuddy.exe"),StringComparison.OrdinalIgnoreCase)) File.Delete(path);
+            }
+            finally { System.Runtime.InteropServices.Marshal.FinalReleaseComObject(link); }
+        }
+        finally { System.Runtime.InteropServices.Marshal.FinalReleaseComObject(shell); }
+    }
+}

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

@@ -0,0 +1,202 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DrumBuddy
+{
+    public static class WorkspaceTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool ok, string message) { if (!ok) throw new Exception(message); log.Add("PASS  " + message); }
+        private static Clip Source(string root, string name, float[] values, int channels)
+        {
+            string path = Path.Combine(root, name + ".wav");
+            using (var writer = new FloatWaveWriter(path, channels, Audio.Rate)) writer.Write(values, values.Length, 1);
+            return Audio.Load(path, Path.Combine(root, "cache"), CancellationToken.None, null);
+        }
+        private static float[] Render(EditorSession session, IDictionary<string, Clip> decoded)
+        {
+            using (var mix = new TimelineMix(session, decoded)) {
+                var result = new List<float>(); var block = new float[126]; int read;
+                while ((read = mix.Read(block, 0, block.Length)) > 0) result.AddRange(block.Take(read));
+                return result.ToArray();
+            }
+        }
+        private static void Picture(FrameworkElement view, string path, 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);
+            var background = new DrawingVisual(); using (var drawing = background.RenderOpen()) drawing.DrawRectangle(WorkspaceUi.Color("#F3F5F5"), null, new Rect(0, 0, width, height));
+            image.Render(background); image.Render(view);
+            var png = new PngBitmapEncoder(); png.Frames.Add(BitmapFrame.Create(image)); using (var file = File.Create(path)) png.Save(file);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "DrumBuddyWorkspace_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear();
+            try {
+                PlaybackTests.Offline(Check);
+                var preference = new Preferences { AudioOutputKey = "compat:default", AudioInputKey = "input:microphone" };
+                var serializer = new System.Xml.Serialization.XmlSerializer(typeof(Preferences));
+                using (var xml = new StringWriter()) {
+                    serializer.Serialize(xml, preference);
+                    using (var read = new StringReader(xml.ToString())) {
+                        var reopenedPreference = (Preferences)serializer.Deserialize(read);
+                        Check(reopenedPreference.AudioInputKey == preference.AudioInputKey && reopenedPreference.AudioOutputKey == preference.AudioOutputKey,
+                            "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 == "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();
+                Clip ramp = Source(root, "Precise float source", precise, 1);
+                byte[] original = File.ReadAllBytes(ramp.Source);
+                var decoded = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { ramp.Source, ramp } };
+                var session = new EditorSession();
+                session.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Ramp", Track = 0, Start = 100, SourceStart = 20, Length = 100 });
+                var baseline = Render(session, decoded);
+                Check(baseline.Length == 400 && baseline.Take(200).All(v => v == 0), "Render silence before a region and stop exactly at the timeline end");
+                Check(Math.Abs(baseline[200] - precise[20]) < .000001 && baseline[200] == baseline[201] && Math.Abs(baseline[398] - precise[119]) < .000001,
+                    "Use exact source-frame offsets and duplicate mono correctly into stereo");
+                var sixteen = new EditorSession();
+                for (int i = 0; i < 16; i++) sixteen.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Input " + (i + 1), Track = i, Start = 0, SourceStart = 0, Length = 1 });
+                Check(Math.Abs(Render(sixteen, decoded)[0] - precise[0] * 16) < .000001, "Mix audio from all 16 editor tracks simultaneously");
+                Clip stereo = Source(root, "Stereo separation", Enumerable.Range(0, 512).Select(i => i % 2 == 0 ? .5f : -.25f).ToArray(), 2);
+                var stereoState = new EditorSession(); stereoState.Regions.Add(new TimelineRegion { Source = stereo.Source, Name = "Stereo", Track = 0, Start = 0, SourceStart = 10, Length = 100 });
+                var stereoAudio = Render(stereoState, new Dictionary<string, Clip> { { stereo.Source, stereo } });
+                Check(stereoAudio.Where((v, i) => i % 2 == 0).All(v => v == .5f) && stereoAudio.Where((v, i) => i % 2 == 1).All(v => v == -.25f), "Preserve stereo channel separation when trimming and mixing");
+                using (var mix = new TimelineMix(session, decoded)) {
+                    mix.Seek(150); var block = new float[4]; mix.Read(block, 0, 4);
+                    Check(Math.Abs(block[0] - precise[70]) < .000001 && mix.Position == 152, "Seek into a region without losing source position");
+                }
+                var split = session.Copy(); TimelineEdits.Split(split, 0, false, 150);
+                Check(split.Regions.Count == 2 && split.Regions[1].Start == 150 && split.Regions[1].SourceStart == 70 && Render(split, decoded).SequenceEqual(baseline),
+                    "Split audio without changing any rendered sample or timing");
+                var cut = session.Copy(); TimelineEdits.Delete(cut, 0, false, 130, 170); var cutAudio = Render(cut, decoded);
+                Check(cut.Regions.Count == 2 && cut.Regions[0].Length == 30 && cut.Regions[1].Start == 170 && cut.Regions[1].SourceStart == 90,
+                    "Cut the middle of a clip into correctly trimmed left and right regions");
+                Check(cutAudio.Skip(260).Take(80).All(v => v == 0) && cutAudio.Take(260).SequenceEqual(baseline.Take(260)) && cutAudio.Skip(340).SequenceEqual(baseline.Skip(340)),
+                    "Leave the cut gap while preserving all unselected samples and alignment");
+                var copied = TimelineEdits.Copy(session, 0, false, 120, 180); var pasted = session.Copy();
+                TimelineEdits.Paste(pasted, copied, 15, 300); var lastTrack = pasted.Regions.Last();
+                Check(lastTrack.Track == 15 && lastTrack.Start == 300 && lastTrack.SourceStart == 40 && lastTrack.Length == 60,
+                    "Copy a partial section and paste it into track 16 at the playhead");
+                Check(Math.Abs(Render(pasted, decoded)[600] - precise[40]) < .000001, "Render pasted audio from the copied source range");
+                var group = session.Copy(); group.Regions.Add(new TimelineRegion { Source = ramp.Source, Name = "Other", Track = 15, Start = 140, SourceStart = 5, Length = 30 });
+                var groupCopy = TimelineEdits.Copy(group, 0, true, 120, 180); TimelineEdits.Paste(group, groupCopy, 7, 500);
+                Check(group.Regions.Any(r => r.Track == 0 && r.Start == 500) && group.Regions.Any(r => r.Track == 15 && r.Start == 520),
+                    "Copy all-track selections with original track numbers and relative timing");
+                var selectedOnly = group.Copy(); TimelineEdits.Delete(selectedOnly, 0, false, 0, 1000);
+                Check(selectedOnly.Regions.All(r => r.Track == 15), "Limit selected-track cuts to that track");
+                var invalid = session.Copy(); invalid.Regions[0].Track = 16; bool blocked = false;
+                try { invalid.Validate(); } catch (IOException) { blocked = true; }
+                Check(blocked, "Reject a track beyond the 16-track editor limit");
+                string saved = Path.Combine(root, "Practice.dbedit"); group.Save(saved); var reopened = EditorSession.Load(saved);
+                Check(reopened.Tracks.Length == 16 && Render(reopened, decoded).SequenceEqual(Render(group, decoded)), "Save and reopen editor sessions without changing edited audio");
+                var clone = group.Copy(); clone.Regions[0].Length = 1; clone.Tracks[0].GainDb = -12;
+                Check(group.Regions[0].Length != 1 && group.Tracks[0].GainDb == 0, "Keep undo snapshots independent of later region and track edits");
+                bool protectedSource = false; try { group.Save(ramp.Source); } catch (IOException) { protectedSource = true; }
+                Check(protectedSource && original.SequenceEqual(File.ReadAllBytes(ramp.Source)), "Refuse to save a session over original audio");
+
+                Clip left = Source(root, "Kick", Enumerable.Repeat(.6f, Audio.Rate).ToArray(), 1);
+                Clip right = Source(root, "Snare", Enumerable.Repeat(.7f, Audio.Rate).ToArray(), 1);
+                var mixedAssets = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { left.Source, left }, { right.Source, right } };
+                var mixState = new EditorSession { Name = "Practice mix" };
+                mixState.Regions.Add(new TimelineRegion { Source = left.Source, Name = "Kick", Track = 0, Start = 0, Length = Audio.Rate });
+                mixState.Regions.Add(new TimelineRegion { Source = right.Source, Name = "Snare", Track = 1, Start = 0, Length = Audio.Rate });
+                Check(Render(mixState, mixedAssets).All(v => Math.Abs(v - 1.3f) < .00001), "Mix simultaneous tracks in float without clipping over-0-dBFS samples");
+                using (var mix = new TimelineMix(mixState, mixedAssets)) {
+                    var listening = AudioOutputs.Adapt(mix, 48000, 2); var samples = new float[400]; int count = listening.Read(samples, 0, samples.Length);
+                    Check(listening.WaveFormat.SampleRate == 48000 && count == 400 && samples.All(v => Math.Abs(v) <= 1),
+                        "Adapt the float editor mix to the endpoint rate and bound its listening samples");
+                }
+                var solo = mixState.Copy(); solo.Tracks[1].Solo = true;
+                Check(Render(solo, mixedAssets).All(v => Math.Abs(v - .7f) < .00001), "Solo isolates the chosen editor track");
+                solo.Tracks[1].Mute = true; Check(Render(solo, mixedAssets).All(v => v == 0), "Mute silences a soloed track without leaking other tracks");
+                var level = mixState.Copy(); level.Tracks[0].GainDb = -6; level.Tracks[1].Mute = true;
+                Check(Math.Abs(Render(level, mixedAssets)[0] - .6 * Math.Pow(10, -.3)) < .00001, "Apply track level changes in the timeline mix");
+                foreach (int bits in new[] { 16, 24, 32 }) {
+                    string path = Path.Combine(root, "editor-mix-" + bits + ".wav");
+                    TimelineRender.Export(mixState, mixedAssets, path, bits, true, 0, 0, CancellationToken.None, null);
+                    Clip exported = Audio.Load(path, Path.Combine(root, "cache"), CancellationToken.None, null);
+                    using (var reader = new WaveFileReader(path)) Check(reader.WaveFormat.BitsPerSample == bits && reader.WaveFormat.SampleRate == Audio.Rate && reader.Length == Audio.Rate * 2 * bits / 8,
+                        "Export exact-duration " + bits + "-bit stereo WAV from the multitrack editor");
+                    Check(bits == 32 ? exported.Peak > 1.29 : Math.Abs(exported.PeakDb + 1) < .02,
+                        bits == 32 ? "Preserve float mix headroom" : "Scale the full PCM mix to prevent clipping");
+                }
+                string selectedMix = Path.Combine(root, "selected-mix.wav");
+                TimelineRender.Export(mixState, mixedAssets, selectedMix, 32, false, Audio.Rate / 4, Audio.Rate / 2, CancellationToken.None, null);
+                using (var reader = new WaveFileReader(selectedMix)) Check(reader.Length == Audio.Rate / 4 * 8, "Export only the selected timeline range");
+                var cancelled = new CancellationTokenSource(); cancelled.Cancel(); string cancelledPath = Path.Combine(root, "cancelled.wav"); bool wasCancelled = false;
+                try { TimelineRender.Export(mixState, mixedAssets, cancelledPath, 32, false, 0, 0, cancelled.Token, null); } catch (OperationCanceledException) { wasCancelled = true; }
+                Check(wasCancelled && !File.Exists(cancelledPath) && !Directory.GetFiles(root, "*.partial").Any(), "Cancel rendering without leaving incomplete exports");
+                Check(original.SequenceEqual(File.ReadAllBytes(ramp.Source)), "Keep original source bytes unchanged through all timeline edits");
+
+                foreach (string codec in new[] { "pcm_s16le", "pcm_s24le", "pcm_s32le", "pcm_f32le", "pcm_f64le" }) {
+                    string file = Path.Combine(root, "player-" + codec + ".wav");
+                    Audio.Run("-hide_banner -v error -nostdin -y -i " + Audio.Q(left.Source) + " -ar 48000 -c:a " + codec + " " + Audio.Q(file), CancellationToken.None, null, true);
+                    var clip = Audio.Load(file, Path.Combine(root, "cache"), CancellationToken.None, null);
+                    Check(clip.Ready && Math.Abs(clip.Duration - 1) < .001 && clip.Peak > .59 && clip.SourceFormat.Contains("48000 Hz"),
+                        "Decode " + codec + " at 48 kHz for the Media Player and display source format");
+                }
+                string aiff = Path.Combine(root, "player-pcm-big-endian.aiff");
+                Audio.Run("-hide_banner -v error -nostdin -y -i " + Audio.Q(left.Source) + " -c:a pcm_s24be " + Audio.Q(aiff), CancellationToken.None, null, true);
+                Check(Audio.Load(aiff, Path.Combine(root, "cache"), CancellationToken.None, null).Ready, "Decode big-endian PCM AIFF without Windows Media Player codecs");
+
+                Window owner;
+                using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Main.xaml")) owner = (Window)XamlReader.Load(stream);
+                ThemePalette.Install(owner);
+                Check(owner.FindName("AudioDevicesButton") != null, "Expose Audio devices in the main header on every workspace");
+                Picture((FrameworkElement)owner.Content, Path.Combine(root, "main-header-preview.png"), 1050, 850);
+                using (var devices = new AudioDevicesView(AudioInputs.Choices().FirstOrDefault(), delegate(InputChoice choice) { }, delegate { }, false)) {
+                    owner.Content = devices; Picture(devices, Path.Combine(root, "audio-devices-preview.png"), 760, 640);
+                    Check(devices.ActualWidth == 712 && devices.DesiredSize.Height <= 640, "Render output selector, speaker test, microphone selector and diagnostics together");
+                }
+                using (var view = new EditorView(owner, Path.Combine(root, "editor-cache"), delegate(string message) { }, delegate { })) {
+                    owner.Content = view; view.SetForTest(mixState, mixedAssets);
+                    Check(view.CheckUndoRedoForTest(), "Exercise the editor's actual cut, undo and redo handlers");
+                    float[] pulse = new float[Audio.Rate * 8];
+                    for (int i = 0; i < pulse.Length; i++) pulse[i] = (float)(.7 * Math.Exp(-(i % (Audio.Rate / 2)) / 3000.0) * Math.Sin(i * .06));
+                    var beat = Source(root, "Generated drum reference", pulse, 1);
+                    var previewAssets = new Dictionary<string, Clip>(StringComparer.OrdinalIgnoreCase) { { beat.Source, beat } };
+                    var previewState = new EditorSession { Name = "Practice · generated test audio" };
+                    string[] names = { "Kick", "Snare", "Hi-hat", "Tom 1", "Tom 2", "Floor tom", "Overhead L", "Overhead R", "Room L", "Room R", "Percussion", "Bass guide", "Guitar guide", "Keys guide", "Click", "Reference" };
+                    for (int i = 0; i < 16; i++) { previewState.Tracks[i].Name = names[i]; previewState.Regions.Add(new TimelineRegion { Source = beat.Source, Name = names[i], Track = i, Start = (i % 3) * Audio.Rate / 2, SourceStart = i % 2 * Audio.Rate, Length = (6 - i % 3) * Audio.Rate }); }
+                    view.SetForTest(previewState, previewAssets); view.ShowSelectionForTest(Audio.Rate, 4L * Audio.Rate); Picture(view, Path.Combine(root, "editor-preview.png"), 1280, 760);
+                    Picture(view, Path.Combine(root, "editor-small-preview.png"), 800, 560);
+                    Check(view.ActualWidth == 800 && view.ActualHeight == 560, "Lay out editor controls and scrolling timeline at small window size");
+                }
+                using (var view = new MediaPlayerView(owner, Path.Combine(root, "player-cache"), delegate(string message) { }, delegate { })) {
+                    owner.Content = view; view.SetForTest(left); Picture(view, Path.Combine(root, "player-preview.png"), 1100, 760);
+                    Picture(view, Path.Combine(root, "player-small-preview.png"), 800, 560);
+                    Check(view.ActualWidth == 800, "Render the Media Player waveform, playlist, transport and seek controls");
+                }
+                owner.Content = null;
+                log.Add("Rendered views use generated samples. Realtek playback on the affected PC and physical Windows/H5studio capture need a connected-device acceptance test.");
+                File.WriteAllLines(Path.Combine(root, "workspace-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "workspace-test-results.txt"), log, Encoding.UTF8); return 1; }
+        }
+    }
+}

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"); }
+        }
+    }
+}

package/source/app.manifest

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="DrumBuddy"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false"/></requestedPrivileges></security></trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application><supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/></application></compatibility>
+  <application xmlns="urn:schemas-microsoft-com:asm.v3"><windowsSettings><dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware><dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness><longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware></windowsSettings></application>
+</assembly>