@pro-gram/flux 0.0.0-stage → 1.5.0

package/source/Audio.cs

@@ -0,0 +1,453 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Linq;
+using System.Diagnostics;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Text.RegularExpressions;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DrumBuddy
+{
+    public sealed class Clip
+    {
+        public string Source, Cache, Name;
+        public string SourceFormat;
+        public string Status { get; set; }
+        public string DisplayName { get { return Name; } }
+        public string SourceSummary { get { return Ready ? SourceFormat + " | " + (Channels == 1 ? "Mono" : "Stereo") : "Reading source..."; } }
+        public int Channels, SourceRate;
+        public double Duration, Peak, Gain;
+        public float[] Waveform;
+        public bool Ready;
+        public double PeakDb { get { return Peak > 0 ? 20 * Math.Log10(Peak) : -120; } }
+        public double AppliedGain(bool protect) { return protect && Peak > 0 ? Math.Min(Gain, -1 - PeakDb) : Gain; }
+        public override string ToString() { return Name; }
+    }
+
+    public static class Audio
+    {
+        public const int Rate = 44100;
+        public static string Tools { get { return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tools", "ffmpeg.exe"); } }
+
+        // Windows command-line quoting; the process never runs through a shell.
+        public static string Q(string value)
+        {
+            var s = new StringBuilder("\"");
+            int slashes = 0;
+            foreach (char ch in value)
+            {
+                if (ch == '\\') { slashes++; continue; }
+                if (ch == '"') s.Append('\\', slashes * 2 + 1).Append(ch);
+                else s.Append('\\', slashes).Append(ch);
+                slashes = 0;
+            }
+            return s.Append('\\', slashes * 2).Append('"').ToString();
+        }
+
+        public static string Run(string args, CancellationToken cancel, Action<string> progress, bool expectSuccess)
+        {
+            if (!File.Exists(Tools)) throw new IOException("The audio tools are missing. Please reinstall Flux.");
+            var log = new StringBuilder();
+            var gate = new object();
+            using (var p = new Process())
+            {
+                p.StartInfo = new ProcessStartInfo(Tools, args) {
+                    UseShellExecute = false, CreateNoWindow = true,
+                    RedirectStandardError = true, RedirectStandardOutput = true,
+                    StandardErrorEncoding = Encoding.UTF8
+                };
+                p.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs e) {
+                    if (e.Data == null) return;
+                    lock (gate) {
+                        log.AppendLine(e.Data);
+                        if (log.Length > 65536) log.Remove(0, log.Length - 32768);
+                    }
+                };
+                p.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e) {
+                    if (progress != null && e.Data != null) progress(e.Data);
+                };
+                p.Start();
+                p.BeginErrorReadLine();
+                p.BeginOutputReadLine();
+                try {
+                    while (!p.WaitForExit(100)) cancel.ThrowIfCancellationRequested();
+                    p.WaitForExit();
+                    cancel.ThrowIfCancellationRequested();
+                    if (expectSuccess && p.ExitCode != 0)
+                        throw new IOException("This file could not be read. It may be damaged, protected, or have no audio track.");
+                    lock (gate) return log.ToString();
+                }
+                finally {
+                    if (!p.HasExited) { p.Kill(); p.WaitForExit(); }
+                }
+            }
+        }
+
+        public static Clip Load(string path, string cacheFolder, CancellationToken cancel, Action<double> progress)
+        {
+            string info = Run("-hide_banner -nostdin -protocol_whitelist file,pipe -i " + Q(path), cancel, null, false);
+            var firstAudio = Regex.Match(info, @"Stream[^\r\n]*Audio:[^\r\n]*");
+            if (!firstAudio.Success) throw new IOException("This file has no readable audio track.");
+            int channels = Regex.IsMatch(firstAudio.Value, @"\bmono\b") ? 1 : 2;
+            var time = Regex.Match(info, @"Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)");
+            double seconds = time.Success ? int.Parse(time.Groups[1].Value) * 3600 + int.Parse(time.Groups[2].Value) * 60 + double.Parse(time.Groups[3].Value, CultureInfo.InvariantCulture) : 0;
+            Directory.CreateDirectory(cacheFolder);
+            string cache = Path.Combine(cacheFolder, Guid.NewGuid().ToString("N") + ".wav");
+            try {
+                Run("-hide_banner -v error -nostdin -y -protocol_whitelist file,pipe -i " + Q(path) +
+                    " -map 0:a:0 -vn -sn -dn -map_metadata -1 -ar 44100 -ac " + channels +
+                    " -c:a pcm_f32le -rf64 auto -progress pipe:1 " + Q(cache), cancel,
+                    delegate(string line) {
+                        if (progress == null || seconds <= 0 || !line.StartsWith("out_time_us=")) return;
+                        double us;
+                        if (double.TryParse(line.Substring(12), NumberStyles.Float, CultureInfo.InvariantCulture, out us))
+                            progress(Math.Min(.94, us / 1000000 / seconds * .94));
+                    }, true);
+                using (var reader = new WaveFileReader(cache)) {
+                    if (reader.WaveFormat.BitsPerSample != 32 || reader.WaveFormat.Channels != channels)
+                        throw new IOException("The decoded audio format was unexpected.");
+                    long samples = reader.Length / 4;
+                    if (samples == 0) throw new IOException("This file contains no audio samples.");
+                    var waveform = new float[900];
+                    byte[] bytes = new byte[65536];
+                    float[] floats = new float[bytes.Length / 4];
+                    long position = 0;
+                    double peak = 0;
+                    int count;
+                    while ((count = reader.Read(bytes, 0, bytes.Length)) > 0) {
+                        cancel.ThrowIfCancellationRequested();
+                        Buffer.BlockCopy(bytes, 0, floats, 0, count);
+                        for (int i = 0; i < count / 4; i++, position++) {
+                            double value = Math.Abs((double)floats[i]);
+                            if (double.IsNaN(value) || double.IsInfinity(value)) throw new IOException("This file contains invalid audio samples.");
+                            peak = Math.Max(peak, value);
+                            int bin = (int)Math.Min(waveform.Length - 1, (double)position / samples * waveform.Length);
+                            waveform[bin] = Math.Max(waveform[bin], (float)value);
+                        }
+                    }
+                    if (progress != null) progress(1);
+                    var codec = Regex.Match(firstAudio.Value, @"Audio:\s*([^\s,(]+)").Groups[1].Value;
+                    var sourceRate = Regex.Match(firstAudio.Value, @"\b(\d+)\s*Hz").Groups[1].Value;
+                    string format = codec;
+                    if (codec.StartsWith("pcm_f32")) format = "32-bit float WAV/PCM";
+                    else if (codec.StartsWith("pcm_f64")) format = "64-bit float WAV/PCM";
+                    else if (codec.StartsWith("pcm_s24")) format = "24-bit integer PCM";
+                    else if (codec.StartsWith("pcm_s32")) format = "32-bit integer PCM";
+                    else if (codec.StartsWith("pcm_s16")) format = "16-bit integer PCM";
+                    else if (codec.StartsWith("pcm_")) format = codec.Replace("pcm_", "PCM ");
+                    return new Clip { Source = path, Cache = cache, Name = Path.GetFileName(path), Channels = channels, SourceRate = sourceRate.Length > 0 ? int.Parse(sourceRate, CultureInfo.InvariantCulture) : Audio.Rate, SourceFormat = format + (sourceRate.Length > 0 ? " | " + sourceRate + " Hz" : ""),
+                        Duration = samples / (double)(Rate * channels), Peak = peak, Waveform = waveform, Ready = true, Status = "Ready" };
+                }
+            }
+            catch { TryDelete(cache); throw; }
+        }
+
+        public static string SafeName(string source)
+        {
+            string stem = Path.GetFileNameWithoutExtension(source).ToUpperInvariant();
+            stem = Regex.Replace(stem, "[^A-Z0-9_]", "_");
+            stem = Regex.Replace(stem, "_+", "_").Trim('_');
+            if (stem.Length == 0) stem = "TRACK";
+            if (Regex.IsMatch(stem,@"^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$")) stem = "_" + stem;
+            return stem.Substring(0, Math.Min(8, stem.Length));
+        }
+
+        public static string UniquePath(string folder, string stem)
+        {
+            stem = SafeName(stem + ".WAV");
+            for (int i = 0; i < 1000000; i++) {
+                string suffix = i == 0 ? "" : i.ToString(CultureInfo.InvariantCulture);
+                string name = stem.Substring(0, Math.Min(stem.Length, 8 - suffix.Length)) + suffix + ".WAV";
+                string path = Path.Combine(folder, name);
+                if (!File.Exists(path)) return path;
+            }
+            throw new IOException("This folder has too many files with similar names. Please choose another folder.");
+        }
+
+        public static string Export(Clip clip, string folder, int bits, bool protect, CancellationToken cancel, Action<double> progress)
+        {
+            Directory.CreateDirectory(folder);
+            string temporary = Path.Combine(folder, ".drumbuddy-" + Guid.NewGuid().ToString("N") + ".partial");
+            try {
+                using (var input = new WaveFileReader(clip.Cache))
+                using (var output = new PcmWriter(temporary, bits, clip.Channels)) {
+                    if (input.Length / 4 * (bits / 8) > PcmWriter.MaxData) throw new IOException("This recording is too long for an R16 WAV file. Please use a shorter recording.");
+                    byte[] bytes = new byte[65536];
+                    float[] samples = new float[bytes.Length / 4];
+                    double scale = Math.Pow(10, clip.AppliedGain(protect) / 20);
+                    int count;
+                    while ((count = input.Read(bytes, 0, bytes.Length)) > 0) {
+                        cancel.ThrowIfCancellationRequested();
+                        Buffer.BlockCopy(bytes, 0, samples, 0, count);
+                        output.Write(samples, count / 4, scale);
+                        if (progress != null) progress((double)input.Position / input.Length);
+                    }
+                }
+                cancel.ThrowIfCancellationRequested();
+                for (int attempt = 0; attempt < 100; attempt++) {
+                    string final = UniquePath(folder, Path.GetFileNameWithoutExtension(clip.Source));
+                    try { File.Move(temporary, final); return final; }
+                    catch (IOException) { if (!File.Exists(final)) throw; }
+                }
+                throw new IOException("A file with this name is already being saved. Try again.");
+            }
+            finally { TryDelete(temporary); }
+        }
+
+        public static void TryDelete(string path) { try { if (File.Exists(path)) File.Delete(path); } catch { } }
+    }
+
+    // Classic 44-byte PCM headers are intentional: compatible with older recorders.
+    public sealed class PcmWriter : IRecordingWriter
+    {
+        public const long MaxData = 0xFFFFFF00L;
+        private readonly FileStream stream;
+        private readonly BinaryWriter writer;
+        private readonly int bits, channels, rate;
+        private readonly Random random = new Random();
+        private byte[] buffer = new byte[0];
+        private long dataSize;
+        private bool disposed;
+        public PcmWriter(string path, int bits, int channels) : this(path, bits, channels, Audio.Rate) { }
+        public PcmWriter(string path, int bits, int channels, int rate)
+        {
+            if ((bits != 16 && bits != 24) || channels < 1 || channels > 2 || (rate != 44100 && rate != 48000 && rate != 96000)) throw new ArgumentException("Invalid WAV format");
+            this.bits = bits; this.channels = channels; this.rate = rate;
+            stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.Read, 65536);
+            writer = new BinaryWriter(stream);
+            writer.Write(Encoding.ASCII.GetBytes("RIFF")); writer.Write((uint)36);
+            writer.Write(Encoding.ASCII.GetBytes("WAVEfmt ")); writer.Write(16);
+            writer.Write((ushort)1); writer.Write((ushort)channels); writer.Write(rate);
+            writer.Write(rate * channels * bits / 8); writer.Write((ushort)(channels * bits / 8)); writer.Write((ushort)bits);
+            writer.Write(Encoding.ASCII.GetBytes("data")); writer.Write((uint)0);
+        }
+        public void Write(float[] samples, int count, double gain)
+        {
+            if (count % channels != 0) throw new ArgumentException("Incomplete audio frame");
+            int size = count * (bits / 8);
+            if (dataSize + size > MaxData) throw new IOException("The WAV file has reached its size limit. This take has been stopped and saved.");
+            if (buffer.Length < size) buffer = new byte[size];
+            int scale = 1 << (bits - 1), j = 0;
+            for (int i = 0; i < count; i++) {
+                double value = samples[i] * gain;
+                if (double.IsNaN(value) || double.IsInfinity(value)) value = 0;
+                double dither = bits == 16 ? random.NextDouble() - random.NextDouble() : 0;
+                double quantized = Math.Round(value * scale + dither, MidpointRounding.AwayFromZero);
+                int pcm = (int)Math.Max(-scale, Math.Min(scale - 1, quantized));
+                buffer[j++] = (byte)pcm; buffer[j++] = (byte)(pcm >> 8);
+                if (bits == 24) buffer[j++] = (byte)(pcm >> 16);
+            }
+            stream.Write(buffer, 0, size); dataSize += size;
+            // Keep an in-progress take readable if Windows or the app stops unexpectedly.
+            if ((dataSize / (rate * channels * (bits / 8))) != ((dataSize - size) / (rate * channels * (bits / 8)))) UpdateHeader();
+        }
+        private void UpdateHeader()
+        {
+            long position = stream.Position;
+            stream.Position = 4; writer.Write((uint)(36 + dataSize + (dataSize & 1)));
+            stream.Position = 40; writer.Write((uint)dataSize);
+            stream.Position = position; stream.Flush();
+        }
+        public void Dispose() { if (disposed) return; disposed = true; try { if ((dataSize & 1) != 0) stream.WriteByte(0); UpdateHeader(); } finally { writer.Dispose(); } }
+    }
+
+    public sealed class GainProvider : ISampleProvider
+    {
+        private readonly ISampleProvider source;
+        public volatile float Gain = 1;
+        public GainProvider(ISampleProvider source) { this.source = source; }
+        public WaveFormat WaveFormat { get { return source.WaveFormat; } }
+        public int Read(float[] buffer, int offset, int count)
+        {
+            int read = source.Read(buffer, offset, count);
+            float gain = Gain;
+            for (int i = offset; i < offset + read; i++) buffer[i] *= gain;
+            return read;
+        }
+    }
+
+    public sealed class Recorder
+    {
+        private AsioOut device;
+        private WaveInEvent windowsInput;
+        private int windowsChannels;
+        private BlockingCollection<float[]> queue;
+        private readonly ConcurrentQueue<float[]> pool = new ConcurrentQueue<float[]>();
+        private Task writing;
+        private readonly object gate = new object();
+        private bool accepting;
+        private int captureChannels, selectedInput, savedChannels;
+        private bool separate, requireFloatInput;
+        private readonly List<IRecordingWriter> writers = new List<IRecordingWriter>();
+        public readonly List<string> Paths = new List<string>();
+        public readonly float[] Peaks = new float[8];
+        public Exception Error;
+        public long Frames;
+        public int SampleRate { get; private set; }
+        public int Bits { get; private set; }
+        public int ChannelCount { get { return captureChannels; } }
+        public string SourceFormat { get; private set; }
+        public bool SourceIsFloat { get; private set; }
+
+        public void Start(string driver, int mode, int bits, string folder)
+        { Start(driver, mode, bits, folder, Audio.Rate); }
+
+        public void Start(InputChoice input, int mode, int bits, string folder, int rate)
+        {
+            if (input.Driver != null) { Start(input.Driver, mode, bits, folder, rate); return; }
+            try {
+                windowsChannels = AudioInputs.Channels(input);
+                var layout = CaptureLayout.Create(windowsChannels, mode);
+                windowsInput = new WaveInEvent { DeviceNumber = AudioInputs.Device(input), WaveFormat = new WaveFormat(rate, 16, windowsChannels), BufferMilliseconds = 50, NumberOfBuffers = 3 };
+                StartBuffered(layout, bits, folder, rate, false);
+                SourceFormat = "Windows 16-bit PCM"; SourceIsFloat = false;
+                windowsInput.DataAvailable += delegate(object sender, WaveInEventArgs e) { ProcessWindowsPcm(e.Buffer, e.BytesRecorded, windowsChannels); };
+                windowsInput.RecordingStopped += delegate(object sender, StoppedEventArgs e) {
+                    lock (gate) { if (accepting && Error == null) Error = e.Exception ?? new IOException("The microphone stopped. Check its connection and Windows microphone permissions."); }
+                };
+                windowsInput.StartRecording();
+            }
+            catch { Stop(); throw; }
+        }
+
+        internal void ProcessWindowsPcm(byte[] data, int bytes, int sourceChannels)
+        {
+            lock (gate) {
+                if (!accepting || Error != null) return;
+                try {
+                    if (requireFloatInput) throw new IOException("Windows PCM input cannot supply native ASIO float samples.");
+                    if (sourceChannels < 1 || bytes < 0 || bytes > data.Length || bytes % (sourceChannels * 2) != 0 || selectedInput + captureChannels > sourceChannels)
+                        throw new IOException("The Windows microphone sent an incomplete or changed channel layout.");
+                    int frames = bytes / (sourceChannels * 2), count = frames * captureChannels;
+                    float[] samples;
+                    if (!pool.TryDequeue(out samples) || samples.Length != count) samples = new float[count];
+                    for (int f = 0; f < frames; f++) for (int c = 0; c < captureChannels; c++) {
+                        float value = BitConverter.ToInt16(data, (f * sourceChannels + selectedInput + c) * 2) / 32768f;
+                        samples[f * captureChannels + c] = value;
+                        Peaks[selectedInput + c] = Math.Max(Peaks[selectedInput + c], Math.Abs(value));
+                    }
+                    SourceFormat = "Windows 16-bit PCM"; SourceIsFloat = false;
+                    if (!queue.TryAdd(samples)) throw new IOException("The computer could not save microphone audio fast enough. Stop and save the take.");
+                    Interlocked.Add(ref Frames, frames);
+                }
+                catch (Exception ex) { Error = ex; }
+            }
+        }
+
+        public void Start(string driver, int mode, int bits, string folder, int rate)
+        {
+            try {
+                device = new AsioOut(driver);
+                var layout = CaptureLayout.Create(device.DriverInputChannelCount, mode);
+                if (!device.IsSampleRateSupported(rate)) throw new IOException("This device does not support " + rate + " Hz in its current mode. Choose a supported rate, or set the recorder to Audio I/F Only.");
+                device.InputChannelOffset = layout.FirstInput;
+                device.InitRecordAndPlayback(null, layout.Channels, rate);
+                StartBuffered(layout, bits, folder, rate, bits == 32 && CaptureLayout.IsH5studio(driver));
+                device.AudioAvailable += Captured;
+                device.PlaybackStopped += delegate(object sender, StoppedEventArgs e) {
+                    lock (gate) { if (accepting && Error == null) Error = e.Exception ?? new IOException("The recording device stopped sending audio. Check its USB connection."); }
+                };
+                device.Play();
+            }
+            catch { Stop(); throw; }
+        }
+
+        // Shared by real ASIO capture and the offline driver-buffer acceptance checks.
+        internal void StartBuffered(CaptureLayout layout, int bits, string folder, int rate, bool requireNativeFloat)
+        {
+            if (bits != 16 && bits != 24 && bits != 32) throw new ArgumentException("Unsupported recording format.");
+            separate = layout.Separate; selectedInput = layout.FirstInput; captureChannels = layout.Channels;
+            savedChannels = separate ? 1 : captureChannels; SampleRate = rate; Bits = bits; requireFloatInput = requireNativeFloat;
+            Directory.CreateDirectory(folder);
+            for (int i = 0; i < (separate ? captureChannels : 1); i++) {
+                string name = separate ? "INPUT_" + (i + selectedInput + 1) : captureChannels == 2 ? "STEREO" : "INPUT_" + (selectedInput + 1);
+                string path = Path.Combine(folder, name + ".WAV");
+                IRecordingWriter writer = bits == 32 ? (IRecordingWriter)new FloatWaveWriter(path, savedChannels, rate) : new PcmWriter(path, bits, savedChannels, rate);
+                writers.Add(writer); Paths.Add(path);
+            }
+            queue = new BlockingCollection<float[]>(128);
+            writing = Task.Run((Action)WriteLoop); accepting = true;
+        }
+
+        internal void ProcessCapture(AsioAudioAvailableEventArgs e) { Captured(this, e); }
+        private void Captured(object sender, AsioAudioAvailableEventArgs e)
+        {
+            lock (gate) {
+                if (!accepting || Error != null) return;
+                try {
+                    SourceFormat = e.AsioSampleType.ToString();
+                    SourceIsFloat = e.AsioSampleType == NAudio.Wave.Asio.AsioSampleType.Float32LSB;
+                    if (requireFloatInput && !SourceIsFloat)
+                        throw new IOException("The H5studio driver is sending " + SourceFormat + ", not native 32-bit float. Check Zoom's H5studio driver and its audio settings, then reconnect. No integer input has been labelled as a native float recording.");
+                    if (e.InputBuffers.Length != captureChannels || e.SamplesPerBuffer <= 0)
+                        throw new IOException("The ASIO input channel layout changed. Stop, refresh the device, and start a new take.");
+                    int count = e.SamplesPerBuffer * captureChannels;
+                    float[] samples;
+                    if (!pool.TryDequeue(out samples) || samples.Length != count) samples = new float[count];
+                    e.GetAsInterleavedSamples(samples);
+                    for (int i = 0; i < count; i++)
+                        if (float.IsNaN(samples[i]) || float.IsInfinity(samples[i])) throw new IOException("The driver sent invalid audio. The previous audio blocks have been kept.");
+                    for (int channel = 0; channel < captureChannels; channel++) {
+                        float peak = 0;
+                        for (int i = channel; i < count; i += captureChannels) peak = Math.Max(peak, Math.Abs(samples[i]));
+                        int input = channel + selectedInput;
+                        Peaks[input] = Math.Max(Peaks[input], peak);
+                    }
+                    if (!queue.TryAdd(samples)) throw new IOException("The computer could not save audio fast enough. The take has been stopped and saved. Close other apps before trying again.");
+                    Interlocked.Add(ref Frames, e.SamplesPerBuffer);
+                }
+                catch (Exception ex) { Error = ex; }
+            }
+        }
+        private void WriteLoop()
+        {
+            try {
+                float[] mono = new float[0];
+                foreach (float[] block in queue.GetConsumingEnumerable()) {
+                    if (separate) {
+                        int frames = block.Length / captureChannels;
+                        if (mono.Length < frames) mono = new float[frames];
+                        for (int c = 0; c < captureChannels; c++) {
+                            for (int f = 0; f < frames; f++) mono[f] = block[f * captureChannels + c];
+                            writers[c].Write(mono, frames, 1);
+                        }
+                    }
+                    else writers[0].Write(block, block.Length, 1);
+                    pool.Enqueue(block);
+                }
+            }
+            catch (Exception ex) { Error = ex; }
+        }
+        // Call on the UI thread: ASIO COM objects have thread affinity.
+        public void Stop()
+        {
+            lock (gate) accepting = false;
+            if (windowsInput != null) {
+                try { windowsInput.StopRecording(); } catch (Exception ex) { if (Error == null) Error = ex; }
+                try { windowsInput.Dispose(); } catch (Exception ex) { if (Error == null) Error = ex; }
+                windowsInput = null;
+            }
+            if (device != null) {
+                try { device.Stop(); } catch (Exception ex) { if (Error == null) Error = ex; }
+                try { device.Dispose(); } catch (Exception ex) { if (Error == null) Error = ex; }
+                device = null;
+            }
+            if (queue != null && !queue.IsAddingCompleted) queue.CompleteAdding();
+        }
+        public async Task Finish()
+        {
+            if (writing != null) await writing;
+            foreach (var writer in writers) {
+                try { writer.Dispose(); } catch (Exception ex) { if (Error == null) Error = ex; }
+            }
+            writers.Clear();
+            if (queue != null) { queue.Dispose(); queue = null; }
+        }
+    }
+}

package/source/AudioDeviceSettings.cs

@@ -0,0 +1,126 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+using NAudio.CoreAudioApi;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public sealed class AudioDevicesView : StackPanel, IDisposable
+    {
+        private readonly AudioOutputPicker outputs;
+        private readonly ComboBox inputs;
+        private readonly TextBlock result;
+        private readonly Action<InputChoice> inputChanged;
+        private readonly Action stopPlayback;
+        private PlaybackRoute test;
+        private bool refreshing;
+        public AudioDevicesView(InputChoice selectedInput, Action<InputChoice> inputChanged, Action stopPlayback, bool recording)
+        {
+            this.inputChanged = inputChanged; this.stopPlayback = stopPlayback;
+            Margin = new Thickness(24); Background = WorkspaceUi.Color("#F3F5F5");
+            Children.Add(WorkspaceUi.Text("Audio devices", 28));
+            var description = WorkspaceUi.Text("Choose where playback is heard and which input is recorded. These selections are saved for your next session.", 15);
+            description.Margin = new Thickness(0, 10, 0, 20); Children.Add(description);
+            Children.Add(WorkspaceUi.Text("Speakers / headphones", 18));
+            outputs = new AudioOutputPicker(delegate { StopTest(); if (stopPlayback != null) stopPlayback(); }, delegate(string text) { if (result != null) result.Text = text; });
+            outputs.Margin = new Thickness(0, 8, 0, 4); Children.Add(outputs);
+            var help = WorkspaceUi.Text("For a Realtek or Windows audio error, choose that device's Compatibility (16-bit PCM) entry. Automatic Windows output also tries this path if shared audio cannot open.", 14);
+            help.Margin = new Thickness(0, 0, 0, 10); Children.Add(help);
+            Children.Add(WorkspaceUi.Button("Test speakers", Test));
+            Children.Add(WorkspaceUi.Text("Recording input", 18));
+            inputs = new ComboBox { MinHeight = 38, FontSize = 15, Margin = new Thickness(0, 8, 0, 8), IsEnabled = !recording };
+            Children.Add(inputs); RefreshInput(selectedInput == null ? null : selectedInput.Key);
+            inputs.SelectionChanged += delegate { if (!refreshing && inputs.SelectedItem != null && this.inputChanged != null) this.inputChanged((InputChoice)inputs.SelectedItem); };
+            var refresh = WorkspaceUi.Button("Refresh inputs", delegate { var current = inputs.SelectedItem as InputChoice; RefreshInput(current == null ? null : current.Key); }); refresh.IsEnabled = !recording; Children.Add(refresh);
+            var captureHelp = WorkspaceUi.Text(recording ? "Stop and save the current take before changing its recording input." : "Windows microphones use 16-bit PCM input. Choose the H5studio ASIO input for native 32-bit float capture. Channel and WAV settings are in Record drums.", 14);
+            captureHelp.Margin = new Thickness(0, 0, 0, 14); Children.Add(captureHelp);
+            var buttons = new WrapPanel(); Children.Add(buttons);
+            buttons.Children.Add(WorkspaceUi.Button("Save diagnostics...", delegate {
+                var dialog = new Microsoft.Win32.SaveFileDialog { Title = "Save audio device diagnostics", Filter = "Text report|*.txt", FileName = "DrumBuddy-Audio-Diagnostics.txt" };
+                if (dialog.ShowDialog(Window.GetWindow(this)) == true) try {
+                    File.WriteAllText(dialog.FileName, AudioDiagnostics.Report(inputs.SelectedItem as InputChoice), Encoding.UTF8);
+                    result.Text = "Diagnostics saved. The report contains device formats and recent playback errors; it contains no recordings.";
+                } catch (Exception ex) { result.Text = "Could not save diagnostics: " + ex.Message; }
+            }));
+            result = WorkspaceUi.Text("Test speakers plays a short quiet tone through the selected output. No microphone is opened until you press Record.", 14); result.Margin = new Thickness(0, 10, 0, 0); Children.Add(result);
+        }
+        private void RefreshInput(string key)
+        {
+            refreshing = true;
+            var choices = AudioInputs.Choices(); inputs.ItemsSource = choices;
+            inputs.SelectedItem = choices.FirstOrDefault(c => c.Key == key);
+            refreshing = false;
+        }
+        private void Test()
+        {
+            StopTest(); if (stopPlayback != null) stopPlayback();
+            try {
+                test = AudioOutputs.Open(new TestSignal(), outputs.Selected); var current = test;
+                test.Player.PlaybackStopped += delegate(object sender, StoppedEventArgs e) {
+                    Dispatcher.BeginInvoke((Action)delegate {
+                        if (test != current) return;
+                        string description = test.Description; StopTest();
+                        result.Text = e.Exception == null ? "Test tone sent through " + description + "." : "Test stopped: " + e.Exception.Message;
+                    });
+                };
+                result.Text = "Playing test through " + test.Description; test.Player.Play();
+            }
+            catch (Exception ex) { StopTest(); result.Text = ex.Message; }
+        }
+        private void StopTest() { var old = test; test = null; if (old != null) old.Dispose(); }
+        public void Dispose() { StopTest(); }
+        private sealed class TestSignal : ISampleProvider
+        {
+            private int frame;
+            public WaveFormat WaveFormat { get { return WaveFormat.CreateIeeeFloatWaveFormat(44100, 2); } }
+            public int Read(float[] buffer, int offset, int count)
+            {
+                int frames = Math.Min(count / 2, 15435 - frame);
+                for (int i = 0; i < frames; i++, frame++) {
+                    double fade = Math.Min(1, Math.Min(frame / 441.0, (15435 - frame) / 441.0));
+                    float value = (float)(.04 * fade * Math.Sin(frame * 2 * Math.PI * 440 / 44100));
+                    buffer[offset + i * 2] = buffer[offset + i * 2 + 1] = value;
+                }
+                return frames * 2;
+            }
+        }
+    }
+
+    public static class AudioDiagnostics
+    {
+        public static string Report(InputChoice input)
+        {
+            var lines = new List<string> {
+                "Flux audio diagnostics", "App: " + Assembly.GetExecutingAssembly().GetName().Version,
+                "Windows: " + Environment.OSVersion, "Output selection: " + AudioOutputs.PreferredKey,
+                "Input selection: " + (input == null ? "not selected" : input.Name + " / " + input.Key), "",
+                "This report reads device information only. It does not record a microphone, play audio, change system volume or install a driver." };
+            try {
+                using (var enumerator = new MMDeviceEnumerator()) {
+                    foreach (DataFlow flow in new[] { DataFlow.Render, DataFlow.Capture }) {
+                        foreach (Role role in new[] { Role.Console, Role.Multimedia, Role.Communications })
+                            try { using (var device = enumerator.GetDefaultAudioEndpoint(flow, role)) lines.Add(flow + " default " + role + ": " + device.FriendlyName + " / " + device.ID); }
+                            catch (Exception ex) { lines.Add(flow + " default " + role + ": " + ex.Message); }
+                        foreach (var device in enumerator.EnumerateAudioEndPoints(flow, DeviceState.All)) using (device) {
+                            lines.Add(""); lines.Add(flow + ": " + device.FriendlyName + " / " + device.State + " / " + device.ID);
+                            if (device.State != DeviceState.Active) continue;
+                            try { using (var client = device.AudioClient) lines.Add("Mix format: " + client.MixFormat + "; encoding " + client.MixFormat.Encoding); }
+                            catch (Exception ex) { lines.Add("Mix format failed: " + ex); }
+                            if (flow == DataFlow.Render) try { lines.Add("Muted: " + device.AudioEndpointVolume.Mute + "; volume: " + device.AudioEndpointVolume.MasterVolumeLevelScalar); } catch (Exception ex) { lines.Add("Volume query: " + ex.Message); }
+                        }
+                    }
+                }
+            } catch (Exception ex) { lines.Add("Endpoint enumeration failed: " + ex); }
+            lines.Add(""); lines.Add("Available output choices:"); foreach (var choice in AudioOutputs.Choices()) lines.Add(choice.Name + " / " + choice.Key);
+            lines.Add(""); lines.Add("Available input choices:"); foreach (var choice in AudioInputs.Choices()) lines.Add(choice.Name + " / " + choice.Key);
+            if (File.Exists(AudioOutputs.ErrorLog)) try { lines.Add(""); lines.Add("Most recent failed/recovered output open:"); lines.Add(File.ReadAllText(AudioOutputs.ErrorLog)); } catch { }
+            return string.Join(Environment.NewLine, lines) + Environment.NewLine;
+        }
+    }
+}

package/source/AudioInputs.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+using NAudio.CoreAudioApi;
+using NAudio.Wave;
+
+namespace DrumBuddy
+{
+    public sealed class InputChoice
+    {
+        public string Name, Driver, EndpointId;
+        public string Key { get { return Driver != null ? "asio:" + Driver : "input:" + (EndpointId ?? "default"); } }
+        public override string ToString() { return Name; }
+    }
+    internal static class AudioInputs
+    {
+        public static List<InputChoice> Choices()
+        {
+            var choices = new List<InputChoice>();
+            try { foreach (string driver in AsioOut.GetDriverNames()) choices.Add(new InputChoice { Name = driver + " (ASIO)", Driver = driver }); } catch { }
+            if (WindowsWaveDevices.waveInGetNumDevs() > 0) choices.Add(new InputChoice { Name = "Windows default microphone - 16-bit PCM" });
+            try {
+                using (var enumerator = new MMDeviceEnumerator()) {
+                    foreach (var endpoint in enumerator.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active)) {
+                        using (endpoint) {
+                            if (WindowsWaveDevices.Find(endpoint.ID, true) >= 0)
+                                choices.Add(new InputChoice { Name = endpoint.FriendlyName + " (Windows microphone)", EndpointId = endpoint.ID });
+                        }
+                    }
+                }
+            } catch { }
+            return choices;
+        }
+        internal static int Device(InputChoice choice)
+        {
+            int device = string.IsNullOrEmpty(choice.EndpointId) ? -1 : WindowsWaveDevices.Find(choice.EndpointId, true);
+            if (device == -2) throw new IOException("The selected microphone is no longer available. Refresh Audio devices and select it again.");
+            return device;
+        }
+        internal static int Channels(InputChoice choice)
+        {
+            int device = Device(choice), channels = Math.Max(1, Math.Min(2, WindowsWaveDevices.InputCaps(device).Channels));
+            if (channels == 2 && !new[] { 44100, 48000, 96000 }.Any(rate => WindowsWaveDevices.SupportsInput(device, rate, 2))) channels = 1;
+            return channels;
+        }
+        internal static IEnumerable<int> Rates(InputChoice choice, int channels)
+        { int device = Device(choice); return new[] { 44100, 48000, 96000 }.Where(rate => WindowsWaveDevices.SupportsInput(device, rate, channels)).ToArray(); }
+    }
+}