@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/TempoGrid.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+
+namespace DrumBuddy
+{
+    public sealed class TempoGridOptions
+    {
+        public double Tempo = 120;
+        public int BeatsPerBar = 4, BeatUnit = 4, Division = 16;
+        public bool Triplet, MusicalRuler = true;
+        public TempoGridOptions Copy() { return (TempoGridOptions)MemberwiseClone(); }
+        public string Signature() { return Tempo.ToString("R", CultureInfo.InvariantCulture) + ":" + BeatsPerBar + ":" + BeatUnit + ":" + Division + ":" + Triplet + ":" + MusicalRuler; }
+        public void Validate()
+        {
+            if (double.IsNaN(Tempo) || double.IsInfinity(Tempo) || Tempo < 20 || Tempo > 400) throw new IOException("Tempo must be between 20 and 400 BPM.");
+            if (BeatsPerBar < 1 || BeatsPerBar > 32 || !PowerOfTwo(BeatUnit) || BeatUnit > 32) throw new IOException("Choose a time signature with 1–32 beats and a power-of-two beat unit up to 32.");
+            if (!PowerOfTwo(Division) || Division > 256) throw new IOException("Choose a grid division from 1/1 through 1/256.");
+        }
+        private static bool PowerOfTwo(int value) { return value > 0 && (value & (value - 1)) == 0; }
+    }
+    public sealed class TempoGridTick
+    {
+        public long Frame;
+        public int Kind; // 0 subdivision, 1 beat, 2 bar
+        public string Label;
+    }
+    public static class TempoGrid
+    {
+        public static readonly int[] Divisions = { 1, 2, 4, 8, 16, 32, 64, 128, 256 };
+        public static bool TryTempo(string text, out double value)
+        { return double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value) || double.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out value); }
+        public static double StepSeconds(TempoGridOptions options) { return 240.0 / options.Tempo / options.Division * (options.Triplet ? 2.0 / 3 : 1); }
+        public static double BeatSeconds(TempoGridOptions options) { return 240.0 / options.Tempo / options.BeatUnit; }
+        public static double BarSeconds(TempoGridOptions options) { return BeatSeconds(options) * options.BeatsPerBar; }
+        public static long Snap(long frame, TempoGridOptions options)
+        {
+            double seconds = Math.Max(0, frame) / (double)Audio.Rate, bar = BarSeconds(options), step = StepSeconds(options);
+            double start = Math.Floor(seconds / bar) * bar, inside = seconds - start;
+            double nearest = Math.Min(bar, Math.Round(inside / step, MidpointRounding.AwayFromZero) * step);
+            if (bar - inside <= Math.Abs(nearest - inside)) nearest = bar;
+            return FrameAt((start + nearest) * Audio.Rate);
+        }
+        private static long FrameAt(double frame) { return (long)Math.Round(Math.Max(0, Math.Min(EditorSession.MaxFrame, frame)), MidpointRounding.AwayFromZero); }
+        public static string Position(long frame, TempoGridOptions options)
+        {
+            double beats = Math.Max(0, frame) / (double)Audio.Rate / BeatSeconds(options);
+            long whole = (long)Math.Floor(beats + .500001 / (Audio.Rate * BeatSeconds(options)));
+            return (whole / options.BeatsPerBar + 1).ToString(CultureInfo.InvariantCulture) + "." + (whole % options.BeatsPerBar + 1).ToString(CultureInfo.InvariantCulture);
+        }
+        public static IEnumerable<TempoGridTick> VisibleTicks(TempoGridOptions options, double left, double width, double pixelsPerSecond)
+        {
+            options.Validate();
+            if (pixelsPerSecond <= 0 || width <= 0) yield break;
+            left = Math.Max(0, left); width = Math.Min(width, 16000);
+            foreach (var tick in Subdivisions(options, left, width, pixelsPerSecond)) yield return tick;
+            foreach (var tick in Series(BeatSeconds(options), left, width, pixelsPerSecond, 9, 1, options)) yield return tick;
+            foreach (var tick in Series(BarSeconds(options), left, width, pixelsPerSecond, 14, 2, options)) yield return tick;
+        }
+        private static IEnumerable<TempoGridTick> Subdivisions(TempoGridOptions options, double left, double width, double scale)
+        {
+            double bar = BarSeconds(options), step = StepSeconds(options), barPixels = bar * scale, stepPixels = step * scale;
+            long barStride = 1, stepStride = 1;
+            while (barPixels * barStride < 4) barStride *= 2;
+            while (stepPixels * stepStride < 4) stepStride *= 2;
+            long firstBar = Math.Max(0, (long)Math.Floor(left / barPixels / barStride) * barStride);
+            long lastBar = (long)Math.Ceiling((left + width) / barPixels); int count = 0;
+            for (long index = firstBar; index <= lastBar && count < 5000; index += barStride) {
+                double start = index * bar;
+                long first = Math.Max(0, (long)Math.Floor((left / scale - start) / step / stepStride) * stepStride);
+                for (long part = first; part * step < bar - 1e-10; part += stepStride) {
+                    double seconds = start + part * step;
+                    if (seconds * scale > left + width || seconds * Audio.Rate > EditorSession.MaxFrame || count++ >= 5000) break;
+                    yield return new TempoGridTick { Frame = FrameAt(seconds * Audio.Rate), Kind = 0 };
+                }
+            }
+        }
+        private static IEnumerable<TempoGridTick> Series(double seconds, double left, double width, double scale, double minimum, int kind, TempoGridOptions options)
+        {
+            double spacing = seconds * scale; long stride = 1;
+            while (spacing * stride < minimum && stride < (1L << 40)) stride *= 2;
+            long first = Math.Max(0, (long)Math.Floor(left / spacing / stride) * stride);
+            long last = (long)Math.Ceiling((left + width) / spacing);
+            long labelStride = stride; while (spacing * labelStride < 58) labelStride *= 2;
+            int count = 0;
+            for (long index = first; index <= last && count++ < 5000; index += stride) {
+                double frame = index * seconds * Audio.Rate; if (frame > EditorSession.MaxFrame) break;
+                string label = kind == 2 && index % labelStride == 0 ? (index + 1).ToString(CultureInfo.InvariantCulture) + ".1" : null;
+                if (kind == 1 && spacing >= 58 && index % options.BeatsPerBar != 0) label = (index / options.BeatsPerBar + 1) + "." + (index % options.BeatsPerBar + 1);
+                yield return new TempoGridTick { Frame = FrameAt(frame), Kind = kind, Label = label };
+            }
+        }
+    }
+}

package/source/TempoGridTests.cs

@@ -0,0 +1,108 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Threading;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace DrumBuddy
+{
+    public static class TempoGridTests
+    {
+        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 RunUi(Func<Task> action)
+        {
+            var previous = SynchronizationContext.Current; var dispatcher = Dispatcher.CurrentDispatcher;
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext(dispatcher));
+            try {
+                var task = action(); var frame = new DispatcherFrame();
+                task.ContinueWith(delegate { dispatcher.BeginInvoke((Action)delegate { frame.Continue = false; }); });
+                if (!task.IsCompleted) Dispatcher.PushFrame(frame); task.GetAwaiter().GetResult();
+            }
+            finally { SynchronizationContext.SetSynchronizationContext(previous); }
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "FluxGrid_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); log.Clear(); var previous = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults();
+                var grid = new TempoGridOptions(); grid.Validate();
+                Check(Math.Abs(TempoGrid.StepSeconds(grid) - .125) < 1e-12, "At 120 BPM, a sixteenth note lasts 0.125 seconds");
+                grid.Division = 32; Check(Math.Abs(TempoGrid.StepSeconds(grid) - .0625) < 1e-12, "At 120 BPM, a thirty-second note lasts 0.0625 seconds");
+                grid.Division = 256; Check(Math.Abs(TempoGrid.StepSeconds(grid) - .0078125) < 1e-12, "Allow fine divisions through 1/256");
+                grid.Division = 8; grid.Triplet = true; Check(Math.Abs(TempoGrid.StepSeconds(grid) - 1.0 / 6) < 1e-12, "Use three eighth-note triplets per quarter-note beat");
+                grid.Triplet = false; grid.BeatsPerBar = 6; grid.BeatUnit = 8;
+                Check(Math.Abs(TempoGrid.BarSeconds(grid) - 1.5) < 1e-12 && TempoGrid.Position(66150, grid) == "2.1", "Label a 6/8 bar correctly using quarter-note BPM");
+                grid = new TempoGridOptions { BeatsPerBar = 7, BeatUnit = 8, Division = 4 };
+                Check(TempoGrid.Snap(88000, grid) == 77175, "Restart quarter-note subdivisions at each 7/8 bar boundary");
+                grid = new TempoGridOptions { BeatsPerBar = 3, Division = 1 };
+                Check(TempoGrid.Snap(Audio.Rate, grid) == 66150, "Keep bar lines snappable when a whole-note division is longer than the bar");
+                grid = new TempoGridOptions { Tempo = 123, Division = 128 };
+                long distant = (long)Math.Round(100000 * 240.0 / 123 / 128 * Audio.Rate);
+                Check(Math.Abs(TempoGrid.Snap(distant, grid) - distant) <= 1, "Avoid accumulated frame rounding drift far into a fine grid");
+                grid = new TempoGridOptions { Division = 32 };
+                long first = TimelineGesture.FrameAt(2.5, 40, new long[] { 0 }, false, grid, true, true);
+                Check(first == 2756, "Do not swallow the first 1/32 grid line with the start-of-track magnet");
+                Check(TimelineGesture.FrameAt(21.4, 40, new long[0], false, new TempoGridOptions(), true, false) == 22050, "Snap a playhead gesture to the nearest sixteenth-note frame");
+                long boundary = 23000;
+                Check(TimelineGesture.FrameAt(boundary / (double)Audio.Rate * 160 + 2, 160, new[] { boundary }, false, grid, true, true) == boundary, "Give a nearby clip edge priority over the beat grid");
+                Check(TimelineGesture.FrameAt(21.4, 40, new[] { boundary }, false, new TempoGridOptions(), true, false) == 22050, "Disable edge snapping independently of grid snapping");
+                long raw = (long)Math.Round(21.4 / 40 * Audio.Rate);
+                Check(TimelineGesture.FrameAt(21.4, 40, new[] { raw + 1 }, true, grid, true, true) == raw, "Alt bypasses both snapping modes at sample resolution");
+                Check(TimelineGesture.FrameAt(2.5, 40, new long[] { 0 }, false, grid, false, false) == 2756, "Both snap switches off permits a free chop near the start");
+                var ticks = TempoGrid.VisibleTicks(new TempoGridOptions { Tempo = 400, Division = 256, Triplet = true }, 86400 * 2560.0 - 1280, 1280, 2560).ToArray();
+                Check(ticks.Length > 10 && ticks.Length < 1200 && ticks.All(t => t.Frame <= EditorSession.MaxFrame), "Bound visible grid rendering near the end of a 24-hour timeline");
+                bool invalid = false; try { new TempoGridOptions { Tempo = double.NaN }.Validate(); } catch (IOException) { invalid = true; }
+                Check(invalid, "Reject a non-finite BPM before drawing or saving a grid");
+                invalid = false; try { new TempoGridOptions { Division = 33 }.Validate(); } catch (IOException) { invalid = true; }
+                Check(invalid, "Reject unsupported grid denominators");
+
+                var legacy = InterfacePreferences.Defaults(); legacy.KeymapRevision = 0; legacy.Keybinds.RemoveAll(b => b.Action == "deleteAlternate"); legacy.Keybinds.First(b => b.Action == "delete").Key = "Delete";
+                InterfacePreferences.Upgrade(legacy); InterfacePreferences.Validate(legacy);
+                Check(legacy.Keybinds.First(b => b.Action == "delete").Key == "Back" && legacy.Keybinds.First(b => b.Action == "deleteAlternate").Key == "Delete", "Upgrade the old default to Backspace while retaining Delete as an editable alternate");
+                var custom = InterfacePreferences.Defaults(); custom.KeymapRevision = 0; custom.Keybinds.RemoveAll(b => b.Action == "deleteAlternate"); custom.Keybinds.First(b => b.Action == "delete").Key = "F9"; custom.Keybinds.First(b => b.Action == "play").Key = "Delete";
+                InterfacePreferences.Upgrade(custom); InterfacePreferences.Validate(custom);
+                Check(custom.Keybinds.First(b => b.Action == "delete").Key == "F9" && custom.Keybinds.First(b => b.Action == "play").Key == "Delete" && custom.Keybinds.First(b => b.Action == "deleteAlternate").Key == "None", "Preserve custom keybinds when a new alternate would conflict");
+                Check(InterfacePreferences.Resolve(Key.Back, ModifierKeys.None) == "delete" && InterfacePreferences.Resolve(Key.Delete, ModifierKeys.None) == "deleteAlternate", "Resolve both keyboard delete actions");
+                var preferences = InterfacePreferences.Defaults(); preferences.Grid = new TempoGridOptions { Tempo = 97.5, Division = 64, BeatsPerBar = 7, BeatUnit = 8, Triplet = true }; preferences.SnapToGrid = false;
+                string preferencePath = Path.Combine(root, "timeline-settings.xml"); InterfacePreferences.SaveToFile(preferences, preferencePath); InterfaceSettings reopened;
+                using (var file = File.OpenRead(preferencePath)) reopened = (InterfaceSettings)new XmlSerializer(typeof(InterfaceSettings)).Deserialize(file);
+                Check(reopened.Grid.Signature() == preferences.Grid.Signature() && !reopened.SnapToGrid && reopened.SnapToEdges, "Save tempo, meter, subdivisions and independent snap settings");
+                var project = new EditorSession { Grid = preferences.Grid.Copy() }; string projectPath = Path.Combine(root, "grid.dbedit"); project.Save(projectPath);
+                Check(EditorSession.Load(projectPath).Grid.Signature() == project.Grid.Signature(), "Restore the project-specific grid from a saved session");
+                var independent = project.Copy(); independent.Grid.Tempo = 150; Check(project.Grid.Tempo == 97.5, "Keep undo snapshots' grid settings independent");
+                var oldProject = new XmlDocument(); oldProject.Load(projectPath); var node = oldProject.DocumentElement.SelectSingleNode("Grid"); node.ParentNode.RemoveChild(node); oldProject.Save(Path.Combine(root, "legacy.dbedit"));
+                Check(EditorSession.Load(Path.Combine(root, "legacy.dbedit")).Grid.Tempo == 120, "Open pre-grid projects with sensible musical defaults");
+
+                string source = Path.Combine(root, "Original.wav"); var audio = new float[Audio.Rate]; for (int i = 0; i < audio.Length; i++) audio[i] = (float)(.5 * Math.Sin(i * .05));
+                using (var writer = new FloatWaveWriter(source, 1, Audio.Rate)) writer.Write(audio, audio.Length, 1);
+                byte[] original = File.ReadAllBytes(source); var clip = Audio.Load(source, Path.Combine(root, "cache"), CancellationToken.None, null);
+                var state = new EditorSession(); state.Regions.Add(new TimelineRegion { Source = source, Name = "Original", Track = 0, Length = Audio.Rate });
+                var owner = new Window(); ThemePalette.Install(owner);
+                using (var editor = new EditorView(owner, Path.Combine(root, "editor"), delegate(string text) { }, delegate { })) {
+                    owner.Content = editor; editor.SetForTest(state, new Dictionary<string, Clip> { { source, clip } }); editor.ShowSelectionForTest(11025, 22050); editor.PlayheadForTest(88200);
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.C, ModifierKeys.Control)));
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.Back, ModifierKeys.None)));
+                    Check(editor.SessionForTest.Regions.All(r => r.End <= 11025 || r.Start >= 22050), "Backspace removes only the selected section and leaves its gap");
+                    RunUi(() => editor.ExecuteAction(InterfacePreferences.Resolve(Key.V, ModifierKeys.Control)));
+                    Check(editor.SessionForTest.Regions.Any(r => r.Start == 88200 && r.Length == 11025 && r.SourceStart == 11025), "Ctrl+C then Backspace preserves the copy for Ctrl+V at the playhead");
+                    editor.ApplyGridOptions(new TempoGridOptions { Tempo = 150, Division = 32 }); RunUi(() => editor.ExecuteAction("undo"));
+                    Check(editor.GridOptions.Tempo == 120 && editor.SessionForTest.Regions.Any(r => r.Start == 88200), "Undo a tempo-grid change without undoing the audio paste");
+                    Check(original.SequenceEqual(File.ReadAllBytes(source)), "Keep the original float audio unchanged through grid editing and copy/delete/paste");
+                }
+                owner.Content = null; owner.Close();
+                File.WriteAllLines(Path.Combine(root, "grid-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "grid-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = previous; }
+        }
+    }
+}

package/source/Third Party Notices.txt

@@ -0,0 +1,32 @@
+Flux 1.5.0 - third-party components
+
+FFmpeg 9.0.2, release essentials build by Gyan Doshi
+Used as a separate command-line decoding process.
+GPL version 3. See licenses\FFmpeg-GPLv3.txt and FFmpeg-build.txt.
+Binary: https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip
+Build information and corresponding upstream source links:
+https://www.gyan.dev/ffmpeg/builds/
+https://github.com/FFmpeg/FFmpeg/tree/946fcce07b
+The build README lists linked third-party libraries and their versions.
+
+NAudio.Core, NAudio.Asio, NAudio.WinMM, NAudio.Wasapi 2.2.1
+Copyright (c) Mark Heath and contributors. MIT license.
+See licenses\NAudio-MIT.txt.
+Source: https://github.com/naudio/NAudio/tree/v2.2.1
+
+Microsoft.Win32.Registry, System.Security.AccessControl,
+System.Security.Principal.Windows 4.7.0
+Copyright (c) .NET Foundation and Contributors. MIT license.
+https://github.com/dotnet/runtime/blob/main/LICENSE.TXT
+
+Zoom H5studio and R16/R24 drivers: linked from Zoom's official support pages, not bundled.
+R16 reference panel image: copyright Zoom Corporation. The npm installer
+fetches the image directly from Zoom's public product website.
+Zoom and R16 are trademarks of Zoom Corporation. This is an independent app.
+
+The original drummer mascot was generated for Drum Buddy using OpenAI's
+built-in image-generation tool, then revised to have long curly black hair.
+
+The FluxTempo wave/tempo emblem was generated with OpenAI's built-in
+image-generation tool. The original Drum Buddy mascot is preserved in
+the source archive under brand-archive.

package/source/Timeline.cs

@@ -0,0 +1,261 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading;
+using System.Xml;
+using System.Xml.Serialization;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public sealed class EditorTrack
+    {
+        public string Name = "";
+        public bool Mute, Solo;
+        public double GainDb;
+        public EditorTrack Copy() { return (EditorTrack)MemberwiseClone(); }
+    }
+
+    public sealed class TimelineRegion
+    {
+        public string Id = Guid.NewGuid().ToString("N"), Source = "", Name = "";
+        public int Track;
+        public long Start, SourceStart, Length;
+        public long End { get { return Start + Length; } }
+        public TimelineRegion Copy() { return (TimelineRegion)MemberwiseClone(); }
+    }
+
+    public sealed class EditorSession
+    {
+        public const long MaxFrame = 44100L * 86400;
+        public int Version = 1;
+        public string Name = "Untitled session";
+        public TempoGridOptions Grid = new TempoGridOptions();
+        public EditorTrack[] Tracks = Enumerable.Range(1, 16).Select(i => new EditorTrack { Name = "Track " + i }).ToArray();
+        public List<TimelineRegion> Regions = new List<TimelineRegion>();
+        [XmlIgnore] public long End { get { return Regions.Count == 0 ? 0 : Regions.Max(r => r.End); } }
+        public EditorSession Copy()
+        { return new EditorSession { Version = Version, Name = Name, Grid = Grid.Copy(), Tracks = Tracks.Select(t => t.Copy()).ToArray(), Regions = Regions.Select(r => r.Copy()).ToList() }; }
+
+        public void Validate()
+        {
+            if (Grid == null) Grid = new TempoGridOptions(); Grid.Validate();
+            if (Version != 1 || Tracks == null || Tracks.Length != 16 || Regions == null || Regions.Count > 20000)
+                throw new IOException("This is not a supported Flux 16-track editor session.");
+            foreach (var track in Tracks)
+                if (track == null || double.IsNaN(track.GainDb) || double.IsInfinity(track.GainDb) || track.GainDb < -60 || track.GainDb > 12)
+                    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)
+                    throw new IOException("The session has an invalid audio region.");
+        }
+
+        public static EditorSession Load(string path)
+        {
+            using (var reader = XmlReader.Create(path, new XmlReaderSettings { DtdProcessing = DtdProcessing.Prohibit, XmlResolver = null, MaxCharactersInDocument = 32000000 })) {
+                var session = (EditorSession)new XmlSerializer(typeof(EditorSession)).Deserialize(reader);
+                session.Validate(); return session;
+            }
+        }
+        public void Save(string path)
+        {
+            Validate(); string target = Path.GetFullPath(path);
+            if (Regions.Any(r => string.Equals(Path.GetFullPath(r.Source), target, StringComparison.OrdinalIgnoreCase)))
+                throw new IOException("Choose a session file name different from your original audio files.");
+            string temp = target + "." + Guid.NewGuid().ToString("N") + ".partial";
+            try {
+                using (var file = File.Create(temp)) new XmlSerializer(typeof(EditorSession)).Serialize(file, this);
+                if (File.Exists(target)) File.Replace(temp, target, null); else File.Move(temp, target);
+            }
+            finally { Audio.TryDelete(temp); }
+        }
+    }
+
+    public sealed class TimelineClipboard
+    {
+        public bool AllTracks;
+        public long Length;
+        public List<TimelineRegion> Regions = new List<TimelineRegion>();
+    }
+
+    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)
+        {
+            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)) {
+                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;
+                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)
+        {
+            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; }
+                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); }
+            }
+            session.Regions = result; return changed;
+        }
+        public static bool Split(EditorSession session, int track, bool all, long frame)
+        {
+            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;
+                result.Add(left); result.Add(right); changed = true;
+            }
+            session.Regions = result; return changed;
+        }
+        public static bool Paste(EditorSession session, TimelineClipboard copied, int track, long at)
+        {
+            if (copied == null || copied.Regions.Count == 0) return false;
+            if (at < 0 || at > EditorSession.MaxFrame - copied.Length || track < 0 || track >= 16)
+                throw new IOException("The pasted selection would exceed the timeline.");
+            foreach (var r in copied.Regions) {
+                var part = r.Copy(); part.Id = Guid.NewGuid().ToString("N"); part.Start += at;
+                if (!copied.AllTracks) part.Track = track;
+                session.Regions.Add(part);
+            }
+            return true;
+        }
+    }
+
+    // The edit model uses integer audio frames. Rendering does not modify source files.
+    public sealed class TimelineMix : ISampleProvider, IDisposable
+    {
+        private sealed class Asset : IDisposable
+        {
+            public WaveFileReader Reader;
+            public byte[] Bytes = new byte[0];
+            public float[] Samples = new float[0];
+            public void Dispose() { Reader.Dispose(); }
+        }
+        private readonly object gate = new object();
+        private readonly EditorSession session;
+        private readonly Dictionary<string, Asset> assets = new Dictionary<string, Asset>(StringComparer.OrdinalIgnoreCase);
+        private long position;
+        private bool disposed;
+        public float Peak;
+        public readonly float[] TrackPeaks = new float[16];
+        public WaveFormat WaveFormat { get { return WaveFormat.CreateIeeeFloatWaveFormat(Audio.Rate, 2); } }
+        public long End { get { return session.End; } }
+        public long Position { get { lock (gate) return position; } }
+
+        public TimelineMix(EditorSession state, IDictionary<string, Clip> decoded)
+        {
+            state.Validate(); session = state.Copy();
+            try {
+                foreach (string source in session.Regions.Select(r => r.Source).Distinct(StringComparer.OrdinalIgnoreCase)) {
+                    Clip clip;
+                    if (!decoded.TryGetValue(source, out clip) || clip == null || !clip.Ready) throw new IOException("Audio is missing: " + Path.GetFileName(source));
+                    var reader = new WaveFileReader(clip.Cache);
+                    if (reader.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat || reader.WaveFormat.BitsPerSample != 32 || reader.WaveFormat.SampleRate != Audio.Rate || reader.WaveFormat.Channels < 1 || reader.WaveFormat.Channels > 2) {
+                        reader.Dispose(); throw new IOException("Re-import this audio file before using it on the timeline.");
+                    }
+                    assets.Add(source, new Asset { Reader = reader });
+                }
+                foreach (var r in session.Regions)
+                    if (r.SourceStart + r.Length > assets[r.Source].Reader.Length / assets[r.Source].Reader.WaveFormat.BlockAlign)
+                        throw new IOException("An audio source is shorter than its saved region: " + r.Name);
+            }
+            catch { Dispose(); throw; }
+        }
+        public void Seek(long frame) { lock (gate) { position = Math.Max(0, Math.Min(End, frame)); } }
+        public int Read(float[] output, int offset, int count)
+        {
+            lock (gate) {
+                if (disposed || position >= End) return 0;
+                int frames = (int)Math.Min(count / 2, End - position);
+                if (frames == 0) return 0;
+                Array.Clear(output, offset, frames * 2);
+                bool solo = session.Tracks.Any(t => t.Solo);
+                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;
+                    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;
+                    int byteCount = checked(take * channels * 4);
+                    if (asset.Bytes.Length < byteCount) { asset.Bytes = new byte[byteCount]; asset.Samples = new float[byteCount / 4]; }
+                    asset.Reader.Position = (r.SourceStart + from - r.Start) * channels * 4;
+                    int got = 0, n;
+                    while (got < byteCount && (n = asset.Reader.Read(asset.Bytes, got, byteCount - got)) > 0) got += n;
+                    if (got != byteCount) throw new IOException("An audio source changed while playing. Reopen the session.");
+                    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;
+                        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)));
+                    }
+                }
+                for (int i = offset; i < offset + frames * 2; i++) {
+                    if (float.IsNaN(output[i]) || float.IsInfinity(output[i])) throw new IOException("The mix contains invalid audio samples.");
+                    Peak = Math.Max(Peak, Math.Abs(output[i]));
+                }
+                position += frames; return frames * 2;
+            }
+        }
+        public void Dispose()
+        { lock (gate) { if (disposed) return; disposed = true; foreach (var asset in assets.Values) asset.Dispose(); assets.Clear(); } }
+    }
+
+    public static class TimelineRender
+    {
+        public static void Export(EditorSession session, IDictionary<string, Clip> assets, string path, int bits, bool protect, long from, long to, CancellationToken cancel, Action<double> progress)
+        {
+            if (bits != 16 && bits != 24 && bits != 32) throw new ArgumentException("Choose PCM 16-bit, PCM 24-bit, or 32-bit float.");
+            session.Validate(); string target = Path.GetFullPath(path);
+            if (session.Regions.Any(r => string.Equals(Path.GetFullPath(r.Source), target, StringComparison.OrdinalIgnoreCase)))
+                throw new IOException("Choose a new export file name to preserve your original audio.");
+            from = Math.Max(0, from); to = to <= 0 ? session.End : Math.Min(to, session.End);
+            long frames = to - from;
+            if (frames <= 0) throw new IOException("The selected timeline range has no audio to export.");
+            if (frames * 2 * (bits / 8) > FloatWaveWriter.MaxData) throw new IOException("This mix would exceed the 4 GB WAV limit. Export a shorter selection.");
+            string temp = target + "." + Guid.NewGuid().ToString("N") + ".partial";
+            try {
+                using (var mix = new TimelineMix(session, assets)) {
+                    var buffer = new float[8192 * 2]; double scale = 1; bool scan = protect && bits != 32;
+                    if (scan) {
+                        mix.Seek(from); long remaining = frames;
+                        while (remaining > 0) {
+                            cancel.ThrowIfCancellationRequested(); int read = mix.Read(buffer, 0, (int)Math.Min(8192, remaining) * 2);
+                            if (read == 0) throw new IOException("The audio ended before the selection finished.");
+                            remaining -= read / 2; if (progress != null) progress((1 - remaining / (double)frames) * .45);
+                        }
+                        if (mix.Peak > .891250938f) scale = .891250938 / mix.Peak;
+                    }
+                    mix.Seek(from);
+                    IRecordingWriter writer = bits == 32 ? (IRecordingWriter)new FloatWaveWriter(temp, 2, Audio.Rate) : new PcmWriter(temp, bits, 2);
+                    using (writer) {
+                        long remaining = frames;
+                        while (remaining > 0) {
+                            cancel.ThrowIfCancellationRequested(); int read = mix.Read(buffer, 0, (int)Math.Min(8192, remaining) * 2);
+                            if (read == 0) throw new IOException("The audio ended before the selection finished.");
+                            writer.Write(buffer, read, scale); remaining -= read / 2;
+                            if (progress != null) progress((scan ? .45 : 0) + (1 - remaining / (double)frames) * (scan ? .55 : 1));
+                        }
+                    }
+                }
+                cancel.ThrowIfCancellationRequested();
+                if (File.Exists(target)) File.Replace(temp, target, null); else File.Move(temp, target);
+            }
+            finally { Audio.TryDelete(temp); }
+        }
+    }
+}

package/source/TimelineGestures.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+
+namespace DrumBuddy
+{
+    internal enum TimelineDrag { None, Playhead, Selection, SelectionStart, SelectionEnd }
+    internal sealed class TimelineGesture
+    {
+        public TimelineDrag Mode;
+        public long Playhead, From, To;
+        private long anchor, oldPlayhead, oldFrom, oldTo;
+        public void Begin(TimelineDrag mode, long frame, long playhead, long from, long to)
+        {
+            Mode = mode; anchor = frame; oldPlayhead = Playhead = playhead; oldFrom = From = from; oldTo = To = to;
+            Move(frame);
+        }
+        public void Move(long frame)
+        {
+            frame = Math.Max(0, Math.Min(EditorSession.MaxFrame, frame));
+            if (Mode == TimelineDrag.Playhead) Playhead = frame;
+            else if (Mode == TimelineDrag.Selection) { From = Math.Min(anchor, frame); To = Math.Max(anchor, frame); }
+            else if (Mode == TimelineDrag.SelectionStart) From = Math.Min(frame, To);
+            else if (Mode == TimelineDrag.SelectionEnd) To = Math.Max(From, frame);
+        }
+        public void End(long frame) { Move(frame); Mode = TimelineDrag.None; }
+        public void Finish() { Mode = TimelineDrag.None; }
+        public void Cancel() { Playhead = oldPlayhead; From = oldFrom; To = oldTo; Mode = TimelineDrag.None; }
+        public static long FrameAt(double x, double pixelsPerSecond, IEnumerable<long> boundaries, bool precise)
+        { return FrameAt(x, pixelsPerSecond, boundaries, precise, null, false, true); }
+        public static long FrameAt(double x, double pixelsPerSecond, IEnumerable<long> boundaries, bool precise, TempoGridOptions grid, bool snapGrid, bool snapEdges)
+        {
+            if (double.IsNaN(x) || double.IsInfinity(x) || pixelsPerSecond <= 0) return 0;
+            x = Math.Max(0, x);
+            long frame = Math.Max(0, Math.Min(EditorSession.MaxFrame, (long)Math.Round(x / pixelsPerSecond * Audio.Rate)));
+            if (precise) return frame;
+            double zeroRange = snapGrid && grid != null ? Math.Min(10, Math.Min(TempoGrid.StepSeconds(grid), TempoGrid.BarSeconds(grid)) * pixelsPerSecond / 2) : 10;
+            if ((snapEdges || snapGrid) && (snapGrid ? x < zeroRange : x <= zeroRange)) return 0;
+            double nearest = 8; long snapped = frame; bool edge = false;
+            if (snapEdges) foreach (long boundary in boundaries) {
+                if (boundary < 0 || boundary > EditorSession.MaxFrame) continue;
+                double distance = Math.Abs(boundary / (double)Audio.Rate * pixelsPerSecond - x);
+                if (boundary == 0 && snapGrid && distance >= zeroRange) continue;
+                if (distance < nearest) { nearest = distance; snapped = boundary; edge = true; }
+            }
+            return edge ? snapped : snapGrid && grid != null ? TempoGrid.Snap(frame, grid) : frame;
+        }
+        public static TimelineDrag RulerHit(double x, double y, double startX, double endX, bool hasRange)
+        {
+            if (hasRange && y >= 13) {
+                double a = Math.Abs(x - startX), b = Math.Abs(x - endX);
+                if (a <= 10 && a <= b) return TimelineDrag.SelectionStart;
+                if (b <= 10) return TimelineDrag.SelectionEnd;
+            }
+            return TimelineDrag.Playhead;
+        }
+    }
+}

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