@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/MidiControl.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Linq;
+using System.IO;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace DrumBuddy
+{
+    public sealed class MidiPort
+    {
+        public int Id;
+        public string Name;
+        public override string ToString() { return Name; }
+    }
+    public sealed class McuAction
+    {
+        public string Kind;
+        public int Channel,Value;
+    }
+    public static class McuProtocol
+    {
+        public static McuAction Decode(int message)
+        {
+            int status=message&255,data1=(message>>8)&127,data2=(message>>16)&127;
+            if((status&240)==224 && (status&15)<=8) return new McuAction { Kind="fader",Channel=status&15,Value=(data1|(data2<<7))*127/16383 };
+            if((status&240)==176 && data1==60) return new McuAction { Kind="jog",Value=data2>=65?64-data2:data2<64?data2:0 };
+            if((status&240)==176 && data1>=16 && data1<=23) return new McuAction { Kind="pan",Channel=data1-16,Value=data2>=65?64-data2:data2<64?data2:0 };
+            if((status&240)!=144 || data2==0) return null;
+            if(data1<8) return new McuAction { Kind="arm",Channel=data1 };
+            if(data1<16) return new McuAction { Kind="solo",Channel=data1-8 };
+            if(data1<24) return new McuAction { Kind="mute",Channel=data1-16 };
+            if(data1<32) return new McuAction { Kind="select",Channel=data1-24 };
+            string kind=null; int value=0;
+            switch(data1) {
+                case 46: kind="bank";value=0;break; case 47: kind="bank";value=8;break;
+                case 91:kind="seek";value=-5;break;case 92:kind="seek";value=5;break;
+                case 93:kind="stop";break;case 94:kind="play";break;case 95:kind="record";break;
+                case 86:kind="loop";break;case 80:kind="save";break;case 81:kind="undo";break;
+                case 54:kind="loop";break;case 55:kind="loopend";break;
+                case 56:kind="previous";break;case 57:kind="next";break;case 58:kind="mark";break;
+                case 96:kind="parameter";value=-1;break;case 97:kind="parameter";value=1;break;
+                case 98:kind="track";value=-1;break;case 99:kind="track";value=1;break;
+            }
+            return kind==null?null:new McuAction { Kind=kind,Value=value };
+        }
+    }
+    internal sealed class R16Midi : IDisposable
+    {
+        [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] private struct InCaps { public ushort Mid,Pid;public uint Version;[MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string Name;public uint Support; }
+        [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] private struct OutCaps { public ushort Mid,Pid;public uint Version;[MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string Name;public ushort Technology,Voices,Notes,ChannelMask;public uint Support; }
+        private delegate void Callback(IntPtr handle,uint message,UIntPtr instance,UIntPtr param1,UIntPtr param2);
+        [DllImport("winmm.dll")] private static extern uint midiInGetNumDevs();
+        [DllImport("winmm.dll")] private static extern uint midiOutGetNumDevs();
+        [DllImport("winmm.dll",EntryPoint="midiInGetDevCapsW",CharSet=CharSet.Unicode)] private static extern uint midiInGetDevCaps(UIntPtr id,out InCaps caps,uint size);
+        [DllImport("winmm.dll",EntryPoint="midiOutGetDevCapsW",CharSet=CharSet.Unicode)] private static extern uint midiOutGetDevCaps(UIntPtr id,out OutCaps caps,uint size);
+        [DllImport("winmm.dll")] private static extern uint midiInOpen(out IntPtr handle,uint id,Callback callback,UIntPtr instance,uint flags);
+        [DllImport("winmm.dll")] private static extern uint midiInStart(IntPtr handle);
+        [DllImport("winmm.dll")] private static extern uint midiInStop(IntPtr handle);
+        [DllImport("winmm.dll")] private static extern uint midiInReset(IntPtr handle);
+        [DllImport("winmm.dll")] private static extern uint midiInClose(IntPtr handle);
+        [DllImport("winmm.dll")] private static extern uint midiOutOpen(out IntPtr handle,uint id,UIntPtr callback,UIntPtr instance,uint flags);
+        [DllImport("winmm.dll")] private static extern uint midiOutShortMsg(IntPtr handle,uint message);
+        [DllImport("winmm.dll")] private static extern uint midiOutClose(IntPtr handle);
+        private IntPtr input,output;
+        private readonly Callback callback;
+        public event Action<McuAction> Received;
+        public event Action<int> MessageReceived;
+        public long Messages;
+        public string Status="R16 MIDI not connected";
+        public bool Connected { get { return input!=IntPtr.Zero; } }
+        public bool HasOutput { get { return output!=IntPtr.Zero; } }
+        public static MidiPort[] Inputs() {
+            var ports=new List<MidiPort>();
+            for(uint i=0;i<midiInGetNumDevs();i++) { InCaps caps; if(midiInGetDevCaps((UIntPtr)i,out caps,(uint)Marshal.SizeOf(typeof(InCaps)))==0) ports.Add(new MidiPort { Id=(int)i,Name=caps.Name }); }
+            return ports.ToArray();
+        }
+        public static MidiPort[] Outputs() {
+            var ports=new List<MidiPort>();
+            for(uint i=0;i<midiOutGetNumDevs();i++) { OutCaps caps; if(midiOutGetDevCaps((UIntPtr)i,out caps,(uint)Marshal.SizeOf(typeof(OutCaps)))==0) ports.Add(new MidiPort { Id=(int)i,Name=caps.Name }); }
+            return ports.ToArray();
+        }
+        public R16Midi() { callback=OnMessage; }
+        private static void Check(uint result,string action) { if(result!=0) throw new IOException(action+" failed (MIDI "+result+"). Close other apps using the R16 MIDI port, then reconnect."); }
+        public void Connect(MidiPort inPort,MidiPort outPort)
+        {
+            Dispose(); Messages=0;
+            if(inPort==null && outPort==null) { Status="No MIDI port detected"; return; }
+            try {
+                if(inPort!=null)Check(midiInOpen(out input,(uint)inPort.Id,callback,UIntPtr.Zero,0x30000),"Opening MIDI input");
+                if(outPort!=null) { uint result=midiOutOpen(out output,(uint)outPort.Id,UIntPtr.Zero,UIntPtr.Zero,0); if(result!=0) output=IntPtr.Zero; }
+                if(input!=IntPtr.Zero)Check(midiInStart(input),"Starting MIDI input");
+                Status=input==IntPtr.Zero?"MIDI output connected":"MIDI connected · move a control or play a note to check";
+            } catch { Dispose(); throw; }
+        }
+        private void OnMessage(IntPtr handle,uint message,UIntPtr instance,UIntPtr param1,UIntPtr param2)
+        {
+            if(message!=0x3C3 && message!=0x3CC) return;
+            System.Threading.Interlocked.Increment(ref Messages);
+            var raw=MessageReceived;if(raw!=null) { try { raw(unchecked((int)param1.ToUInt64())); }catch { } }
+            McuAction action=McuProtocol.Decode(unchecked((int)param1.ToUInt64()));
+            var receive=Received;
+            if(action!=null && receive!=null) { try { receive(action); } catch { } }
+        }
+        public void Led(int note,bool on) { if(output!=IntPtr.Zero) midiOutShortMsg(output,(uint)(0x90|(note<<8)|((on?127:0)<<16))); }
+        public void Send(int message) { if(output!=IntPtr.Zero)midiOutShortMsg(output,unchecked((uint)message)); }
+        public void Dispose()
+        {
+            IntPtr old=input; input=IntPtr.Zero;
+            if(old!=IntPtr.Zero) { midiInStop(old);midiInReset(old);midiInClose(old); }
+            if(output!=IntPtr.Zero) { midiOutClose(output);output=IntPtr.Zero; }
+        }
+    }
+}

package/source/MidiPerformance.cs

@@ -0,0 +1,125 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace DrumBuddy
+{
+    public sealed class MidiMessage
+    {
+        public double Seconds;
+        public int Message;
+    }
+    public static class MidiFile
+    {
+        private sealed class RawEvent { public long Tick;public int Message,Tempo;public int Order; }
+        private static int Read16(BinaryReader r) { return (r.ReadByte()<<8)|r.ReadByte(); }
+        private static uint Read32(BinaryReader r) { return ((uint)r.ReadByte()<<24)|((uint)r.ReadByte()<<16)|((uint)r.ReadByte()<<8)|r.ReadByte(); }
+        private static void Write16(BinaryWriter w,int n) { w.Write((byte)(n>>8));w.Write((byte)n); }
+        private static void Write32(BinaryWriter w,long n) { w.Write((byte)(n>>24));w.Write((byte)(n>>16));w.Write((byte)(n>>8));w.Write((byte)n); }
+        private static long Vlq(BinaryReader r) { long value=0;for(int i=0;i<4;i++) { byte b=r.ReadByte();value=(value<<7)|(uint)(b&127);if((b&128)==0)return value; }throw new IOException("Invalid MIDI event time."); }
+        private static void Vlq(BinaryWriter w,long value) { if(value<0 || value>0x0FFFFFFF)throw new IOException("MIDI event time is too long.");var bytes=new byte[4];int i=3;bytes[i]=(byte)(value&127);while((value>>=7)>0)bytes[--i]=(byte)((value&127)|128);w.Write(bytes,i,4-i); }
+        public static void Save(string path,IEnumerable<MidiMessage> messages,double endSeconds)
+        {
+            using(var memory=new MemoryStream()) {
+                var track=new BinaryWriter(memory);Vlq(track,0);track.Write(new byte[]{255,81,3,7,161,32}); // 120 BPM, 480 ticks/quarter.
+                long previous=0;
+                foreach(var e in messages.OrderBy(e=>e.Seconds)) {
+                    int status=e.Message&255;if(status<128 || status>=240)continue;
+                    long tick=(long)Math.Round(Math.Max(0,e.Seconds)*960);Vlq(track,tick-previous);previous=tick;
+                    track.Write((byte)status);track.Write((byte)((e.Message>>8)&127));if((status&240)!=192 && (status&240)!=208)track.Write((byte)((e.Message>>16)&127));
+                }
+                Vlq(track,Math.Max(previous,(long)Math.Round(endSeconds*960))-previous);track.Write(new byte[]{255,47,0});track.Flush();
+                using(var file=new FileStream(path,FileMode.CreateNew,FileAccess.Write))using(var output=new BinaryWriter(file)) { output.Write(Encoding.ASCII.GetBytes("MThd"));Write32(output,6);Write16(output,0);Write16(output,1);Write16(output,480);output.Write(Encoding.ASCII.GetBytes("MTrk"));Write32(output,memory.Length);output.Write(memory.ToArray()); }
+            }
+        }
+        public static MidiMessage[] Load(string path)
+        {
+            if(new FileInfo(path).Length>32*1024*1024)throw new IOException("This MIDI file is too large.");
+            var events=new List<RawEvent>();int division,format,trackCount,order=0;
+            using(var stream=File.OpenRead(path))using(var r=new BinaryReader(stream)) {
+                if(Encoding.ASCII.GetString(r.ReadBytes(4))!="MThd")throw new IOException("This is not a Standard MIDI file.");
+                uint header=Read32(r);if(header<6 || header>1024)throw new IOException("Invalid MIDI header.");format=Read16(r);trackCount=Read16(r);division=Read16(r);stream.Position+=header-6;
+                if(format>1 || trackCount<1 || trackCount>1024 || division==0)throw new IOException("Use a type 0 or type 1 Standard MIDI file.");
+                for(int t=0;t<trackCount;t++) {
+                    if(Encoding.ASCII.GetString(r.ReadBytes(4))!="MTrk")throw new IOException("Missing MIDI track.");uint length=Read32(r);long end=stream.Position+length;if(end>stream.Length)throw new IOException("Truncated MIDI track.");
+                    long tick=0;int running=0;
+                    while(stream.Position<end) {
+                        tick+=Vlq(r);int first=r.ReadByte(),status;
+                        if(first<128) { if(running==0)throw new IOException("Invalid MIDI running status.");status=running;stream.Position--; }else status=first;
+                        if(status==255) { int type=r.ReadByte();long size=Vlq(r);if(size>end-stream.Position)throw new IOException("Truncated MIDI metadata.");if(type==81 && size==3) { int tempo=(r.ReadByte()<<16)|(r.ReadByte()<<8)|r.ReadByte();if(tempo<=0)throw new IOException("Invalid MIDI tempo.");events.Add(new RawEvent { Tick=tick,Tempo=tempo,Order=order++ }); }else stream.Position+=size; }
+                        else if(status==240 || status==247) { long size=Vlq(r);if(size>end-stream.Position)throw new IOException("Truncated MIDI system event.");stream.Position+=size;running=0; }
+                        else if(status>=128 && status<240) { running=status;int d1=r.ReadByte(),d2=(status&240)==192 || (status&240)==208?0:r.ReadByte();if(d1>127 || d2>127)throw new IOException("Invalid MIDI channel data.");events.Add(new RawEvent { Tick=tick,Message=status|(d1<<8)|(d2<<16),Order=order++ }); }
+                        else throw new IOException("Unsupported MIDI event.");
+                        if(stream.Position>end || events.Count>1000000)throw new IOException("Invalid or oversized MIDI track.");
+                    }
+                }
+            }
+            var result=new List<MidiMessage>();double seconds=0;long last=0;int currentTempo=500000;
+            double smpte=0;if((division&0x8000)!=0) { int fps=-(sbyte)(division>>8),sub=division&255;if(sub==0 || (fps!=24 && fps!=25 && fps!=29 && fps!=30))throw new IOException("Invalid SMPTE MIDI timing.");smpte=(fps==29?29.97:fps)*sub; }
+            foreach(var e in events.OrderBy(e=>e.Tick).ThenBy(e=>e.Tempo>0?0:1).ThenBy(e=>e.Order)) {
+                seconds+=(e.Tick-last)*(smpte>0?1/smpte:currentTempo/(1000000.0*division));last=e.Tick;
+                if(e.Tempo>0)currentTempo=e.Tempo;else result.Add(new MidiMessage { Seconds=seconds,Message=e.Message });
+            }
+            return result.ToArray();
+        }
+    }
+    internal sealed class MidiPerformance : IDisposable
+    {
+        private readonly R16Midi port=new R16Midi();
+        private readonly object gate=new object();
+        private readonly Stopwatch recordingClock=new Stopwatch();
+        private readonly List<MidiMessage> captured=new List<MidiMessage>();
+        private readonly HashSet<int> held=new HashSet<int>();
+        private CancellationTokenSource playback;
+        public bool Recording,Playing;
+        public string LastEvent="No MIDI notes received",LoadedPath;
+        public long NoteCount;
+        public Exception Error;
+        private MidiMessage[] song=new MidiMessage[0];
+        public bool Connected { get { return port.Connected; } }
+        public double RecordSeconds { get { return recordingClock.Elapsed.TotalSeconds; } }
+        public MidiPerformance() { port.MessageReceived+=Accept; }
+        public void Connect(MidiPort input,MidiPort output) { StopPlayback();if(Recording)throw new IOException("Stop the MIDI recording before changing ports.");port.Connect(input,output); }
+        internal void Accept(int message)
+        {
+            int status=message&255,type=status&240,d1=(message>>8)&127,d2=(message>>16)&127;
+            if(status<128 || status>=240)return;
+            lock(gate) {
+                if(type==144 && d2>0) { NoteCount++;LastEvent="Ch "+((status&15)+1)+" · note "+d1+" · velocity "+d2; }
+                else LastEvent="Ch "+((status&15)+1)+" · "+(type==128 || (type==144 && d2==0)?"note off "+d1:type==176?"CC "+d1+" = "+d2:"MIDI "+type.ToString("X2"));
+                if(!Recording)return;
+                if(captured.Count>=1000000) { Error=new IOException("The MIDI take reached its event limit. Stop and save it.");return; }
+                captured.Add(new MidiMessage { Seconds=recordingClock.Elapsed.TotalSeconds,Message=message&0xFFFFFF });
+                int key=((status&15)<<8)|d1;if(type==144 && d2>0)held.Add(key);else if(type==128 || (type==144 && d2==0))held.Remove(key);
+            }
+        }
+        public void Begin()
+        {
+            StopPlayback();lock(gate) { captured.Clear();held.Clear();Error=null;recordingClock.Restart();Recording=true; }
+        }
+        public string Finish(string folder)
+        {
+            MidiMessage[] events;double end;
+            lock(gate) { if(!Recording)return null;recordingClock.Stop();end=recordingClock.Elapsed.TotalSeconds;Recording=false;foreach(int key in held)captured.Add(new MidiMessage { Seconds=end,Message=(128|(key>>8))|((key&127)<<8) });held.Clear();events=captured.ToArray(); }
+            Directory.CreateDirectory(folder);string path=Path.Combine(folder,"PERFORM.MID");int i=0;while(File.Exists(path))path=Path.Combine(folder,"PERF"+(++i).ToString("0000")+".MID");MidiFile.Save(path,events,end);LoadedPath=path;song=events;return path;
+        }
+        public void Load(string path) { StopPlayback();var data=MidiFile.Load(path);song=data;LoadedPath=path; }
+        public async Task Play()
+        {
+            if(Recording)throw new IOException("Stop recording before MIDI playback.");if(!port.HasOutput)throw new IOException("Choose a MIDI output and click Connect instrument first.");if(song.Length==0)throw new IOException("Open or record a MIDI file first.");
+            StopPlayback();var cancel=new CancellationTokenSource();playback=cancel;Playing=true;var clock=Stopwatch.StartNew();
+            try {
+                foreach(var e in song) { while(clock.Elapsed.TotalSeconds<e.Seconds) { cancel.Token.ThrowIfCancellationRequested();await Task.Delay(Math.Max(1,Math.Min(10,(int)((e.Seconds-clock.Elapsed.TotalSeconds)*1000))),cancel.Token).ConfigureAwait(false); }lock(gate) { cancel.Token.ThrowIfCancellationRequested();if(playback==cancel)port.Send(e.Message); } }
+            }catch(OperationCanceledException) { }
+            finally { lock(gate) { if(playback==cancel) { AllNotesOff();Playing=false;playback=null; } }cancel.Dispose(); }
+        }
+        private void AllNotesOff() { for(int c=0;c<16;c++)port.Send(176|c|(123<<8)); }
+        public void StopPlayback() { lock(gate) { var cancel=playback;playback=null;if(cancel!=null) { try { cancel.Cancel(); }catch(ObjectDisposedException) { } }Playing=false;AllNotesOff(); } }
+        public void Dispose() { StopPlayback();port.Dispose(); }
+    }
+}

package/source/Mixer.cs

@@ -0,0 +1,280 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml.Serialization;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+using NAudio.Dsp;
+
+namespace DrumBuddy
+{
+    public sealed class TrackState
+    {
+        public string Name = "", File = "";
+        public double Offset;
+        public int Fader = 100, Pan, HighGain, MidGain, LowGain;
+        public int HighFreq = 8000, MidFreq = 1000, LowFreq = 125;
+        public double MidQ = .5;
+        public bool Mute, Solo, Arm, Stereo, Invert;
+        public bool HighOn = true, MidOn = true, LowOn = true, ReverbOn = true, ChorusOn = true;
+        public int Reverb, Chorus;
+        public TrackState Copy() { return (TrackState)MemberwiseClone(); }
+    }
+    public sealed class MixerSession
+    {
+        public int Version = 1, Bits = 24, Master = 100;
+        public string Name = "NEW SONG", NativeProject = "";
+        public TrackState[] Tracks;
+    }
+    internal sealed class MixerVoice : IDisposable
+    {
+        public Clip Clip;
+        public WaveFileReader Reader;
+        public ISampleProvider Samples;
+        public float[] Buffer = new float[0];
+        public BiQuadFilter[] Left, Right;
+        public string EqKey;
+        public MixerVoice(Clip clip) { Clip = clip; Reader = new WaveFileReader(clip.Cache); Samples = Reader.ToSampleProvider(); }
+        public void Filters(TrackState state, bool reset)
+        {
+            string key = string.Join("/",new object[] { state.LowOn,state.LowGain,state.LowFreq,state.MidOn,state.MidGain,state.MidFreq,state.MidQ,state.HighOn,state.HighGain,state.HighFreq });
+            if (!reset && key == EqKey) return;
+            EqKey = key;
+            Left = CreateFilters(state); Right = CreateFilters(state);
+        }
+        private static BiQuadFilter[] CreateFilters(TrackState s)
+        {
+            var filters = new List<BiQuadFilter>();
+            if (s.LowOn && s.LowGain != 0) filters.Add(BiQuadFilter.LowShelf(Audio.Rate,s.LowFreq,1,s.LowGain));
+            if (s.MidOn && s.MidGain != 0) filters.Add(BiQuadFilter.PeakingEQ(Audio.Rate,s.MidFreq,(float)s.MidQ,s.MidGain));
+            if (s.HighOn && s.HighGain != 0) filters.Add(BiQuadFilter.HighShelf(Audio.Rate,s.HighFreq,1,s.HighGain));
+            return filters.ToArray();
+        }
+        public void Dispose() { Reader.Dispose(); }
+    }
+    // All stream operations and state edits share one short lock. Audio stays on the audio callback.
+    public sealed class MixerEngine : ISampleProvider, IDisposable
+    {
+        public readonly object Gate = new object();
+        public readonly TrackState[] Tracks = new TrackState[16];
+        private readonly MixerVoice[] voices = new MixerVoice[16];
+        public readonly float[] Peaks = new float[16];
+        public float MasterPeak,MasterLeftPeak,MasterRightPeak;
+        public bool Playing, Recording, Loop;
+        public double LoopStart, LoopEnd;
+        public int Master = 100;
+        private long frame;
+        public Exception Error;
+        public MixerEngine() { for (int i=0;i<16;i++) Tracks[i] = new TrackState(); }
+        public WaveFormat WaveFormat { get { return WaveFormat.CreateIeeeFloatWaveFormat(Audio.Rate,2); } }
+        public double Position { get { lock(Gate) return frame / (double)Audio.Rate; } }
+        public double Duration { get { lock(Gate) return DurationUnsafe(); } }
+        private double DurationUnsafe() { double end=0; for(int i=0;i<16;i++) if(voices[i]!=null) end=Math.Max(end,Tracks[i].Offset+voices[i].Clip.Duration); return end; }
+        public bool HasAudio(int index) { lock(Gate) return voices[index] != null; }
+        public Clip GetClip(int index) { lock(Gate) return voices[index] == null ? null : voices[index].Clip; }
+        public static double FaderDb(int value)
+        {
+            if(value<=0)return -120;
+            int[] positions={1,7,14,36,60,80,100,114,127};
+            double[] levels={-90,-60,-40,-20,-10,-5,0,6,12};
+            for(int i=1;i<positions.Length;i++)if(value<=positions[i])return levels[i-1]+(levels[i]-levels[i-1])*(value-positions[i-1])/(positions[i]-positions[i-1]);
+            return 12;
+        }
+        public static double FaderGain(int value) { return value <= 0 ? 0 : Math.Pow(10,FaderDb(value)/20); }
+        public void Attach(int index, Clip clip)
+        {
+            var voice = clip == null ? null : new MixerVoice(clip);
+            lock(Gate) {
+                if(voices[index]!=null) voices[index].Dispose();
+                voices[index]=voice;
+                if(clip!=null) { Tracks[index].File=clip.Source; Tracks[index].Name=Path.GetFileNameWithoutExtension(clip.Name); }
+                else { Tracks[index].File=""; Tracks[index].Name=""; Tracks[index].Offset=0; }
+            }
+        }
+        public void Seek(double seconds) { lock(Gate) { frame=(long)(Math.Max(0,seconds)*Audio.Rate); foreach(var voice in voices) if(voice!=null) voice.EqKey=null; } }
+        public MixerSession Snapshot(string name, int bits, string native)
+        {
+            lock(Gate) return new MixerSession { Name=name,Bits=bits,Master=Master,NativeProject=native,Tracks=Tracks.Select(t=>t.Copy()).ToArray() };
+        }
+        public void Apply(MixerSession session)
+        {
+            if(session==null || session.Tracks==null || session.Tracks.Length!=16) throw new IOException("This is not a 16-track Drum Buddy session.");
+            lock(Gate) { for(int i=0;i<16;i++) { Validate(session.Tracks[i]); Tracks[i]=session.Tracks[i].Copy(); } Master=Math.Max(0,Math.Min(127,session.Master)); }
+        }
+        public static void Validate(TrackState t)
+        {
+            if(t==null || t.Fader<0 || t.Fader>127 || t.Pan<-50 || t.Pan>50 || t.Offset<0 || t.Offset>86400 || double.IsNaN(t.Offset) || double.IsInfinity(t.Offset) ||
+                t.HighGain<-12 || t.HighGain>12 || t.MidGain<-12 || t.MidGain>12 || t.LowGain<-12 || t.LowGain>12 ||
+                t.HighFreq<40 || t.HighFreq>18000 || t.MidFreq<40 || t.MidFreq>18000 || t.LowFreq<40 || t.LowFreq>18000 ||
+                t.MidQ<.1 || t.MidQ>16 || double.IsNaN(t.MidQ) || t.Reverb<0 || t.Reverb>100 || t.Chorus<0 || t.Chorus>100)
+                throw new IOException("The project contains unsupported track settings.");
+        }
+        public int Read(float[] buffer,int offset,int count)
+        {
+            Array.Clear(buffer,offset,count);
+            lock(Gate) {
+                if(!Playing) return count;
+                try {
+                    int remaining=count/2, target=offset;
+                    while(remaining>0) {
+                        long end=(long)(DurationUnsafe()*Audio.Rate);
+                        bool looping=Loop && !Recording && LoopEnd>LoopStart+.01;
+                        long loopEnd=(long)(LoopEnd*Audio.Rate);
+                        if(looping && frame>=loopEnd) { frame=(long)(LoopStart*Audio.Rate); foreach(var v in voices) if(v!=null) v.EqKey=null; }
+                        if(!Recording && !looping && frame>=end) { Playing=false; break; }
+                        int frames=remaining;
+                        if(looping) frames=(int)Math.Min(frames,loopEnd-frame);
+                        else if(!Recording) frames=(int)Math.Min(frames,end-frame);
+                        if(frames<=0) break;
+                        MixBlock(buffer,target,frames);
+                        frame+=frames; remaining-=frames; target+=frames*2;
+                    }
+                } catch(Exception ex) { Error=ex; Playing=false; }
+                return count;
+            }
+        }
+        private void MixBlock(float[] output,int target,int frames)
+        {
+            bool solo=Tracks.Any(t=>t.Solo);
+            for(int index=0;index<16;index++) {
+                MixerVoice v=voices[index]; TrackState s=Tracks[index];
+                if(v==null || s.Mute || (solo && !s.Solo)) continue;
+                long clipFrame=frame-(long)(s.Offset*Audio.Rate); int skip=clipFrame<0 ? (int)Math.Min(frames,-clipFrame) : 0;
+                clipFrame=Math.Max(0,clipFrame); if(skip==frames || clipFrame>=v.Reader.SampleCount) continue;
+                int channels=v.Reader.WaveFormat.Channels;
+                long position=clipFrame*v.Reader.WaveFormat.BlockAlign;
+                bool seek=v.Reader.Position!=position;
+                if(seek) v.Reader.Position=Math.Min(v.Reader.Length,position);
+                v.Filters(s,seek || v.EqKey==null);
+                int needed=(frames-skip)*channels;
+                if(v.Buffer.Length<needed) v.Buffer=new float[needed];
+                int read=v.Samples.Read(v.Buffer,0,needed), actual=read/channels;
+                double gain=FaderGain(s.Fader)*(s.Invert?-1:1);
+                double pan=s.Pan/50.0;
+                double leftGain=gain*(pan>0?1-pan:1), rightGain=gain*(pan<0?1+pan:1);
+                float peak=0;
+                for(int f=0;f<actual;f++) {
+                    float l=v.Buffer[f*channels],r=channels==1?l:v.Buffer[f*channels+1];
+                    foreach(var eq in v.Left) l=eq.Transform(l);
+                    foreach(var eq in v.Right) r=eq.Transform(r);
+                    l*=(float)leftGain; r*=(float)rightGain;
+                    peak=Math.Max(peak,Math.Max(Math.Abs(l),Math.Abs(r)));
+                    output[target+(f+skip)*2]+=l; output[target+(f+skip)*2+1]+=r;
+                }
+                Peaks[index]=Math.Max(Peaks[index],peak);
+            }
+            float master=(float)FaderGain(Master);
+            for(int i=target;i<target+frames*2;i++) {
+                float sample=output[i]*master; MasterPeak=Math.Max(MasterPeak,Math.Abs(sample));
+                if((i-target)%2==0)MasterLeftPeak=Math.Max(MasterLeftPeak,Math.Abs(sample));else MasterRightPeak=Math.Max(MasterRightPeak,Math.Abs(sample));
+                // Protect headphones from summing overload; meters retain the pre-ceiling peak.
+                output[i]=Math.Max(-.98855f,Math.Min(.98855f,sample));
+            }
+        }
+        public void Dispose() { lock(Gate) { Playing=false; for(int i=0;i<16;i++) { if(voices[i]!=null) voices[i].Dispose(); voices[i]=null; } } }
+    }
+
+    internal sealed class TakeWriter
+    {
+        private readonly BlockingCollection<float[]> queue=new BlockingCollection<float[]>(128);
+        private readonly ConcurrentQueue<float[]> pool=new ConcurrentQueue<float[]>();
+        private readonly List<PcmWriter> writers=new List<PcmWriter>();
+        private readonly int[] inputs;
+        private readonly Task task;
+        public readonly Dictionary<int,string> Paths=new Dictionary<int,string>();
+        public Exception Error;
+        public long Frames;
+        public TakeWriter(string folder,int bits,int[] selected)
+        {
+            inputs=selected.Distinct().OrderBy(i=>i).ToArray();
+            if(inputs.Length==0 || inputs.Any(i=>i<0 || i>7)) throw new IOException("Arm at least one input track before recording.");
+            Directory.CreateDirectory(folder);
+            try { foreach(int input in inputs) { string path=Path.Combine(folder,"INPUT_"+(input+1)+".WAV"); writers.Add(new PcmWriter(path,bits,1)); Paths.Add(input,path); } }
+            catch { foreach(var writer in writers) writer.Dispose(); queue.Dispose(); throw; }
+            task=Task.Run((Action)WriteLoop);
+        }
+        public void Add(AsioAudioAvailableEventArgs e)
+        {
+            if(Error!=null) return;
+            int count=e.SamplesPerBuffer*8; float[] block;
+            if(!pool.TryDequeue(out block) || block.Length!=count) block=new float[count];
+            try { e.GetAsInterleavedSamples(block); if(!queue.TryAdd(block)) throw new IOException("The disk could not keep up. The captured take has been kept."); Interlocked.Add(ref Frames,e.SamplesPerBuffer); }
+            catch(Exception ex) { Error=ex; }
+        }
+        internal void AddSamples(float[] samples,int frames)
+        {
+            if(Error!=null)return;
+            int count=frames*8;if(frames<1 || samples.Length<count)throw new ArgumentException("Expected eight interleaved input channels.");
+            float[] block;if(!pool.TryDequeue(out block) || block.Length!=count)block=new float[count];Array.Copy(samples,block,count);
+            if(!queue.TryAdd(block))Error=new IOException("The disk could not keep up.");else Interlocked.Add(ref Frames,frames);
+        }
+        private void WriteLoop()
+        {
+            try {
+                float[] mono=new float[0];
+                foreach(float[] block in queue.GetConsumingEnumerable()) {
+                    int frames=block.Length/8; if(mono.Length<frames) mono=new float[frames];
+                    for(int w=0;w<inputs.Length;w++) { for(int f=0;f<frames;f++) mono[f]=block[f*8+inputs[w]]; writers[w].Write(mono,frames,1); }
+                    pool.Enqueue(block);
+                }
+            } catch(Exception ex) { Error=ex; }
+        }
+        public async Task Finish() { queue.CompleteAdding(); await task; foreach(var writer in writers) { try { writer.Dispose(); } catch(Exception ex) { Error=ex; } } queue.Dispose(); }
+    }
+    internal sealed class ControlAudio : IDisposable
+    {
+        private IWavePlayer device;
+        private PlaybackRoute playbackRoute;
+        private AsioOut asio;
+        private readonly object gate=new object();
+        private TakeWriter take;
+        public readonly float[] InputPeaks=new float[8];
+        private float[] inputBuffer=new float[0];
+        public Exception Error;
+        public bool Connected { get { return device!=null; } }
+        public bool CanRecord { get { return asio!=null; } }
+        public float[] DrainInputPeaks() { lock(gate) { var result=(float[])InputPeaks.Clone();Array.Clear(InputPeaks,0,InputPeaks.Length);return result; } }
+        internal void AccumulateInputPeaks(float[] samples,int count) { lock(gate) { for(int c=0;c<8;c++) { float peak=0;for(int f=c;f<count;f+=8)peak=Math.Max(peak,Math.Abs(samples[f]));InputPeaks[c]=Math.Max(InputPeaks[c],peak); } } }
+        public Exception TakeError { get { lock(gate) return take==null?null:take.Error; } }
+        public void Connect(MixerEngine engine,OutputChoice output)
+        {
+            Dispose(); Error=null;
+            try {
+                if(output!=null && output.Driver!=null) {
+                    asio=new AsioOut(output.Driver); device=asio;
+                    if(asio.DriverInputChannelCount<8) throw new IOException("Full Control needs the R16's eight ASIO inputs.");
+                    if(!asio.IsSampleRateSupported(Audio.Rate)) throw new IOException("The device must support 44.1 kHz.");
+                    asio.InitRecordAndPlayback(new SampleToWaveProvider(engine),8,Audio.Rate);
+                    asio.AudioAvailable+=delegate(object sender,AsioAudioAvailableEventArgs e) {
+                        lock(gate) {
+                            try {
+                                int count=e.SamplesPerBuffer*8;
+                                if(inputBuffer.Length<count) inputBuffer=new float[count];
+                                e.GetAsInterleavedSamples(inputBuffer);
+                                AccumulateInputPeaks(inputBuffer,count);
+                                if(take!=null) take.Add(e);
+                            } catch(Exception ex) { Error=ex; }
+                        }
+                    };
+                } else {
+                    playbackRoute=AudioOutputs.Open(engine,output);device=playbackRoute.Player;
+                }
+                var active=device;
+                device.PlaybackStopped+=delegate(object sender,StoppedEventArgs e) { if(device==active)Error=e.Exception??new IOException("The audio interface stopped. Check its USB connection."); };
+                device.Play();
+            } catch { Dispose(); throw; }
+        }
+        public void BeginTake(string folder,int bits,int[] inputs) { if(asio==null) throw new IOException("Select the Zoom ASIO audio device to record."); var writer=new TakeWriter(folder,bits,inputs); lock(gate) take=writer; }
+        public async Task<TakeWriter> EndTake() { TakeWriter writer; lock(gate) { writer=take; take=null; } if(writer!=null) await writer.Finish(); return writer; }
+        public void Dispose()
+        {
+            var old=device; device=null; asio=null;
+            if(playbackRoute!=null) { playbackRoute.Dispose();playbackRoute=null; }
+            else if(old!=null) { try { old.Stop(); } catch { } try { old.Dispose(); } catch { } }
+        }
+    }
+}