@pro-gram/flux 1.5.0 → 1.6.1

package/source/EditorTools.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace DrumBuddy
+{
+    internal enum ClipDrag { None, Move, TrimLeft, TrimRight, Slip, FadeIn, FadeOut }
+    public static class EditorTools
+    {
+        public static double Envelope(TimelineRegion region, long offset)
+        {
+            double value = 1;
+            if (region.FadeIn > 0) value = Math.Min(value, Math.Max(0, offset + region.FadeInOffset) / (double)region.FadeIn);
+            if (region.FadeOut > 0) value = Math.Min(value, Math.Max(0, region.Length - 1 - offset + region.FadeOutOffset) / (double)region.FadeOut);
+            return Math.Max(0, Math.Min(1, value));
+        }
+        public static void ClampFades(TimelineRegion region)
+        { region.FadeIn = Math.Max(0, Math.Min(region.Length, region.FadeIn)); region.FadeOut = Math.Max(0, Math.Min(region.Length, region.FadeOut)); region.FadeInOffset = region.FadeOutOffset = 0; }
+        public static bool Move(EditorSession session, ISet<string> ids, long delta, int tracks)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            delta = Math.Max(-selected.Min(r => r.Start), Math.Min(EditorSession.MaxFrame - selected.Max(r => r.End), delta));
+            tracks = Math.Max(-selected.Min(r => r.Track), Math.Min(15 - selected.Max(r => r.Track), tracks));
+            if (delta == 0 && tracks == 0) return false;
+            foreach (var region in selected) { region.Start += delta; region.Track += tracks; } return true;
+        }
+        public static bool Trim(TimelineRegion region, bool left, long boundary, long sourceFrames)
+        {
+            if (sourceFrames < region.SourceStart + region.Length) throw new IOException("Re-import the source before extending this clip.");
+            long before = region.Length;
+            if (left) {
+                long start = Math.Max(Math.Max(0, region.Start - region.SourceStart), Math.Min(region.End - 1, boundary));
+                long delta = start - region.Start; region.Start = start; region.SourceStart += delta; region.Length -= delta;
+            }
+            else {
+                long end = Math.Max(region.Start + 1, Math.Min(Math.Min(EditorSession.MaxFrame, region.Start + sourceFrames - region.SourceStart), boundary)); region.Length = end - region.Start;
+            }
+            ClampFades(region); return before != region.Length;
+        }
+        public static bool Slip(TimelineRegion region, long delta, long sourceFrames)
+        {
+            long before = region.SourceStart; region.SourceStart = Math.Max(0, Math.Min(sourceFrames - region.Length, region.SourceStart + delta));
+            return before != region.SourceStart;
+        }
+        public static bool Fade(TimelineRegion region, bool fadeIn, long length)
+        {
+            length = Math.Max(0, Math.Min(region.Length, length)); long before = fadeIn ? region.FadeIn : region.FadeOut;
+            if (fadeIn) { region.FadeIn = length; region.FadeInOffset = 0; } else { region.FadeOut = length; region.FadeOutOffset = 0; } return before != length;
+        }
+        public static List<string> Repeat(EditorSession session, ISet<string> ids, int copies)
+        {
+            var source = session.Regions.Where(r => ids.Contains(r.Id)).ToArray();
+            if (source.Length == 0) throw new IOException("Select clips to duplicate or repeat.");
+            if (copies < 1 || copies > 64 || session.Regions.Count + copies * source.Length > 20000) throw new IOException("Choose 1 to 64 additional copies within the session's region limit.");
+            long length = source.Max(r => r.End) - source.Min(r => r.Start);
+            if (length > (EditorSession.MaxFrame - source.Max(r => r.End)) / copies) throw new IOException("The repeats would exceed the 24-hour timeline.");
+            var added = new List<string>();
+            for (int n = 1; n <= copies; n++) foreach (var item in source) {
+                var copy = item.Copy(); copy.Id = Guid.NewGuid().ToString("N"); copy.Start += length * n; session.Regions.Add(copy); added.Add(copy.Id);
+            }
+            return added;
+        }
+        public static bool ToggleMute(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).ToArray(); if (selected.Length == 0) return false;
+            bool mute = selected.Any(r => !r.Muted); foreach (var region in selected) region.Muted = mute; return true;
+        }
+        public static bool Crossfade(EditorSession session, ISet<string> ids)
+        {
+            var selected = session.Regions.Where(r => ids.Contains(r.Id)).OrderBy(r => r.Start).ToArray();
+            if (selected.Length != 2 || selected[0].Track != selected[1].Track || selected[0].Start >= selected[1].Start || selected[0].End <= selected[1].Start || selected[0].End > selected[1].End)
+                throw new IOException("Select two overlapping clips on one track, with the second extending beyond the first, to crossfade.");
+            long overlap = selected[0].End - selected[1].Start;
+            selected[0].FadeOut = overlap; selected[0].FadeOutOffset = 0; selected[1].FadeIn = overlap; selected[1].FadeInOffset = 1; return true;
+        }
+    }
+}

package/source/EditorToolsTests.cs

@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace DrumBuddy
+{
+    public static class EditorToolsTests
+    {
+        private static readonly List<string> log = new List<string>();
+        private static void Check(bool value, string text) { if (!value) throw new Exception(text); log.Add("PASS  " + text); }
+        private static long Frame(double seconds) { return (long)Math.Round(seconds * Audio.Rate); }
+        private static float[] Render(EditorSession session, IDictionary<string, Clip> assets)
+        {
+            using (var mix = new TimelineMix(session, assets)) { var output = new float[checked((int)session.End * 2)]; int n = 0, read; while ((read = mix.Read(output, n, output.Length - n)) > 0) n += read; return output; }
+        }
+        private static void Picture(FrameworkElement view, string file)
+        {
+            view.Measure(new Size(1100, 650)); view.Arrange(new Rect(0, 0, 1100, 650)); view.UpdateLayout();
+            var bitmap = new RenderTargetBitmap(1100, 650, 96, 96, PixelFormats.Pbgra32); bitmap.Render(view);
+            var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bitmap)); using (var output = File.Create(file)) encoder.Save(output);
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args[0]); Directory.CreateDirectory(root); log.Clear(); var preferences = InterfacePreferences.Current;
+            try {
+                InterfacePreferences.Current = InterfacePreferences.Defaults(); InterfacePreferences.Current.SnapToGrid = InterfacePreferences.Current.SnapToEdges = false;
+                string file = Path.Combine(root, "Original float.wav"); var samples = Enumerable.Repeat(1.5f, Audio.Rate * 4).ToArray();
+                using (var writer = new FloatWaveWriter(file, 1, Audio.Rate)) writer.Write(samples, samples.Length, 1);
+                byte[] original = File.ReadAllBytes(file);
+                var clip = new Clip { Source = file, Cache = file, Name = "Original float.wav", Channels = 1, Duration = 4, Peak = 1.5, Waveform = Enumerable.Repeat(1.5f, 900).ToArray(), Ready = true };
+                var assets = new Dictionary<string, Clip> { { file, clip } };
+                var fade = new EditorSession(); fade.Regions.Add(new TimelineRegion { Id = "fade", Source = file, Length = 100, FadeIn = 20, FadeOut = 20 });
+                var rendered = Render(fade, assets);
+                Check(rendered[0] == 0 && rendered[40] == 1.5f && rendered[198] == 0, "Apply clip fade-in/out to actual float samples while retaining headroom");
+                var split = fade.Copy(); TimelineEdits.Split(split, 0, false, 10); split.Validate(); Check(rendered.SequenceEqual(Render(split, assets)), "Splitting inside a fade preserves the exact audible envelope");
+                var copied = TimelineEdits.Copy(fade, 0, false, 5, 85); var pasted = new EditorSession(); TimelineEdits.Paste(pasted, copied, 0, 0);
+                Check(Render(pasted, assets).SequenceEqual(rendered.Skip(10).Take(160)), "Copy/paste part of a faded clip preserves its original sample levels");
+                var muted = fade.Copy(); EditorTools.ToggleMute(muted, new HashSet<string> { "fade" }); Check(Render(muted, assets).All(v => v == 0), "Clip mute silences playback and mix output without changing source audio");
+                var cross = new EditorSession(); cross.Regions.Add(new TimelineRegion { Id = "a", Source = file, Length = 100 }); cross.Regions.Add(new TimelineRegion { Id = "b", Source = file, Start = 80, Length = 100 });
+                EditorTools.Crossfade(cross, new HashSet<string> { "a", "b" });
+                Check(Render(cross, assets).Skip(160).Take(40).All(v => Math.Abs(v - 1.5f) < 1e-6), "Crossfade overlapping clips with complementary levels across the overlap");
+                string exported = Path.Combine(root, "Faded mix.wav"); TimelineRender.Export(fade, assets, exported, 32, false, 0, 0, CancellationToken.None, null);
+                using (var wave = new NAudio.Wave.WaveFileReader(exported)) { var bytes = new byte[checked((int)wave.Length)]; wave.Read(bytes, 0, bytes.Length); var actual = new float[bytes.Length / 4]; Buffer.BlockCopy(bytes, 0, actual, 0, bytes.Length); Check(actual.SequenceEqual(rendered), "Save the same clip fades heard in playback into a float mix export"); }
+                string project = Path.Combine(root, "Fades.dbedit"); split.Regions[0].Muted = true; split.Save(project); var loaded = EditorSession.Load(project);
+                Check(loaded.Regions[0].Muted && loaded.Regions[1].FadeInOffset == 10, "Persist clip mute, fades and split-envelope offsets in project files");
+                var state = new EditorSession { Name = "Clip tools" };
+                state.Regions.Add(new TimelineRegion { Id = "first", Name = "Move / trim / slip", Source = file, Start = Frame(1), SourceStart = Frame(1), Length = Frame(2) });
+                state.Regions.Add(new TimelineRegion { Id = "second", Name = "Group item", Source = file, Track = 1, Start = Frame(2), Length = Frame(1) });
+                var owner = new Window(); ThemePalette.Apply(true); ThemePalette.Install(owner);
+                using (var editor = new EditorView(owner, Path.Combine(root, "cache"), delegate { }, delegate { })) {
+                    owner.Content = editor; editor.SetForTest(state, assets); editor.ZoomForTest(250); Picture(editor, Path.Combine(root, "clip-tools-start.png"));
+                    editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.PointerDownForTest(Frame(2.25), 1, true);
+                    editor.ToolDownForTest("first", "Move", Frame(1.5)); editor.ToolMoveForTest(Frame(3.5), 2); editor.ToolEndForTest(false);
+                    var moved = editor.SessionForTest;
+                    Check(moved.Regions.Single(r => r.Id == "first").Start == Frame(3) && moved.Regions.Single(r => r.Id == "second").Start == Frame(4) && moved.Regions.Single(r => r.Id == "first").Track == 2 && moved.Regions.Single(r => r.Id == "second").Track == 3, "Move a selected clip group in time and across tracks without losing relative placement");
+                    editor.ExecuteAction("undo").GetAwaiter().GetResult(); Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").Start == Frame(1), "Undo a complete clip drag as one edit");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "Move", Frame(1.5)); editor.ToolMoveForTest(Frame(2.5), 2); editor.ToolEndForTest(true);
+                    Check(!editor.Dirty && editor.SessionForTest.Regions.Single(r => r.Id == "first").Track == 0 && editor.SessionForTest.Regions.Single(r => r.Id == "first").Start == Frame(1), "Cancel a clip drag without changing the session or dirty state");
+                    editor.ToolDownForTest("first", "TrimLeft", Frame(1)); editor.ToolMoveForTest(Frame(1.5), 0); editor.ToolEndForTest(false);
+                    var trimmed = editor.SessionForTest.Regions.Single(r => r.Id == "first"); Check(trimmed.Start == Frame(1.5) && trimmed.SourceStart == Frame(1.5) && trimmed.Length == Frame(1.5), "Trim the left edge while advancing the exact source offset");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "TrimRight", Frame(3)); editor.ToolMoveForTest(Frame(8), 0); editor.ToolEndForTest(false);
+                    Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").End == Frame(4), "Clamp edge extension to available source audio");
+                    editor.SetForTest(state, assets); editor.ToolDownForTest("first", "Slip", Frame(1.5)); editor.ToolMoveForTest(Frame(1.25), 0); editor.ToolEndForTest(false);
+                    var slipped = editor.SessionForTest.Regions.Single(r => r.Id == "first"); Check(slipped.SourceStart == Frame(1.25) && slipped.Start == Frame(1) && slipped.Length == Frame(2), "Slip source contents while retaining clip start and end");
+                    editor.ToolDownForTest("first", "FadeIn", Frame(1)); editor.ToolMoveForTest(Frame(1.5), 0); editor.ToolEndForTest(false); editor.ToolDownForTest("first", "FadeOut", Frame(3)); editor.ToolMoveForTest(Frame(2.5), 0); editor.ToolEndForTest(false);
+                    Check(editor.SessionForTest.Regions.Single(r => r.Id == "first").FadeIn == Frame(.5) && editor.SessionForTest.Regions.Single(r => r.Id == "first").FadeOut == Frame(.5), "Commit both fade handles as audible, undoable clip properties");
+                    editor.ExecuteAction("zoomSelection").GetAwaiter().GetResult(); Picture(editor, Path.Combine(root, "clip-tools-fades.png"));
+                    editor.SetForTest(state, assets); editor.PointerDownForTest(Frame(1.25), 0, false); editor.PointerUpForTest(Frame(1.25)); editor.ExecuteAction("duplicate").GetAwaiter().GetResult();
+                    Check(editor.SessionForTest.Regions.Any(r => r.Id != "first" && r.Track == 0 && r.Start == Frame(3) && r.SourceStart == Frame(1)), "Duplicate selected audio directly after its original duration");
+                    editor.SetForTest(state, assets); editor.ShowSelectionForTest(Frame(1.25), Frame(1.75)); editor.ContextForTest(Frame(1.5), 0);
+                    Check(editor.SelectedClipsForTest == 0, "Keep a dragged time range active when opening its context menu");
+                    editor.ExecuteAction("clearFades").GetAwaiter().GetResult();
+                    Check(!editor.Dirty && editor.SessionForTest.Regions.Count == 2, "Roll back temporary splits when a range operation makes no audio change");
+                }
+                owner.Content = null; owner.Close();
+                var repeats = state.Copy(); EditorTools.Repeat(repeats, new HashSet<string> { "first", "second" }, 3);
+                Check(repeats.Regions.Count == 8 && repeats.Regions.Any(r => r.Track == 1 && r.Start == Frame(8)), "Repeat selected multitrack clips with their timing and source windows intact");
+                bool rejected = false; int before = repeats.Regions.Count; try { EditorTools.Repeat(repeats, new HashSet<string> { "first" }, 65); } catch (IOException) { rejected = true; }
+                Check(rejected && repeats.Regions.Count == before, "Reject excessive repeats before partially editing the project");
+                Check(original.SequenceEqual(File.ReadAllBytes(file)), "Keep original audio byte-for-byte unchanged across all new clip tools");
+                File.WriteAllLines(Path.Combine(root, "tools-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "tools-test-results.txt"), log, Encoding.UTF8); return 1; }
+            finally { InterfacePreferences.Current = preferences; ThemePalette.Apply(preferences.Theme == "Dark"); }
+        }
+    }
+}