@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/AudioOutputs.cs

@@ -0,0 +1,327 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Controls;
+using NAudio.CoreAudioApi;
+using NAudio;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DrumBuddy
+{
+    // Channel conversion and resampling happen in managed code before shared playback.
+    internal sealed class EndpointSamples : ISampleProvider
+    {
+        private readonly ISampleProvider source;
+        private readonly WaveFormat format;
+        private float[] input = new float[0];
+        public EndpointSamples(ISampleProvider source, int channels)
+        {
+            if (source.WaveFormat.Channels < 1 || source.WaveFormat.Channels > 2 || channels < 1 || channels > 32)
+                throw new ArgumentException("Unsupported playback channel layout.");
+            this.source = source; format = WaveFormat.CreateIeeeFloatWaveFormat(source.WaveFormat.SampleRate, channels);
+        }
+        public WaveFormat WaveFormat { get { return format; } }
+        public int Read(float[] buffer, int offset, int count)
+        {
+            int sourceChannels = source.WaveFormat.Channels, frames = count / format.Channels;
+            int needed = frames * sourceChannels;
+            if (input.Length < needed) input = new float[needed];
+            int read = source.Read(input, 0, needed), got = read / sourceChannels;
+            Array.Clear(buffer, offset, got * format.Channels);
+            for (int frame = 0; frame < got; frame++) {
+                float left = input[frame * sourceChannels], right = input[frame * sourceChannels + (sourceChannels == 1 ? 0 : 1)];
+                if (float.IsNaN(left) || float.IsInfinity(left)) left = 0;
+                if (float.IsNaN(right) || float.IsInfinity(right)) right = 0;
+                if (format.Channels == 1) buffer[offset + frame] = Math.Max(-1, Math.Min(1, left * .5f + right * .5f));
+                else {
+                    buffer[offset + frame * format.Channels] = Math.Max(-1, Math.Min(1, left));
+                    buffer[offset + frame * format.Channels + 1] = Math.Max(-1, Math.Min(1, right));
+                }
+            }
+            return got * format.Channels;
+        }
+    }
+
+    internal sealed class CountedPlayback : ISampleProvider
+    {
+        private readonly ISampleProvider source;
+        public long Frames;
+        public CountedPlayback(ISampleProvider source) { this.source = source; }
+        public WaveFormat WaveFormat { get { return source.WaveFormat; } }
+        public int Read(float[] buffer, int offset, int count)
+        { int read = source.Read(buffer, offset, count); Interlocked.Add(ref Frames, read / WaveFormat.Channels); return read; }
+    }
+
+    internal sealed class EndpointWaveProvider : IWaveProvider
+    {
+        private readonly ISampleProvider source;
+        private readonly bool floating;
+        private float[] bufferSamples = new float[0];
+        public WaveFormat WaveFormat { get; private set; }
+        public EndpointWaveProvider(ISampleProvider samples) : this(samples, null) { }
+        public EndpointWaveProvider(ISampleProvider samples, WaveFormat endpointFormat)
+        {
+            source = samples;
+            WaveFormat = endpointFormat ?? (samples.WaveFormat.Channels > 2
+                ? new WaveFormatExtensible(samples.WaveFormat.SampleRate, 32, samples.WaveFormat.Channels)
+                : samples.WaveFormat);
+            var extensible = WaveFormat as WaveFormatExtensible;
+            var standard = extensible == null ? WaveFormat : extensible.ToStandardWaveFormat();
+            floating = standard.Encoding == WaveFormatEncoding.IeeeFloat && standard.BitsPerSample == 32;
+            bool pcm = standard.Encoding == WaveFormatEncoding.Pcm && new[] { 16, 24, 32 }.Contains(standard.BitsPerSample);
+            if ((!floating && !pcm) || WaveFormat.Channels != samples.WaveFormat.Channels || WaveFormat.SampleRate != samples.WaveFormat.SampleRate)
+                throw new ArgumentException("The endpoint format does not match the adapted playback audio.");
+        }
+        public int Read(byte[] buffer, int offset, int count)
+        {
+            int needed = count / WaveFormat.BlockAlign * WaveFormat.Channels;
+            if (bufferSamples.Length < needed) bufferSamples = new float[needed];
+            int read = source.Read(bufferSamples, 0, needed);
+            if (floating) { Buffer.BlockCopy(bufferSamples, 0, buffer, offset, read * 4); return read * 4; }
+            int bytes = WaveFormat.BitsPerSample / 8;
+            double scale = Math.Pow(2, WaveFormat.BitsPerSample - 1);
+            for (int i = 0; i < read; i++) {
+                double value = float.IsNaN(bufferSamples[i]) || float.IsInfinity(bufferSamples[i]) ? 0 : bufferSamples[i];
+                long pcm = (long)Math.Max(-scale, Math.Min(scale - 1, Math.Round(value * scale, MidpointRounding.AwayFromZero)));
+                for (int b = 0; b < bytes; b++) buffer[offset + i * bytes + b] = (byte)(pcm >> (8 * b));
+            }
+            return read * bytes;
+        }
+    }
+
+    internal static class WindowsWaveDevices
+    {
+        [DllImport("winmm.dll")] private static extern uint waveOutMessage(IntPtr device, uint message, IntPtr value, IntPtr size);
+        [DllImport("winmm.dll")] private static extern uint waveInMessage(IntPtr device, uint message, IntPtr value, IntPtr size);
+        [DllImport("winmm.dll")] internal static extern int waveInGetNumDevs();
+        [DllImport("winmm.dll", CharSet = CharSet.Auto)] private static extern int waveInGetDevCaps(IntPtr device, out WaveInCapabilities caps, int size);
+        [DllImport("winmm.dll")] private static extern int waveInOpen(IntPtr handle, IntPtr device, [In, MarshalAs(UnmanagedType.LPStruct)] WaveFormat format, IntPtr callback, IntPtr instance, uint flags);
+        internal static bool SupportsInput(int device, int rate, int channels)
+        { return waveInOpen(IntPtr.Zero, (IntPtr)device, new WaveFormat(rate, 16, channels), IntPtr.Zero, IntPtr.Zero, 1) == 0; }
+        internal static WaveInCapabilities InputCaps(int device)
+        {
+            WaveInCapabilities caps;
+            MmException.Try((MmResult)waveInGetDevCaps((IntPtr)device, out caps, Marshal.SizeOf(typeof(WaveInCapabilities))), "waveInGetDevCaps"); return caps;
+        }
+        private static uint Message(int device, bool capture, uint message, IntPtr value, IntPtr size)
+        { return capture ? waveInMessage((IntPtr)device, message, value, size) : waveOutMessage((IntPtr)device, message, value, size); }
+        internal static string EndpointId(int device, bool capture = false)
+        {
+            IntPtr size = Marshal.AllocHGlobal(IntPtr.Size), text = IntPtr.Zero;
+            try {
+                Marshal.WriteIntPtr(size, IntPtr.Zero);
+                // mmddk.h: DRV_RESERVED + 18 (size) and + 17 (endpoint ID).
+                if (Message(device, capture, 0x812, size, IntPtr.Zero) != 0) return null;
+                int bytes = Marshal.ReadInt32(size);
+                if (bytes < 2 || bytes > 65536 || bytes % 2 != 0) return null;
+                text = Marshal.AllocHGlobal(bytes);
+                if (Message(device, capture, 0x811, text, (IntPtr)bytes) != 0) return null;
+                return Marshal.PtrToStringUni(text);
+            }
+            finally { if (text != IntPtr.Zero) Marshal.FreeHGlobal(text); Marshal.FreeHGlobal(size); }
+        }
+        internal static int Find(string endpoint, bool capture = false)
+        {
+            for (int i = 0; i < (capture ? waveInGetNumDevs() : OutputDevices.waveOutGetNumDevs()); i++)
+                if (string.Equals(endpoint, EndpointId(i, capture), StringComparison.OrdinalIgnoreCase)) return i;
+            return -2;
+        }
+    }
+
+    internal sealed class PlaybackRoute : IDisposable
+    {
+        public IWavePlayer Player;
+        public MMDevice Endpoint;
+        public CountedPlayback Counter;
+        public WaveFormat PlaybackFormat;
+        public string Description;
+        public double Seconds
+        {
+            get {
+                var position = Player as IWavePosition;
+                if (position != null && Player.PlaybackState != PlaybackState.Stopped)
+                    try { return position.GetPosition() / (double)(PlaybackFormat ?? Counter.WaveFormat).AverageBytesPerSecond; } catch { }
+                return Interlocked.Read(ref Counter.Frames) / (double)Counter.WaveFormat.SampleRate;
+            }
+        }
+        public void Dispose()
+        {
+            var old = Player; Player = null;
+            if (old != null) { try { old.Stop(); } catch { } try { old.Dispose(); } catch { } }
+            if (Endpoint != null) { try { Endpoint.Dispose(); } catch { } Endpoint = null; }
+        }
+    }
+
+    internal static class AudioOutputs
+    {
+        private static string preferredKey = "default";
+        public static int LatencyMilliseconds = 80;
+        public static event Action OutputChanged;
+        public static string PreferredKey {
+            get { return preferredKey; }
+            set { value = value ?? "default"; if (value == preferredKey) return; preferredKey = value; var changed = OutputChanged; if (changed != null) changed(); }
+        }
+        public static readonly string ErrorLog = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DrumBuddy", "audio-output-errors.txt");
+        public static List<OutputChoice> Choices()
+        {
+            var choices = new List<OutputChoice> { new OutputChoice { Name = "Windows default speakers / headphones" } };
+            try {
+                using (var enumerator = new MMDeviceEnumerator()) {
+                    try { using (var defaultDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia)) choices[0].Name = "Windows default — " + defaultDevice.FriendlyName; } catch { }
+                    foreach (var endpoint in enumerator.EnumerateAudioEndPoints(DataFlow.Render, DeviceState.Active)) {
+                        using (endpoint) choices.Add(new OutputChoice { Name = endpoint.FriendlyName + " (Windows)", EndpointId = endpoint.ID });
+                    }
+                }
+            }
+            catch { /* The default entry keeps the picker usable if Windows Audio is stopped. */ }
+            choices.Add(new OutputChoice { Name = "Windows default - Compatibility (16-bit PCM)", Compatibility = true });
+            try {
+                for (int i = 0; i < OutputDevices.waveOutGetNumDevs(); i++) {
+                    string endpoint = WindowsWaveDevices.EndpointId(i);
+                    string name = choices.Where(c => !c.Compatibility && c.EndpointId == endpoint).Select(c => c.Name.Replace(" (Windows)", "")).FirstOrDefault() ?? OutputDevices.Name(i);
+                    if (!string.IsNullOrEmpty(endpoint)) choices.Add(new OutputChoice { Name = name + " - Compatibility (16-bit PCM)", Compatibility = true, EndpointId = endpoint, Device = i });
+                }
+            } catch { }
+            try { foreach (string driver in AsioOut.GetDriverNames()) choices.Add(new OutputChoice { Name = driver + " (ASIO)", Driver = driver }); } catch { }
+            return choices;
+        }
+        public static ISampleProvider Adapt(ISampleProvider source, int rate, int channels)
+        {
+            if (rate < 8000 || rate > 384000) throw new ArgumentException("Unsupported playback sample rate.");
+            if (source.WaveFormat.SampleRate != rate) source = new WdlResamplingSampleProvider(source, rate);
+            return new EndpointSamples(source, channels);
+        }
+        public static PlaybackRoute Open(ISampleProvider source, OutputChoice choice)
+        {
+            choice = choice ?? new OutputChoice { Name = "Windows default speakers / headphones" };
+            if (choice.Driver != null) {
+                var route = new PlaybackRoute();
+                try {
+                    var asio = new AsioOut(choice.Driver); route.Player = asio;
+                    if (asio.DriverOutputChannelCount < 1) throw new IOException("This ASIO driver has no playback outputs.");
+                    int rate = source.WaveFormat.SampleRate;
+                    if (!asio.IsSampleRateSupported(rate)) rate = new[] { 48000, 44100, 96000 }.FirstOrDefault(asio.IsSampleRateSupported);
+                    if (rate == 0) throw new IOException("The ASIO device is not offering a supported playback rate.");
+                    route.Counter = new CountedPlayback(Adapt(source, rate, Math.Min(2, asio.DriverOutputChannelCount)));
+                    var wire = new SampleToWaveProvider(route.Counter); route.PlaybackFormat = wire.WaveFormat;
+                    asio.Init(wire); route.Description = choice.Driver + " - " + rate + " Hz"; return route;
+                }
+                catch (Exception ex) { route.Dispose(); throw DeviceError(choice.Name, ex); }
+            }
+            if (choice.Compatibility) return OpenCompatibility(source, choice);
+            Exception lastError = null; string endpointId = choice.EndpointId; var failures = new List<string>();
+            // Retry polling on the same selected endpoint if its driver rejects event sync.
+            foreach (bool events in new[] { true, false }) {
+                var route = new PlaybackRoute();
+                string stage = "find endpoint";
+                try {
+                    using (var enumerator = new MMDeviceEnumerator())
+                        route.Endpoint = string.IsNullOrEmpty(choice.EndpointId)
+                            ? enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia)
+                            : enumerator.GetDevice(choice.EndpointId);
+                    endpointId = route.Endpoint.ID; stage = "create shared audio client";
+                    var wasapi = new WasapiOut(route.Endpoint, AudioClientShareMode.Shared, events, Math.Max(40, Math.Min(250, LatencyMilliseconds))); route.Player = wasapi;
+                    WaveFormat mix = wasapi.OutputWaveFormat;
+                    route.Counter = new CountedPlayback(Adapt(source, mix.SampleRate, mix.Channels));
+                    var wire = new EndpointWaveProvider(route.Counter, mix); route.PlaybackFormat = wire.WaveFormat;
+                    stage = "initialize " + mix;
+                    wasapi.Init(wire);
+                    route.Description = route.Endpoint.FriendlyName + " · Windows shared audio · " + mix.SampleRate + " Hz";
+                    return route;
+                }
+                catch (Exception ex) { lastError = ex; failures.Add("WASAPI " + (events ? "event" : "polling") + " / " + stage + ": " + ex); route.Dispose(); }
+            }
+            try {
+                var result = OpenCompatibility(source, new OutputChoice { Name = choice.Name, Compatibility = true, EndpointId = endpointId });
+                WriteFailures(choice.Name, failures, "Recovered using " + result.Description); return result;
+            }
+            catch (Exception ex) { lastError = ex; failures.Add("Compatibility: " + ex); }
+            WriteFailures(choice.Name, failures, "Playback could not start");
+            throw DeviceError(choice.Name, lastError);
+        }
+        internal static PlaybackRoute OpenCompatibility(ISampleProvider source, OutputChoice choice)
+        {
+            int device = string.IsNullOrEmpty(choice.EndpointId) ? -1 : WindowsWaveDevices.Find(choice.EndpointId);
+            if (device == -2) throw new IOException("The selected output is no longer available. Click Refresh in Audio devices and select it again.");
+            Exception last = null;
+            foreach (int rate in new[] { 48000, 44100 }) {
+                var route = new PlaybackRoute();
+                try {
+                    var player = new WaveOutEvent { DeviceNumber = device, DesiredLatency = Math.Max(100, Math.Min(250, LatencyMilliseconds)), NumberOfBuffers = 3 }; route.Player = player;
+                    route.Counter = new CountedPlayback(Adapt(source, rate, 2));
+                    var wire = new EndpointWaveProvider(route.Counter, new WaveFormat(rate, 16, 2)); route.PlaybackFormat = wire.WaveFormat;
+                    player.Init(wire);
+                    route.Description = (device == -1 ? "Windows default" : OutputDevices.Name(device)) + " - Compatibility / 16-bit PCM / " + rate + " Hz";
+                    return route;
+                }
+                catch (Exception ex) { last = ex; route.Dispose(); }
+            }
+            throw new IOException("Windows PCM compatibility playback failed: " + last.Message + " (0x" + last.HResult.ToString("X8") + ")", last);
+        }
+        private static void WriteFailures(string name, IEnumerable<string> failures, string result)
+        {
+            try {
+                Directory.CreateDirectory(Path.GetDirectoryName(ErrorLog));
+                File.WriteAllText(ErrorLog, DateTimeOffset.Now.ToString("o") + " | " + name + "\r\n" + string.Join("\r\n\r\n", failures) + "\r\n\r\n" + result);
+            } catch { }
+        }
+        private static IOException DeviceError(string name, Exception error)
+        {
+            string detail = error == null ? "No playback device is available." : error.Message + " (0x" + error.HResult.ToString("X8") + ")";
+            return new IOException("Could not open " + name + ". " + detail + " Open Audio devices at the top of the app, click Refresh, and select your speakers/headphones. Try the Compatibility (16-bit PCM) entry. Save diagnostics there if it still fails.", error);
+        }
+    }
+
+    internal sealed class AudioOutputPicker : Grid
+    {
+        private readonly ComboBox devices;
+        private readonly Action changed;
+        private readonly Action<string> status;
+        private bool updating;
+        public OutputChoice Selected { get { return devices.SelectedItem as OutputChoice; } }
+        public AudioOutputPicker(Action changed, Action<string> status)
+        {
+            this.changed = changed; this.status = status; Margin = new Thickness(0, 0, 0, 12);
+            ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto }); ColumnDefinitions.Add(new ColumnDefinition()); ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+            var label = WorkspaceUi.Text("Audio output  ", 14); Children.Add(label);
+            devices = new ComboBox { FontSize = 14, MinHeight = 34, Padding = new Thickness(5), MaxWidth = 520, HorizontalAlignment = HorizontalAlignment.Stretch };
+            SetColumn(devices, 1); Children.Add(devices);
+            var refresh = WorkspaceUi.Button("Refresh", delegate { Refresh(); }); refresh.Margin = new Thickness(8, 0, 0, 0); SetColumn(refresh, 2); Children.Add(refresh);
+            devices.SelectionChanged += delegate {
+                if (updating || Selected == null) return;
+                AudioOutputs.PreferredKey = Selected.Key; if (changed != null) changed();
+            };
+            Loaded += delegate { AudioOutputs.OutputChanged += SyncSelection; SyncSelection(); };
+            Unloaded += delegate { AudioOutputs.OutputChanged -= SyncSelection; };
+            Refresh();
+        }
+        private void SyncSelection()
+        {
+            if (!Dispatcher.CheckAccess()) { Dispatcher.BeginInvoke((Action)SyncSelection); return; }
+            var choices = devices.ItemsSource as IEnumerable<OutputChoice>;
+            if (choices == null) return;
+            var selected = choices.FirstOrDefault(c => c.Key == AudioOutputs.PreferredKey);
+            if (selected == null) { Refresh(AudioOutputs.PreferredKey); return; }
+            if (Selected != null && Selected.Key == selected.Key) return;
+            updating = true; devices.SelectedItem = selected; updating = false;
+            if (changed != null) changed();
+        }
+        private void Refresh(string desiredKey = null)
+        {
+            string key = desiredKey ?? (Selected == null ? AudioOutputs.PreferredKey : Selected.Key);
+            if (changed != null && devices.Items.Count > 0) changed();
+            updating = true;
+            try {
+                var choices = AudioOutputs.Choices(); devices.ItemsSource = choices;
+                devices.SelectedItem = choices.FirstOrDefault(c => c.Key == key) ?? choices[0];
+            }
+            catch (Exception ex) { if (status != null) status("Could not list audio outputs: " + ex.Message); }
+            finally { updating = false; }
+        }
+    }
+}

package/source/AudioWorkspace.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DrumBuddy
+{
+    internal static class WorkspaceUi
+    {
+        public static Brush Color(string value) { return ThemePalette.Brush(value); }
+        public static Button Button(string text, Action action)
+        {
+            var button = new Button { Content = text, MinHeight = 30, Padding = new Thickness(9, 4, 9, 4), FontSize = 13, Margin = new Thickness(0, 0, 6, 6), Background = Color("#FFFFFF"), Foreground = Color("#182C37"), BorderBrush = Color("#C3CED0") };
+            button.Click += delegate { action(); }; return button;
+        }
+        public static TextBlock Text(string text, double size)
+        { return new TextBlock { Text = text, FontSize = Math.Max(11, size * .94), Foreground = Color("#182C37"), TextWrapping = TextWrapping.Wrap, VerticalAlignment = VerticalAlignment.Center }; }
+        public static string Clock(double seconds)
+        { return TimeSpan.FromSeconds(Math.Max(0, seconds)).ToString(seconds >= 3600 ? @"h\:mm\:ss\.ff" : @"mm\:ss\.ff"); }
+        public static string AudioFilter = "Audio and video|*.wav;*.wave;*.bwf;*.rf64;*.mp3;*.mp4;*.m4a;*.aac;*.flac;*.ogg;*.opus;*.wma;*.aif;*.aiff;*.mov;*.mkv;*.webm|All files|*.*";
+    }
+
+    // All file formats are decoded before this Windows PCM playback boundary.
+    internal sealed class WorkspaceOutput : IDisposable
+    {
+        private readonly Dispatcher dispatcher;
+        private IWavePlayer device;
+        private PlaybackRoute route;
+        private GainProvider gain;
+        private double start, held;
+        public string Description { get { return route == null ? "" : route.Description; } }
+        public WorkspaceOutput(Dispatcher dispatcher) { this.dispatcher = dispatcher; }
+        public bool Playing { get { return device != null && device.PlaybackState == PlaybackState.Playing; } }
+        public bool Paused { get { return device != null && device.PlaybackState == PlaybackState.Paused; } }
+        public double Position
+        {
+            get {
+                if (device == null) return held;
+                try { return start + route.Seconds; } catch { return held; }
+            }
+        }
+        public void Open(ISampleProvider source, double at, float volume, Action<Exception> ended, OutputChoice choice = null)
+        {
+            Stop(); start = held = at;
+            gain = new GainProvider(source) { Gain = volume };
+            try {
+                route = AudioOutputs.Open(gain, choice); var current = route.Player; device = current;
+                current.PlaybackStopped += delegate(object sender, StoppedEventArgs e) {
+                    dispatcher.BeginInvoke((Action)delegate {
+                        if (device != current) return;
+                        Stop(); if (ended != null) ended(e.Exception);
+                    });
+                };
+                current.Play();
+            }
+            catch { Stop(); throw; }
+        }
+        public void Pause() { if (device != null) device.Pause(); }
+        public void Resume() { if (device != null) device.Play(); }
+        public void Volume(float level) { if (gain != null) gain.Gain = level; }
+        public void Stop()
+        {
+            held = Position; device = null; gain = null;
+            if (route != null) { route.Dispose(); route = null; }
+        }
+        public void Dispose() { Stop(); }
+    }
+}

package/source/BrandArtwork.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Xml;
+
+namespace DrumBuddy
+{
+    public static class BrandArtwork
+    {
+        private static DrawingImage cached;
+        private static BitmapSource raster;
+        public static ImageSource Raster()
+        {
+            if (raster != null) return raster;
+            var source = new BitmapImage(); var embedded = Assembly.GetExecutingAssembly().GetManifestResourceStream("logo.png");
+            try {
+                source.BeginInit(); source.CacheOption = BitmapCacheOption.OnLoad;
+                if (embedded != null) source.StreamSource = embedded; else source.UriSource = new Uri(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logo.png"));
+                source.EndInit(); source.Freeze();
+            }
+            finally { if (embedded != null) embedded.Dispose(); }
+            raster = new CroppedBitmap(source, new Int32Rect(100, 280, 1050, 800)); raster.Freeze(); return raster;
+        }
+        // The SVG alternative uses paths and user-space linear gradients only.
+        // Render those directly as WPF vector geometry, without a bitmap fallback.
+        public static ImageSource Load()
+        {
+            if (cached != null) return cached;
+            var svg = new XmlDocument { XmlResolver = null };
+            using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Flux-Mark.svg")) {
+                if (stream == null) throw new IOException("The Flux vector artwork is missing.");
+                using (var reader = XmlReader.Create(stream, new XmlReaderSettings { DtdProcessing = DtdProcessing.Prohibit, XmlResolver = null })) svg.Load(reader);
+            }
+            var ns = new XmlNamespaceManager(svg.NameTable); ns.AddNamespace("s", "http://www.w3.org/2000/svg");
+            var brushes = new Dictionary<string, Brush>();
+            foreach (XmlElement gradient in svg.SelectNodes("/s:svg/s:defs/s:linearGradient", ns)) {
+                var brush = new LinearGradientBrush { MappingMode = BrushMappingMode.Absolute,
+                    StartPoint = new Point(Number(gradient, "x1"), Number(gradient, "y1")), EndPoint = new Point(Number(gradient, "x2"), Number(gradient, "y2")) };
+                foreach (XmlElement stop in gradient.SelectNodes("s:stop", ns)) brush.GradientStops.Add(new GradientStop((Color)ColorConverter.ConvertFromString(stop.GetAttribute("stop-color")), Number(stop, "offset")));
+                brush.Freeze(); brushes.Add(gradient.GetAttribute("id"), brush);
+            }
+            var drawing = new DrawingGroup(); string[] box = svg.DocumentElement.GetAttribute("viewBox").Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
+            var bounds = new Rect(Parse(box[0]), Parse(box[1]), Parse(box[2]), Parse(box[3]));
+            drawing.Children.Add(new GeometryDrawing(Brushes.Transparent, null, new RectangleGeometry(bounds))); drawing.ClipGeometry = new RectangleGeometry(bounds);
+            foreach (XmlElement path in svg.SelectNodes("/s:svg/s:path", ns)) {
+                double opacity = path.HasAttribute("opacity") ? Number(path, "opacity") : 1;
+                Brush fill = Paint(path.GetAttribute("fill"), brushes, opacity); Pen pen = null;
+                if (path.HasAttribute("stroke")) {
+                    pen = new Pen(Paint(path.GetAttribute("stroke"), brushes, opacity), Number(path, "stroke-width"));
+                    if (path.GetAttribute("stroke-linecap") == "round") pen.StartLineCap = pen.EndLineCap = PenLineCap.Round;
+                    if (path.GetAttribute("stroke-linejoin") == "round") pen.LineJoin = PenLineJoin.Round;
+                }
+                drawing.Children.Add(new GeometryDrawing(fill, pen, Geometry.Parse("F1 " + path.GetAttribute("d"))));
+            }
+            drawing.Freeze(); cached = new DrawingImage(drawing); cached.Freeze(); return cached;
+        }
+        private static double Parse(string value) { return double.Parse(value, CultureInfo.InvariantCulture); }
+        private static Brush Paint(string value, Dictionary<string, Brush> brushes, double opacity)
+        {
+            if (value == "none" || string.IsNullOrEmpty(value)) return null;
+            Brush brush = value.StartsWith("url(#", StringComparison.Ordinal) ? brushes[value.Substring(5, value.Length - 6)].Clone() : new SolidColorBrush((Color)ColorConverter.ConvertFromString(value));
+            brush.Opacity = opacity; return brush;
+        }
+        private static double Number(XmlElement element, string attribute) { return Parse(element.GetAttribute(attribute)); }
+    }
+}

package/source/Build Instructions.txt

@@ -0,0 +1,59 @@
+FLUX SOURCE (DRUM BUDDY COMPATIBLE UPDATE)
+
+Build on Windows 10/11 x64 with .NET Framework 4.8.
+No Visual Studio or .NET SDK is required: Build.ps1 uses the C# compiler
+included with .NET Framework.
+
+1. Run Fetch-Dependencies.ps1 in PowerShell. All downloads are pinned by SHA-256.
+2. Run Build.ps1. The output is ..\build\DrumBuddy-Setup.exe and the portable
+   app folder ..\build\DrumBuddy.
+
+Dependencies are pinned to reviewed SHA-256 hashes. The FFmpeg release URL is version-specific. If an upstream asset changes, review the replacement before changing its lock; do not disable verification.
+
+Verification:
+  DrumBuddy.exe --self-test "C:\path\to\new-audio-test-folder"
+  DrumBuddy.exe --grid-self-test "C:\path\to\new-grid-test-folder"
+  DrumBuddy.exe --workspace-self-test "C:\path\to\new-editor-test-folder"
+  DrumBuddy.exe --float-self-test "C:\path\to\new-float-test-folder"
+  DrumBuddy.exe --output-self-test "C:\path\to\new-output-test-folder"
+  DrumBuddy.exe --interface-self-test "C:\path\to\new-interface-test-folder"
+  DrumBuddy.exe --conversion-self-test "C:\path\to\new-conversion-test-folder"
+  DrumBuddy.exe --audio-diagnostics "C:\path\to\Audio-Diagnostics.txt"
+  DrumBuddy-Setup.exe --verify-payload "C:\path\to\new-payload-check-folder"
+
+The self-test creates real MP3 and MP4 samples, then checks decoding,
+16/24-bit output, positive/negative gain, peak protection, safe file names,
+preservation of existing/source files, cancellation, and WAV headers.
+Payload verification extracts and checks every bundled file against SHA-256.
+It does not install the app, install a driver, or modify Windows settings.
+The workspace suite covers the 16-track editor, range/playhead gestures,
+endpoint resampling/channel adaptation, PCM/float imports and exports,
+and offscreen player/editor renders. The output suite opens the actual
+default Windows endpoint and plays only silence; it never changes volume.
+Windows speakers/headphones use shared WASAPI with the exact endpoint format,
+with an endpoint-matched 16-bit PCM compatibility fallback. The output suite
+checks both paths and queries microphone formats without opening capture.
+Windows microphone buffer tests cover routing, saved samples and queue draining.
+The interface suite checks keybind capture, saved/unsaved settings, theme
+switching, integrated recording insertion and dark/light/compact layouts.
+The general-conversion suite checks original-rate float/PCM WAV, FLAC,
+MP3 and AAC outputs, headroom, cancellation and source-file preservation.
+Use a fresh output directory for every suite run.
+Native ASIO remains available. Physical recording and Realtek playback on the
+affected PC still need a connected-device acceptance test.
+
+ASIO recording must be acceptance-tested on a physical Zoom R16.
+Check all eight inputs, 1+2 stereo, individual mono inputs, 16/24-bit saved
+files, stop/save, direct monitoring, and safe handling of a disconnected USB cable.
+
+The app is WPF/.NET Framework with NAudio 2.2.1. FFmpeg decodes local audio
+and video into cached 44.1-kHz floating-point WAV, preserving mono and
+downmixing other channel layouts to stereo. The app scans every decoded
+sample for the gain ceiling, then writes classic 16/24-bit PCM WAV files.
+Capturing uses an ASIO callback, bounded audio queue, and background writer;
+it writes eight separate mono files or one stereo/mono file as selected.
+
+The installer is a per-user native Windows executable with an embedded ZIP
+and per-file integrity manifest. With -BootstrapOnly, FFmpeg and the panel reference image are downloaded and verified at first setup, then cached. The Zoom driver is not bundled or downloaded; Install Drivers opens its official support page and a setup tutorial.
+The uninstaller removes only files in the installation's saved file list;
+it preserves user audio, settings, unknown files, and the Zoom driver.