@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/NativeMemory.cs

@@ -0,0 +1,165 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    // Independent binary reader/writer. Format research: zoomrlib 1.1.0 by
+    // Remy Taymans and Glenn Boysko, https://gitlab.com/remytms/zoomrlib.
+    // Retain the original container; patch only identified fields. Do not synthesize firmware state.
+    public sealed class R16Project
+    {
+        public const int ProjectSize=3332;
+        public static readonly int[] Frequencies={40,50,63,80,100,125,160,200,250,315,400,500,630,800,1000,1300,1600,2000,2500,3200,4000,5000,6300,8000,10000,12500,16000,18000};
+        public string Folder, Name;
+        public int Bits, Master;
+        public bool Protected;
+        public byte[] Raw;
+        public string ReverbPatch="Not available",ChorusPatch="Not available";
+        public readonly TrackState[] Tracks=new TrackState[16];
+        public readonly string[] AssignedFiles=new string[16];
+        public static R16Project Read(string folder)
+        {
+            string path=Path.Combine(Path.GetFullPath(folder),"PRJDATA.ZDT");
+            byte[] raw=File.ReadAllBytes(path);
+            if(raw.Length!=ProjectSize || Text(raw,0,47)!="ZOOM R-16  PROJECT DATA VER0001")
+                throw new IOException("This is not a supported R16 VER0001 project. Its files have not been changed.");
+            var p=new R16Project { Folder=Path.GetDirectoryName(path),Raw=raw,Name=Text(raw,52,8),Bits=raw[3320]==0?16:24,Master=Int(raw,1188),Protected=raw[48]!=0 };
+            if(p.Master<0 || p.Master>127) throw new IOException("Unsupported R16 master level.");
+            for(int i=0;i<16;i++) {
+                string filename=Text(raw,1192+16*i,12);
+                if(filename.Length>0 && !ValidFilename(filename)) throw new IOException("The R16 project contains an unsupported file assignment.");
+                p.AssignedFiles[i]=filename;
+                int eq=416+48*i;
+                var track=new TrackState {
+                    File=filename.Length==0?"":Path.Combine(p.Folder,"AUDIO",filename),Name=Path.GetFileNameWithoutExtension(filename),
+                    Fader=Int(raw,96+4*i),Pan=Int(raw,160+4*i)-50,
+                    Mute=!Bit(raw,84,i),Arm=Bit(raw,80,i),Stereo=Bit(raw,1184,i),Invert=Int(raw,352+4*i)!=0,
+                    Chorus=Int(raw,224+4*i),Reverb=Int(raw,288+4*i),ChorusOn=Bit(raw,1468,i),ReverbOn=Bit(raw,1472,i),
+                    HighOn=Int(raw,eq)!=0,HighFreq=Frequency(Int(raw,eq+4),11,17),HighGain=Int(raw,eq+12)-12,
+                    MidOn=Int(raw,eq+16)!=0,MidFreq=Frequency(Int(raw,eq+20),0,28),MidQ=(Int(raw,eq+24)+1)/10.0,MidGain=Int(raw,eq+28)-12,
+                    LowOn=Int(raw,eq+32)!=0,LowFreq=Frequency(Int(raw,eq+36),0,17),LowGain=Int(raw,eq+44)-12
+                };
+                MixerEngine.Validate(track); p.Tracks[i]=track;
+            }
+            string efx=Path.Combine(p.Folder,"EFXDATA.ZDT");
+            if(File.Exists(efx)) {
+                byte[] data=File.ReadAllBytes(efx);
+                if(data.Length==39032 && Text(data,0,47)=="ZOOM R-16  EFFECT DATA VER0001") {
+                    p.ChorusPatch=Text(data,0xE8,8)+" (#"+Int(data,0x58)+")";
+                    p.ReverbPatch=Text(data,0x106,8)+" (#"+Int(data,0x5C)+")";
+                }
+            }
+            return p;
+        }
+        private static int Frequency(int index,int start,int count) { if(index<0 || index>=count) throw new IOException("Unsupported R16 EQ frequency."); return Frequencies[index+start]; }
+        public static string Text(byte[] data,int offset,int length) { return Encoding.ASCII.GetString(data,offset,length).Trim('\0',' '); }
+        private static int Int(byte[] data,int offset) { return BitConverter.ToInt32(data,offset); }
+        private static bool Bit(byte[] data,int offset,int index) { return (BitConverter.ToUInt16(data,offset)&(1<<index))!=0; }
+        private static void Put(byte[] data,int offset,int value) { Buffer.BlockCopy(BitConverter.GetBytes(value),0,data,offset,4); }
+        private static void SetBit(byte[] data,int offset,int index,bool value) { int mask=BitConverter.ToUInt16(data,offset); mask=value?mask|(1<<index):mask&~(1<<index); data[offset]=(byte)mask; data[offset+1]=(byte)(mask>>8); }
+        public static bool ValidFilename(string value) { return Regex.IsMatch(value,@"^[A-Z0-9_\-]{1,8}\.WAV$"); }
+        public byte[] Build(MixerSession state,string[] filenames)
+        {
+            if(state.Tracks==null || state.Tracks.Length!=16 || filenames.Length!=16) throw new IOException("A project must have sixteen tracks.");
+            byte[] result=(byte[])Raw.Clone();
+            string name=state.Name;
+            if(name!=Name) {
+                if(string.IsNullOrEmpty(name) || name.Length>8 || name.Any(c=>c<32 || c>126)) throw new IOException("Use 1–8 plain characters for an R16 project name.");
+                Buffer.BlockCopy(Encoding.ASCII.GetBytes(name.PadRight(8)),0,result,52,8);
+            }
+            result[3320]=(byte)(state.Bits==16?0:1);
+            if(state.Master<0 || state.Master>127) throw new IOException("Invalid master level.");
+            Put(result,1188,state.Master);
+            for(int i=0;i<16;i++) {
+                TrackState t=state.Tracks[i]; MixerEngine.Validate(t);
+                if(filenames[i]!="" && !ValidFilename(filenames[i])) throw new IOException("R16 filenames must be uppercase 8.3 WAV names.");
+                if(filenames[i]!=AssignedFiles[i]) {
+                    Array.Clear(result,1192+16*i,16);
+                    if(filenames[i].Length>0) Buffer.BlockCopy(Encoding.ASCII.GetBytes(filenames[i].PadRight(12)),0,result,1192+16*i,12);
+                }
+                SetBit(result,80,i,t.Arm); SetBit(result,84,i,!t.Mute || t.Arm); SetBit(result,1184,i,t.Stereo);
+                Put(result,96+4*i,t.Fader); Put(result,160+4*i,t.Pan+50); Put(result,352+4*i,t.Invert?1:0);
+                Put(result,224+4*i,t.Chorus); Put(result,288+4*i,t.Reverb); SetBit(result,1468,i,t.ChorusOn); SetBit(result,1472,i,t.ReverbOn);
+                int eq=416+48*i;
+                PutEq(result,eq,t.HighOn,t.HighFreq,t.HighGain,11,17);
+                PutEq(result,eq+16,t.MidOn,t.MidFreq,t.MidGain,0,28);
+                Put(result,eq+24,(int)Math.Round(t.MidQ*10)-1);
+                PutEq(result,eq+32,t.LowOn,t.LowFreq,t.LowGain,0,17);
+            }
+            return result;
+        }
+        private static void PutEq(byte[] data,int offset,bool on,int frequency,int gain,int start,int count)
+        {
+            int index=Array.IndexOf(Frequencies,frequency)-start;
+            if(index<0 || index>=count) throw new IOException("This EQ frequency is not supported by the R16.");
+            Put(data,offset,on?1:0); Put(data,offset+4,index); Put(data,offset+12,gain+12);
+        }
+        public static string CopyFolder(string source,string parent,CancellationToken cancel)
+        {
+            source=Path.GetFullPath(source).TrimEnd(Path.DirectorySeparatorChar);
+            parent=Path.GetFullPath(parent).TrimEnd(Path.DirectorySeparatorChar);
+            if(parent.Equals(source,StringComparison.OrdinalIgnoreCase) || parent.StartsWith(source+Path.DirectorySeparatorChar,StringComparison.OrdinalIgnoreCase))
+                throw new IOException("Choose a destination outside the source project folder.");
+            Directory.CreateDirectory(parent);
+            string target=null;
+            for(int i=0;i<1000;i++) { string candidate=Path.Combine(parent,"PROJ"+i.ToString("000")); if(!Directory.Exists(candidate) && !File.Exists(candidate)) { target=candidate; break; } }
+            if(target==null) throw new IOException("There are already 1000 projects in this folder.");
+            Directory.CreateDirectory(target);
+            CopyTree(source,target,cancel);
+            return target;
+        }
+        private static void CopyTree(string source,string target,CancellationToken cancel)
+        {
+            foreach(string path in Directory.GetFileSystemEntries(source)) {
+                cancel.ThrowIfCancellationRequested();
+                var attributes=File.GetAttributes(path);
+                if((attributes&FileAttributes.ReparsePoint)!=0) throw new IOException("Linked files are not supported inside an R16 project.");
+                string dest=Path.Combine(target,Path.GetFileName(path));
+                if((attributes&FileAttributes.Directory)!=0) { Directory.CreateDirectory(dest); CopyTree(path,dest,cancel); }
+                else { File.Copy(path,dest,false); File.SetAttributes(dest,File.GetAttributes(dest)&~FileAttributes.ReadOnly); }
+            }
+        }
+        public string SaveCopy(string parent,MixerSession session,Clip[] clips,CancellationToken cancel)
+        {
+            // The destination is always a newly created project. The source card is never patched.
+            string destination=CopyFolder(Folder,parent,cancel);
+            var names=(string[])AssignedFiles.Clone();
+            Directory.CreateDirectory(Path.Combine(destination,"AUDIO"));
+            for(int i=0;i<16;i++) {
+                cancel.ThrowIfCancellationRequested();
+                if(clips[i]==null) {
+                    if(string.IsNullOrEmpty(session.Tracks[i].File)) names[i]="";
+                    continue;
+                }
+                string original=AssignedFiles[i].Length==0?"":Path.Combine(Folder,"AUDIO",AssignedFiles[i]);
+                if(string.Equals(Path.GetFullPath(clips[i].Source),original,StringComparison.OrdinalIgnoreCase) && session.Tracks[i].Offset==0) continue;
+                Clip clip=clips[i];
+                if(session.Tracks[i].Offset==0) {
+                    double gain=clip.Gain; clip.Gain=0;
+                    try { names[i]=Path.GetFileName(Audio.Export(clip,Path.Combine(destination,"AUDIO"),session.Bits,false,cancel,null)); }
+                    finally { clip.Gain=gain; }
+                } else {
+                    string name="TR"+(i+1).ToString("00")+"TAKE";
+                    string path=Path.Combine(destination,"AUDIO",name+".WAV"); int suffix=0;
+                    while(File.Exists(path)) path=Path.Combine(destination,"AUDIO",name.Substring(0,6)+(++suffix).ToString("00")+".WAV");
+                    using(var reader=new WaveFileReader(clip.Cache)) using(var writer=new PcmWriter(path,session.Bits,clip.Channels)) {
+                        int channels=clip.Channels; float[] block=new float[8192*channels]; long silence=(long)(session.Tracks[i].Offset*Audio.Rate);
+                        while(silence>0) { cancel.ThrowIfCancellationRequested(); int frames=(int)Math.Min(8192,silence); writer.Write(block,frames*channels,1); silence-=frames; }
+                        var samples=reader.ToSampleProvider(); int read;
+                        while((read=samples.Read(block,0,block.Length))>0) { cancel.ThrowIfCancellationRequested(); writer.Write(block,read,1); }
+                    }
+                    names[i]=Path.GetFileName(path);
+                }
+            }
+            byte[] updated=Build(session,names);
+            string temp=Path.Combine(destination,"PRJDATA.DBUDDY-TEMP"); File.WriteAllBytes(temp,updated);
+            File.Replace(temp,Path.Combine(destination,"PRJDATA.ZDT"),null);
+            return destination;
+        }
+    }
+}

package/source/PanelFeedback.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Media;
+
+namespace DrumBuddy
+{
+    public enum LampState { Off,Green,Red,Amber }
+    public static class PanelFeedback
+    {
+        public static LampState TrackLamp(TrackState track) { return track.Arm?LampState.Red:track.Solo?LampState.Amber:track.Mute?LampState.Off:LampState.Green; }
+        public static bool RecordLamp(bool recording,bool armed,bool pulse) { return recording || (armed && pulse); }
+    }
+    public sealed class MeterBallistics
+    {
+        public double Db=-90,HoldDb=-90,ClipSeconds;
+        private double holdSeconds;
+        public void Update(float peak,double seconds)
+        {
+            seconds=Math.Max(0,Math.Min(1,seconds));
+            double input=peak>0 && !float.IsNaN(peak)?20*Math.Log10(peak):-90;
+            Db=Math.Max(input,Db-28*seconds);
+            if(input>=HoldDb) { HoldDb=input;holdSeconds=.65; }
+            else { holdSeconds-=seconds;if(holdSeconds<=0)HoldDb=Math.Max(Db,HoldDb-22*seconds); }
+            if(peak>=.99f)ClipSeconds=1.5;else ClipSeconds=Math.Max(0,ClipSeconds-seconds);
+        }
+    }
+    internal sealed class PanelLamp : FrameworkElement
+    {
+        private LampState state;
+        public LampState State { get { return state; }set { if(state!=value) { state=value;InvalidateVisual(); } } }
+        protected override void OnRender(DrawingContext dc)
+        {
+            double cx=ActualWidth/2,cy=ActualHeight/2,r=Math.Min(cx,cy)*.6;
+            Color color=state==LampState.Red?Color.FromRgb(255,46,37):state==LampState.Green?Color.FromRgb(64,246,127):state==LampState.Amber?Color.FromRgb(255,192,38):Color.FromRgb(48,56,51);
+            if(state!=LampState.Off) {
+                var glow=new RadialGradientBrush(Color.FromArgb(180,color.R,color.G,color.B),Color.FromArgb(0,color.R,color.G,color.B));
+                dc.DrawEllipse(glow,null,new Point(cx,cy),r*2,r*2);
+            }
+            dc.DrawEllipse(new SolidColorBrush(color),new Pen(new SolidColorBrush(Color.FromRgb(40,50,44)),.7),new Point(cx,cy),r,r);
+            if(state!=LampState.Off)dc.DrawEllipse(new SolidColorBrush(Color.FromArgb(210,255,255,235)),null,new Point(cx-r*.25,cy-r*.25),r*.24,r*.24);
+        }
+    }
+    internal sealed class PanelMeter : FrameworkElement
+    {
+        public readonly MeterBallistics Level=new MeterBallistics();
+        public string Caption="";
+        public bool Compact;
+        private static readonly Brush BackgroundBrush=new SolidColorBrush(Color.FromRgb(5,9,8));
+        private static readonly Brush Inactive=new SolidColorBrush(Color.FromRgb(29,47,37));
+        private static readonly Brush Green=new SolidColorBrush(Color.FromRgb(79,239,115));
+        private static readonly Brush Amber=new SolidColorBrush(Color.FromRgb(255,190,42));
+        private static readonly Brush Red=new SolidColorBrush(Color.FromRgb(255,59,40));
+        public void Update(float peak,double seconds,string caption) { Level.Update(peak,seconds);Caption=caption;InvalidateVisual(); }
+        private void Text(DrawingContext dc,string text,double x,double y,double size,Brush color)
+        {
+            dc.DrawText(new FormattedText(text,CultureInfo.InvariantCulture,FlowDirection.LeftToRight,new Typeface("Consolas"),size,color,VisualTreeHelper.GetDpi(this).PixelsPerDip),new Point(x,y));
+        }
+        protected override void OnRender(DrawingContext dc)
+        {
+            dc.DrawRectangle(BackgroundBrush,null,new Rect(0,0,ActualWidth,ActualHeight));
+            double x=Compact?5:33,w=Compact?10:12;
+            Text(dc,Caption,Compact?1:4,0,9,Brushes.LightGray);
+            for(int i=0;i<18;i++) {
+                double db=-60+i*(60.0/17),y=18+(17-i)*3.8;
+                Brush color=Level.Db>=db-.2?(db>=-3?Red:db>=-12?Amber:Green):Inactive;
+                dc.DrawRectangle(color,null,new Rect(x,y,w,2.8));
+            }
+            double holdY=18+(17-Math.Max(0,Math.Min(17,(Level.HoldDb+60)*17/60)))*3.8;
+            if(Level.HoldDb>-60)dc.DrawRectangle(Brushes.Ivory,null,new Rect(x,holdY,w,1));
+            if(Level.ClipSeconds>0)dc.DrawRectangle(Red,null,new Rect(x,14,w,3));
+            if(!Compact) { Text(dc," 0",4,14,9,Brushes.Gray);Text(dc,"-12",4,28,9,Brushes.Gray);Text(dc,"-24",4,42,9,Brushes.Gray);Text(dc,"-48",4,68,9,Brushes.Gray); }
+        }
+    }
+}

package/source/PlaybackTests.cs

@@ -0,0 +1,134 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public static class PlaybackTests
+    {
+        private sealed class Samples : ISampleProvider
+        {
+            private readonly float[] values;
+            private int position;
+            public WaveFormat WaveFormat { get; private set; }
+            public Samples(float[] values, int rate, int channels)
+            { this.values = values; WaveFormat = WaveFormat.CreateIeeeFloatWaveFormat(rate, channels); }
+            public int Read(float[] buffer, int offset, int count)
+            { int read = Math.Min(count, values.Length - position); Array.Copy(values, position, buffer, offset, read); position += read; return read; }
+        }
+        private static float[] ReadAll(ISampleProvider source)
+        {
+            var result = new List<float>(); var block = new float[258 * source.WaveFormat.Channels]; int read;
+            while ((read = source.Read(block, 0, block.Length)) > 0) result.AddRange(block.Take(read));
+            return result.ToArray();
+        }
+        internal static void Offline(Action<bool, string> check)
+        {
+            foreach (int bits in new[] { 16, 24, 32 }) {
+                var input = new Samples(new[] { -2f, -.5f, 0f, .5f, 2f, float.NaN }, 48000, 1);
+                var format = new WaveFormat(48000, bits, 1); var pcm = new EndpointWaveProvider(input, format);
+                var data = Enumerable.Repeat((byte)0xCC, 6 * bits / 8 + 8).ToArray(); int length = pcm.Read(data, 4, data.Length - 8);
+                var values = new List<long>();
+                for (int i = 4; i < 4 + length; i += bits / 8) {
+                    long value = 0; for (int b = 0; b < bits / 8; b++) value |= (long)data[i + b] << (8 * b);
+                    if ((value & (1L << (bits - 1))) != 0) value -= 1L << bits; values.Add(value);
+                }
+                long scale = 1L << (bits - 1);
+                check(values.SequenceEqual(new[] { -scale, -scale / 2, 0L, scale / 2, scale - 1, 0L }) && data.Take(4).All(b => b == 0xCC) && data.Skip(4 + length).All(b => b == 0xCC),
+                    "Encode bounded " + bits + "-bit PCM for a Windows endpoint without corrupting buffer offsets");
+            }
+            var nativeFormat = new WaveFormatExtensible(48000, 32, 6);
+            var exact = new EndpointWaveProvider(new Samples(new float[6], 48000, 6), nativeFormat);
+            check(object.ReferenceEquals(exact.WaveFormat, nativeFormat), "Keep the exact native endpoint descriptor, including its speaker mask");
+            check(new OutputChoice { Compatibility = true }.Key == "compat:default" && new OutputChoice { Compatibility = true, EndpointId = "endpoint" }.Key == "compat:endpoint",
+                "Persist compatibility outputs separately from shared Windows and ASIO selections");
+            var mono = ReadAll(AudioOutputs.Adapt(new Samples(new[] { .25f, -.75f, 1.5f }, 44100, 1), 44100, 2));
+            check(mono.SequenceEqual(new[] { .25f, .25f, -.75f, -.75f, 1f, 1f }), "Duplicate mono into both headphones and bound playback headroom");
+            var stereo = ReadAll(AudioOutputs.Adapt(new Samples(new[] { .5f, -.25f, -1f, .5f }, 44100, 2), 44100, 2));
+            check(stereo.SequenceEqual(new[] { .5f, -.25f, -1f, .5f }), "Preserve stereo separation at the Windows output boundary");
+            var downmix = ReadAll(AudioOutputs.Adapt(new Samples(new[] { .5f, -.25f, -1f, .5f }, 44100, 2), 44100, 1));
+            check(downmix.SequenceEqual(new[] { .125f, -.25f }), "Downmix stereo for mono Windows endpoints");
+            var surround = AudioOutputs.Adapt(new Samples(new[] { .5f, -.25f, float.NaN, float.PositiveInfinity }, 48000, 2), 48000, 6);
+            var wire = new EndpointWaveProvider(surround); var bytes = new byte[64]; int count = wire.Read(bytes, 4, 48);
+            check(wire.WaveFormat.Encoding == WaveFormatEncoding.Extensible && wire.WaveFormat.BitsPerSample == 32 && count == 48 &&
+                BitConverter.ToSingle(bytes, 4) == .5f && BitConverter.ToSingle(bytes, 8) == -.25f && bytes.Skip(12).Take(40).All(b => b == 0),
+                "Supply extensible float audio to multichannel endpoints with silent unused speakers and finite samples");
+            foreach (int rate in new[] { 48000, 96000 }) {
+                float[] tone = Enumerable.Range(0, 4410).Select(i => (float)(.5 * Math.Sin(2 * Math.PI * 440 * i / 44100))).ToArray();
+                var adapted = AudioOutputs.Adapt(new Samples(tone, 44100, 1), rate, 2); var converted = ReadAll(adapted);
+                check(Math.Abs(converted.Length / 2.0 / rate - .1) < .001 && converted.All(v => !float.IsNaN(v) && Math.Abs(v) <= 1) && converted.Max() > .4,
+                    "Resample 44.1 kHz audio to " + rate + " Hz without changing playback duration or losing audio");
+                check(converted.Where((v, i) => i % 2 == 0).SequenceEqual(converted.Where((v, i) => i % 2 != 0)), "Keep resampled mono centered at " + rate + " Hz");
+            }
+            var gesture = new TimelineGesture();
+            gesture.Begin(TimelineDrag.Playhead, 200, 100, 20, 80); gesture.Move(400); gesture.End(450);
+            check(gesture.Playhead == 450 && gesture.From == 20 && gesture.To == 80 && gesture.Mode == TimelineDrag.None,
+                "Drag the playhead continuously and use the final release position without changing the selection");
+            check(TimelineGesture.FrameAt(9, 40, new long[0], false) == 0 && TimelineGesture.FrameAt(-10, 40, new long[0], false) == 0,
+                "Snap a generous left-edge target and drags past the start to exact zero");
+            check(TimelineGesture.FrameAt(9, 40, new long[0], true) > 0, "Alt permits precise placement inside the zero-snap area");
+            check(TimelineGesture.FrameAt(77, 40, new[] { Audio.Rate * 2L }, false) == Audio.Rate * 2L &&
+                TimelineGesture.FrameAt(77, 40, new[] { Audio.Rate * 2L }, true) != Audio.Rate * 2L,
+                "Snap to clip boundaries while allowing Alt to bypass snapping");
+            gesture.Begin(TimelineDrag.Selection, 900, 150, 20, 80); gesture.Move(500); gesture.End(300);
+            check(gesture.From == 300 && gesture.To == 900 && gesture.Playhead == 150, "Select in either drag direction while retaining the separate playhead");
+            gesture.Begin(TimelineDrag.SelectionStart, 300, 150, 300, 900); gesture.Move(500); gesture.End(600);
+            check(gesture.From == 600 && gesture.To == 900, "Drag the thin selection-start handle without moving the end");
+            gesture.Begin(TimelineDrag.SelectionEnd, 900, 150, 600, 900); gesture.End(1200);
+            check(gesture.From == 600 && gesture.To == 1200, "Drag the thin selection-end handle without moving the start");
+            gesture.Begin(TimelineDrag.SelectionStart, 600, 150, 600, 1200); gesture.End(1400);
+            check(gesture.From == 1200 && gesture.To == 1200, "Prevent a selection-start handle from crossing its end");
+            gesture.Begin(TimelineDrag.SelectionEnd, 1200, 150, 600, 1200); gesture.End(400);
+            check(gesture.From == 600 && gesture.To == 600, "Prevent a selection-end handle from crossing its start");
+            gesture.Begin(TimelineDrag.Playhead, 300, 150, 20, 80); gesture.Move(600); gesture.Cancel();
+            check(gesture.Playhead == 150 && gesture.From == 20 && gesture.To == 80 && gesture.Mode == TimelineDrag.None, "Escape restores the values before dragging");
+            gesture.Begin(TimelineDrag.Selection, 200, 150, 20, 80); gesture.Move(400); gesture.Finish();
+            check(gesture.From == 200 && gesture.To == 400 && gesture.Mode == TimelineDrag.None, "Keep the current selection when mouse capture is lost");
+            check(TimelineGesture.RulerHit(105, 20, 100, 200, true) == TimelineDrag.SelectionStart &&
+                TimelineGesture.RulerHit(195, 20, 100, 200, true) == TimelineDrag.SelectionEnd &&
+                TimelineGesture.RulerHit(105, 5, 100, 200, true) == TimelineDrag.Playhead,
+                "Give blue boundary handles broad hit areas while retaining upper-ruler playhead dragging");
+        }
+        public static int Run(string[] args)
+        {
+            string root = Path.GetFullPath(args.Length > 0 ? args[0] : Path.Combine(Path.GetTempPath(), "DrumBuddyOutput_" + Guid.NewGuid().ToString("N")));
+            Directory.CreateDirectory(root); var log = new List<string>();
+            try {
+                var choices = new List<OutputChoice> { new OutputChoice { Name = "Windows default" }, new OutputChoice { Name = "Windows default compatibility", Compatibility = true } };
+                var named = AudioOutputs.Choices().FirstOrDefault(c => c.Compatibility && c.EndpointId != null);
+                if (named != null) choices.Add(named);
+                foreach (var choice in choices) foreach (int channels in new[] { 1, 2 }) {
+                    using (var completed = new ManualResetEvent(false))
+                    using (var route = AudioOutputs.Open(new Samples(new float[4410 * channels], 44100, channels), choice)) {
+                        Exception error = null;
+                        route.Player.PlaybackStopped += delegate(object sender, StoppedEventArgs e) { error = e.Exception; completed.Set(); };
+                        if (choice.Compatibility && !(route.Player is WaveOutEvent)) throw new Exception("Expected PCM compatibility playback.");
+                        log.Add("Output: " + route.Description + ", " + route.Counter.WaveFormat.Channels + " channels");
+                        route.Player.Play();
+                        if (!completed.WaitOne(5000)) throw new Exception("Timed out while playing silent samples.");
+                        if (error != null) throw error;
+                        if (route.Counter.Frames <= 0 || Math.Abs(route.Seconds - .1) > .01) throw new Exception("The output did not consume the expected audio duration.");
+                        log.Add("PASS  Open, play and drain " + channels + "-channel silent source through " + route.Description);
+                    }
+                }
+                bool unavailable = false;
+                try { using (AudioOutputs.OpenCompatibility(new Samples(new float[4410], 44100, 1), new OutputChoice { Compatibility = true, EndpointId = "missing-endpoint-for-test" })) { } }
+                catch (IOException) { unavailable = true; }
+                if (!unavailable) throw new Exception("A missing selected endpoint was replaced by another output.");
+                log.Add("PASS  Refuse to route a missing explicitly selected endpoint to a different device");
+                foreach (var input in AudioInputs.Choices().Where(c => c.Driver == null)) {
+                    int channels = AudioInputs.Channels(input); var rates = AudioInputs.Rates(input, channels).ToArray();
+                    if (channels < 1 || rates.Length == 0) throw new Exception("Windows microphone capabilities could not be queried: " + input.Name);
+                    log.Add("PASS  Query microphone mapping, " + channels + " channels and rates " + string.Join(", ", rates) + " without recording: " + input.Name);
+                }
+                log.Add("Silent output probe only: no tone, microphone recording or system-volume change. This does not verify audible sound on another PC.");
+                File.WriteAllLines(Path.Combine(root, "output-test-results.txt"), log, Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { log.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root, "output-test-results.txt"), log, Encoding.UTF8); return 1; }
+        }
+    }
+}

package/source/Quick Start.txt

@@ -0,0 +1,77 @@
+FLUX 1.5.0
+
+INSTALL / UPDATE
+Close the app. Run npm.cmd install -g @pro-gram/flux@latest
+Launch flux.cmd, or the Flux Desktop shortcut.
+Migrating: npm.cmd uninstall -g @pro-gram/drumbuddy before installing Flux.
+Windows 10/11 x64 only in this release.
+Macintosh support is planned.
+
+EDITOR + RECORD
+The Editor opens by default. Home contains the separate mini-app sections.
+File contains New, Open session, Save, Save as and Add audio.
+Resize recording options by dragging the divider. Collapse hides its content;
+Show restores it. Its Side/Bottom selector changes the panel position.
+Add/drop audio, select time by dragging, then cut/copy/paste or split.
+Drag the ruler to place the playhead. The left edge snaps to exact zero.
+The thinner blue sticks mark selection start/end. Alt bypasses snapping.
+Range / zoom opens numeric selection and zoom controls.
+Record options opens the sidebar. Select input, channels, rate and format.
+The take is saved at the playhead on the selected track; separate inputs use
+consecutive tracks. Stop saves and inserts it. Source files are preserved.
+Use direct headphone monitoring. Software overdub synchronization is not included.
+
+AUDIO DEVICES
+Audio devices at the top right opens Settings > Audio. Save device changes.
+For Realtek/shared-audio errors, select the same device's Compatibility
+(16-bit PCM) output. Test speakers plays a short quiet tone.
+Save diagnostics exports device information and recent playback errors.
+Playback buffer: 40-250 ms; increase it if audio breaks up.
+Windows microphones/Realtek/USB headsets receive 16-bit PCM. Saving that
+as 24-bit PCM or float does not create extra input precision/headroom.
+Use H5studio ASIO for native 32-bit float, with Zoom's official driver.
+USB > Audio Interface > Connect. Use Audio I/F Only for supported rates.
+R16 ASIO capture remains supported. Vendor drivers are linked, not bundled.
+
+CONVERTER
+Open View > Converter, or its Home card. Drop audio/video and choose a type.
+General formats: PCM WAV, float WAV, AIFF, FLAC, MP3 and AAC/M4A.
+MP3 -> AIFF and AIFF -> WAV are supported. Gain tools are in Media Player.
+Choose source/44.1/48/96 kHz; MP3 uses at most 48 kHz.
+Conversion options resize, collapse and dock on the side or bottom.
+The Zoom R16 preset writes classic 44.1 kHz PCM with compatible filenames.
+Existing sources and exports are never overwritten.
+
+THEMES / SETTINGS
+Top right switches Dark/Light immediately. Settings categories are on the left.
+Keybinds: click Edit; the field automatically highlights and waits for keys.
+Save commits changes. Closing with unsaved changes asks Yes/No to save.
+No discards changes. Duplicate bindings prevent saving until corrected.
+
+DEFAULT KEYS
+Space: play/pause or stop active recording. R: start/stop recording.
+Shift+Space: stop. S: split at playhead. K: click-to-split scissors tool.
+Ctrl+X/C/V: cut/copy/paste. Backspace/Delete: remove selection. Ctrl+Z/Y: undo/redo.
+Ctrl+S: save session. Ctrl+Shift+S: save as. Ctrl+O/N: open/new.
+Ctrl+I/E: import/export. Home/End: timeline beginning/end.
+Ctrl+1/2/3/4: Home/Editor/Converter/Player. Ctrl+comma: Settings.
+
+MEDIA PLAYER / R16
+Media Player supports PCM/float WAV and other decoded formats.
+Gain / Save amplifies or reduces playback and writes adjusted WAV copies.
+Reset, Set safe level and Prevent clipping are available. Playback volume
+only changes listening level. The gain pane resizes, collapses and docks
+on the side or bottom. Save copy is a compact button; originals are kept.
+R16 Control retains the mixer, MIDI, front panel and project-copy tools.
+Use CARD READER mode for R16 SD-card access; verify project copies on hardware.
+Save .dbedit sessions and keep source files in place. WAV exports: 4 GB limit.
+The original black-haired Drum Buddy logo is preserved in the source archive.
+Basic tools work locally without an account. Premium/billing is not implemented.
+
+TEMPO GRID
+Editor BPM/division controls or Settings > Timeline / grid.
+20-400 quarter-note BPM; time signatures; straight/triplet 1/1 to 1/256.
+Grid and clip-edge snapping are independent. Alt bypasses both.
+Tempo changes grid spacing without stretching audio. Save .dbedit to keep it.
+Ctrl+C, Backspace, position playhead, Ctrl+V. Copies survive deletion.
+Zoom to 2560 px/s for fine subdivisions; disable snap for free chops.

package/source/SelfTest.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections.Generic;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public static class SelfTest
+    {
+        private static readonly List<string> results = new List<string>();
+        private static void Check(bool condition, string message) { if (!condition) throw new Exception(message); results.Add("PASS  " + message); }
+        public static int Run(string[] args)
+        {
+            string root = args.Length > 0 ? Path.GetFullPath(args[0]) : Path.Combine(Path.GetTempPath(),"DrumBuddyTest_" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(root);
+            try {
+                string input = Path.Combine(root,"Practice & Unicode é sample.wav");
+                float[] source = new float[44100 * 2 * 2];
+                for (int i = 0; i < source.Length / 2; i++) { source[2*i] = (float)(.25 * Math.Sin(2 * Math.PI * 440 * i / 44100)); source[2*i+1] = (float)(.125 * Math.Sin(2 * Math.PI * 880 * i / 44100)); }
+                using (var writer = new PcmWriter(input,24,2)) writer.Write(source,source.Length,1);
+                Clip original = Audio.Load(input,Path.Combine(root,"cache"),CancellationToken.None,null);
+                Check(Math.Abs(original.Duration - 2) < .0001 && original.Channels == 2,"Read stereo WAV with spaces, ampersand and Unicode in path");
+                Check(Math.Abs(original.PeakDb - 20 * Math.Log10(.25)) < .002,"Measure full-file sample peak accurately");
+                foreach (int bits in new[] { 16,24 }) {
+                    original.Gain = 6;
+                    string output = Audio.Export(original,Path.Combine(root,"gain" + bits),bits,false,CancellationToken.None,null);
+                    using (var reader = new WaveFileReader(output)) {
+                        Check(reader.WaveFormat.SampleRate == 44100 && reader.WaveFormat.BitsPerSample == bits && reader.WaveFormat.Channels == 2,"Export " + bits + "-bit / 44.1 kHz stereo WAV");
+                    }
+                    byte[] header = File.ReadAllBytes(output).Take(44).ToArray();
+                    Check(BitConverter.ToUInt16(header,20) == 1 && BitConverter.ToInt32(header,16) == 16,"Use classic PCM header for " + bits + "-bit R16 compatibility");
+                    Clip converted = Audio.Load(output,Path.Combine(root,"cache"),CancellationToken.None,null);
+                    Check(Math.Abs(converted.PeakDb - original.PeakDb - 6) < .012,"Apply +6 dB gain correctly in " + bits + "-bit export");
+                }
+                original.Gain = 36;
+                string safe = Audio.Export(original,Path.Combine(root,"safe"),24,true,CancellationToken.None,null);
+                Clip protectedClip = Audio.Load(safe,Path.Combine(root,"cache"),CancellationToken.None,null);
+                Check(Math.Abs(protectedClip.PeakDb + 1) < .002,"Prevent clipping by holding the saved peak at −1 dBFS");
+                original.Gain = -6;
+                string quieter = Audio.Export(original,Path.Combine(root,"quieter"),24,true,CancellationToken.None,null);
+                Clip quietClip = Audio.Load(quieter,Path.Combine(root,"cache"),CancellationToken.None,null);
+                Check(Math.Abs(quietClip.PeakDb - original.PeakDb + 6) < .002,"Apply negative gain without normalizing it back up");
+                string second = Audio.Export(original,Path.Combine(root,"quieter"),24,true,CancellationToken.None,null);
+                Check(second != quieter && File.Exists(quieter),"Keep existing output files and generate a new short name");
+                Check(System.Text.RegularExpressions.Regex.IsMatch(Path.GetFileName(second),"^[A-Z0-9_]{1,8}\\.WAV$"),"Generate R16-compatible uppercase 8-character file names");
+                Check(Audio.SafeName("AUX!.wav") == "_AUX","Avoid reserved Windows device names");
+                foreach (string extension in new[] { "mp3","mp4" }) {
+                    string media = Path.Combine(root,"actual sample." + extension);
+                    string argsMedia = extension == "mp3" ? "-i " + Audio.Q(input) + " -c:a libmp3lame -b:a 192k " : "-f lavfi -i color=c=black:s=160x90:r=10 -i " + Audio.Q(input) + " -c:v mpeg4 -c:a aac -shortest ";
+                    Audio.Run("-hide_banner -v error -nostdin -y " + argsMedia + Audio.Q(media),CancellationToken.None,null,true);
+                    Clip clip = Audio.Load(media,Path.Combine(root,"cache"),CancellationToken.None,null);
+                    Check(clip.Ready && Math.Abs(clip.Duration - 2) < .1,"Decode real " + extension.ToUpperInvariant() + (extension == "mp4" ? " video and extract its audio" : " audio"));
+                    string output = Audio.Export(clip,Path.Combine(root,extension),16,true,CancellationToken.None,null);
+                    Check(File.Exists(output),"Convert " + extension.ToUpperInvariant() + " to R16 WAV");
+                }
+                string odd = Path.Combine(root,"odd-mono.wav");
+                using (var writer = new PcmWriter(odd,24,1)) writer.Write(new float[] { .25f },1,1);
+                byte[] oddBytes = File.ReadAllBytes(odd);
+                Check(oddBytes.Length == 48 && BitConverter.ToUInt32(oddBytes,40) == 3 && BitConverter.ToUInt32(oddBytes,4) == 40,"Pad odd-sized 24-bit mono data while keeping correct RIFF lengths");
+                Clip mono = Audio.Load(odd,Path.Combine(root,"cache"),CancellationToken.None,null);
+                Check(mono.Channels == 1,"Preserve a mono source as mono");
+                string invalid = Path.Combine(root,"no audio.mp4"); File.WriteAllText(invalid,"This is not audio");
+                bool rejected = false; try { Audio.Load(invalid,Path.Combine(root,"cache"),CancellationToken.None,null); } catch (IOException) { rejected = true; }
+                Check(rejected,"Reject corrupt or audio-free inputs cleanly");
+                var cancelled = new CancellationTokenSource(); cancelled.Cancel();
+                bool stopped = false; try { Audio.Export(original,Path.Combine(root,"cancel"),24,true,cancelled.Token,null); } catch (OperationCanceledException) { stopped = true; }
+                Check(stopped && Directory.GetFiles(Path.Combine(root,"cancel")).Length == 0,"Cancel an export and remove incomplete output");
+                Check(File.Exists(input) && new FileInfo(input).Length == 44 + source.Length * 3,"Leave original source audio unchanged");
+                results.Add("\nAudio checks complete. Hardware-dependent ASIO capture requires a connected R16 and remains a manual acceptance test.");
+                File.WriteAllLines(Path.Combine(root,"test-results.txt"),results,Encoding.UTF8); return 0;
+            }
+            catch (Exception ex) { results.Add("FAIL  " + ex); File.WriteAllLines(Path.Combine(root,"test-results.txt"),results,Encoding.UTF8); return 1; }
+        }
+    }
+}