init

2022-01-18 17:10:16 +11:00
commit e58a138bea
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using CSCore.DSP;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    /// <summary>
+    ///     BasicSpectrumProvider
+    /// </summary>
+    public class BasicSpectrumProvider : FftProvider, ISpectrumProvider
+    {
+        private readonly int _sampleRate;
+        private readonly List<object> _contexts = new List<object>();
+
+        public BasicSpectrumProvider(int channels, int sampleRate, FftSize fftSize)
+            : base(channels, fftSize)
+        {
+            if (sampleRate <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(sampleRate));
+            }
+
+            _sampleRate = sampleRate;
+        }
+
+        public int GetFftBandIndex(float frequency)
+        {
+            int fftSize = (int)FftSize;
+            double f = _sampleRate / 2.0;
+            // ReSharper disable once PossibleLossOfFraction
+            return (int)((frequency / f) * (fftSize / 2));
+        }
+
+        public bool GetFftData(float[] fftResultBuffer, object context)
+        {
+            if (_contexts.Contains(context))
+                return false;
+
+            _contexts.Add(context);
+            GetFftData(fftResultBuffer);
+            return true;
+        }
+
+        public override void Add(float[] samples, int count)
+        {
+            base.Add(samples, count);
+
+            if (count > 0)
+            {
+                _contexts.Clear();
+            }
+        }
+
+        public override void Add(float left, float right)
+        {
+            base.Add(left, right);
+            _contexts.Clear();
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3ac978f06ccd8f943ad7c7d03b6229bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,45 @@
+using CSCore;
+using CSCore.DSP;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public class BiQuadFilterSource : SampleAggregatorBase
+    {
+        private readonly object _lockObject = new object();
+        private BiQuad _biQuad;
+
+        public BiQuad Filter
+        {
+            get => _biQuad;
+            set
+            {
+                lock (_lockObject)
+                {
+                    _biQuad = value;
+                }
+            }
+        }
+
+        public BiQuadFilterSource(ISampleSource source) : base(source)
+        {
+        }
+
+        public override int Read(float[] buffer, int offset, int count)
+        {
+            var read = base.Read(buffer, offset, count);
+            
+            lock (_lockObject)
+            {
+                if (Filter != null)
+                {
+                    for (int i = 0; i < read; i++)
+                    {
+                        buffer[i + offset] = Filter.Process(buffer[i + offset]);
+                    }
+                }
+            }
+
+            return read;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ce8b1509cfd7d26459241de2dc788b5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,8 @@
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    internal interface ISpectrumProvider
+    {
+        bool GetFftData(float[] fftBuffer, object context);
+        int GetFftBandIndex(float frequency);
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b3d8384de325694c8a3a05f5c22b115
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Linq;
+using CSCore.DSP;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    internal class LineSpectrum : SpectrumBase
+    {
+        public int BarCount
+        {
+            get => SpectrumResolution;
+            set => SpectrumResolution = value;
+        }
+
+        public LineSpectrum(FftSize fftSize, int minFrequency, int maxFrequency)
+        : base(minFrequency, maxFrequency)
+        {
+            FftSize = fftSize;
+        }
+
+        public float[] GetSpectrumData(double maxValue)
+        {
+            // Get spectrum data internal
+            var fftBuffer = new float[(int)FftSize];
+
+            UpdateFrequencyMapping();
+
+            if (SpectrumProvider.GetFftData(fftBuffer, this))
+            {
+                SpectrumPointData[] spectrumPoints = CalculateSpectrumPoints(maxValue, fftBuffer);
+                
+                // Convert to float[]
+                List<float> spectrumData = new List<float>();
+                spectrumPoints.ToList().ForEach(point => spectrumData.Add((float)point.Value));
+                return spectrumData.ToArray();
+            }
+
+            return null;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a2567baf275265a478107376fdd44c99
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,9 @@
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public enum ScalingStrategy
+    {
+        Decibel,
+        Linear,
+        Sqrt
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4a5498d82d260dc48a788da725b7d4c7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,177 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using CSCore;
+using CSCore.DSP;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    internal abstract class SpectrumBase
+    {
+        private const int ScaleFactorLinear = 9;
+        protected const int ScaleFactorSqr = 2;
+        protected const double MinDbValue = -90;
+        protected const double MaxDbValue = 0;
+        protected const double DbScale = (MaxDbValue - MinDbValue);
+
+        private int _fftSize;
+        private bool _isXLogScale;
+        private int _maxFftIndex;
+        private int _minFrequency;
+        private int _minimumFrequencyIndex;
+        private int _maxFrequency;
+        private int _maximumFrequencyIndex;
+        private int[] _spectrumIndexMax;
+        private int[] _spectrumLogScaleIndexMax;
+        private ISpectrumProvider _spectrumProvider;
+
+        protected int SpectrumResolution;
+        private bool _useAverage;
+
+        [Browsable(false)]
+        public ISpectrumProvider SpectrumProvider
+        {
+            get => _spectrumProvider;
+            set => _spectrumProvider = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
+        public bool IsXLogScale
+        {
+            get => _isXLogScale;
+            set
+            {
+                _isXLogScale = value;
+                UpdateFrequencyMapping();
+            }
+        }
+
+        public ScalingStrategy ScalingStrategy { get; set; }
+
+        public bool UseAverage
+        {
+            get => _useAverage;
+            set => _useAverage = value;
+        }
+
+        [Browsable(false)]
+        public FftSize FftSize
+        {
+            get => (FftSize) _fftSize;
+            protected set
+            {
+                if ((int) Math.Log((int) value, 2) % 1 != 0)
+                    throw new ArgumentOutOfRangeException(nameof(value));
+
+                _fftSize = (int) value;
+                _maxFftIndex = _fftSize / 2 - 1;
+            }
+        }
+
+        public SpectrumBase(int minFrequency, int maxFrequency)
+        {
+            _minFrequency = minFrequency;
+            _maxFrequency = maxFrequency;
+        }
+
+        protected virtual void UpdateFrequencyMapping()
+        {
+            _minimumFrequencyIndex = Math.Min(_spectrumProvider.GetFftBandIndex(_minFrequency), _maxFftIndex);
+            _maximumFrequencyIndex = Math.Min(_spectrumProvider.GetFftBandIndex(_maxFrequency) + 1, _maxFftIndex);
+
+            var actualResolution = SpectrumResolution;
+
+            var indexCount = _maximumFrequencyIndex - _minimumFrequencyIndex;
+            var linearIndexBucketSize = Math.Round(indexCount / (double) actualResolution, 3);
+
+            _spectrumIndexMax = _spectrumIndexMax.CheckBuffer(actualResolution, true);
+            _spectrumLogScaleIndexMax = _spectrumLogScaleIndexMax.CheckBuffer(actualResolution, true);
+
+            var maxLog = Math.Log(actualResolution, actualResolution);
+            
+            for (int i = 1; i < actualResolution; i++)
+            {
+                var logIndex =
+                    (int) ((maxLog - Math.Log((actualResolution + 1) - i, (actualResolution + 1))) * indexCount) +
+                    _minimumFrequencyIndex;
+
+                _spectrumIndexMax[i - 1] = _minimumFrequencyIndex + (int) (i * linearIndexBucketSize);
+                _spectrumLogScaleIndexMax[i - 1] = logIndex;
+            }
+
+            if (actualResolution > 0)
+            {
+                _spectrumIndexMax[_spectrumIndexMax.Length - 1] =
+                    _spectrumLogScaleIndexMax[_spectrumLogScaleIndexMax.Length - 1] = _maximumFrequencyIndex;
+            }
+        }
+
+        protected virtual SpectrumPointData[] CalculateSpectrumPoints(double maxValue, float[] fftBuffer)
+        {
+            var dataPoints = new List<SpectrumPointData>();
+
+            double value0 = 0, value = 0;
+            double lastValue = 0;
+            double actualMaxValue = maxValue;
+            var spectrumPointIndex = 0;
+
+            for (int i = _minimumFrequencyIndex; i <= _maximumFrequencyIndex; i++)
+            {
+                switch (ScalingStrategy)
+                {
+                    case ScalingStrategy.Decibel:
+                        value0 = (((20 * Math.Log10(fftBuffer[i])) - MinDbValue) / DbScale) * actualMaxValue;
+                        break;
+                    case ScalingStrategy.Linear:
+                        value0 = (fftBuffer[i] * ScaleFactorLinear) * actualMaxValue;
+                        break;
+                    case ScalingStrategy.Sqrt:
+                        value0 = ((Math.Sqrt(fftBuffer[i])) * ScaleFactorSqr) * actualMaxValue;
+                        break;
+                }
+
+                var recalc = true;
+
+                value = Math.Max(0, Math.Max(value0, value));
+
+                while (spectrumPointIndex <= _spectrumIndexMax.Length - 1 &&
+                       i ==
+                       (IsXLogScale
+                           ? _spectrumLogScaleIndexMax[spectrumPointIndex]
+                           : _spectrumIndexMax[spectrumPointIndex]))
+                {
+                    if (!recalc)
+                    {
+                        value = lastValue;
+                    }
+
+                    if (value > maxValue)
+                    {
+                        value = maxValue;
+                    }
+
+                    if (_useAverage && spectrumPointIndex > 0)
+                    {
+                        value = (lastValue + value) / 2.0;
+                    }
+
+                    dataPoints.Add(new SpectrumPointData {SpectrumPointIndex = spectrumPointIndex, Value = value});
+
+                    lastValue = value;
+                    value = 0.0;
+                    spectrumPointIndex++;
+                    recalc = false;
+                }
+            }
+
+            return dataPoints.ToArray();
+        }
+
+        [DebuggerDisplay("{" + nameof(Value) + "}")]
+        protected struct SpectrumPointData
+        {
+            public int SpectrumPointIndex;
+            public double Value;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8fbdbf5c48dee7b4da3f946503b29f80
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public class SpectrumSmoother
+    {
+        private long _iteration;
+
+        private readonly int _spectrumSize;
+        private readonly float[] _smoothedSpectrum;
+        private readonly List<float[]> _spectrumHistory = new List<float[]>();
+        
+        public byte SmoothingIterations { get; }
+
+        public SpectrumSmoother(int spectrumSize, byte smoothingIterations)
+        {
+            _spectrumSize = spectrumSize;
+
+            SmoothingIterations = smoothingIterations;
+
+            _smoothedSpectrum = new float[_spectrumSize];
+
+            for (int i = 0; i < _spectrumSize; i++)
+            {
+                _spectrumHistory.Add(new float[SmoothingIterations]);
+            }
+        }
+
+        public float[] GetSpectrumData(float[] spectrum)
+        {
+            _iteration++;
+            
+            // Record and average last N frames
+            for (var i = 0; i < _spectrumSize; i++)
+            {
+                var historyIndex = _iteration % SmoothingIterations;
+
+                var audioData = spectrum[i];
+                _spectrumHistory[i][historyIndex] = audioData;
+
+                _smoothedSpectrum[i] = _spectrumHistory[i].Average();
+            }
+
+            return _smoothedSpectrum;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6dd5954917d385d458671783cb3579ab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,140 @@
+using System;
+using Assets.WasapiAudio.Scripts.Unity;
+using CSCore;
+using CSCore.CoreAudioAPI;
+using CSCore.DSP;
+using CSCore.SoundIn;
+using CSCore.Streams;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public class WasapiAudio
+    {
+        private const FftSize CFftSize = FftSize.Fft4096;
+        private const float MaxAudioValue = 1.0f;
+
+        private readonly WasapiCaptureType _captureType;
+        private readonly int _spectrumSize;
+        private readonly ScalingStrategy _scalingStrategy;
+        private readonly int _minFrequency;
+        private readonly int _maxFrequency;
+
+        private WasapiCapture _wasapiCapture;
+        private SoundInSource _soundInSource;
+        private IWaveSource _realtimeSource;
+        private BasicSpectrumProvider _basicSpectrumProvider;
+        private LineSpectrum _lineSpectrum;
+        private SingleBlockNotificationStream _singleBlockNotificationStream;
+        private WasapiAudioFilter[] _filters;
+        private Action<float[]> _receiveAudio;
+
+        public WasapiAudio(WasapiCaptureType captureType, int spectrumSize, ScalingStrategy scalingStrategy, int minFrequency, int maxFrequency, WasapiAudioFilter[] filters, Action<float[]> receiveAudio)
+        {
+            _captureType = captureType;
+            _spectrumSize = spectrumSize;
+            _scalingStrategy = scalingStrategy;
+            _minFrequency = minFrequency;
+            _maxFrequency = maxFrequency;
+            _filters = filters;
+            _receiveAudio = receiveAudio;
+        }
+
+        public void StartListen()
+        {
+            switch (_captureType)
+            {
+                case WasapiCaptureType.Loopback:
+                    _wasapiCapture = new WasapiLoopbackCapture();
+                    break;
+                case WasapiCaptureType.Microphone:
+                    MMDevice defaultMicrophone;
+                    using (var deviceEnumerator = new MMDeviceEnumerator())
+                    {
+                        defaultMicrophone = deviceEnumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
+                    }
+                    _wasapiCapture = new WasapiCapture();
+                    _wasapiCapture.Device = defaultMicrophone;
+                    break;
+                default:
+                    throw new InvalidOperationException("Unhandled WasapiCaptureType");
+            }
+
+            _wasapiCapture.Initialize();
+
+            _soundInSource = new SoundInSource(_wasapiCapture);
+
+            _basicSpectrumProvider = new BasicSpectrumProvider(_soundInSource.WaveFormat.Channels, _soundInSource.WaveFormat.SampleRate, CFftSize);
+
+            _lineSpectrum = new LineSpectrum(CFftSize, _minFrequency, _maxFrequency)
+            {
+                SpectrumProvider = _basicSpectrumProvider,
+                BarCount = _spectrumSize,
+                UseAverage = true,
+                IsXLogScale = true,
+                ScalingStrategy = _scalingStrategy
+            };
+
+            _wasapiCapture.Start();
+
+            var sampleSource = _soundInSource.ToSampleSource();
+
+            if (_filters != null && _filters.Length > 0)
+            {
+                foreach (var filter in _filters)
+                {
+                    sampleSource = sampleSource.AppendSource(x => new BiQuadFilterSource(x));
+                    var biQuadSource = (BiQuadFilterSource) sampleSource;
+                    
+                    switch (filter.Type)
+                    {
+                        case WasapiAudioFilterType.LowPass:
+                            biQuadSource.Filter = new LowpassFilter(_soundInSource.WaveFormat.SampleRate, filter.Frequency);
+                            break;
+                        case WasapiAudioFilterType.HighPass:
+                            biQuadSource.Filter = new HighpassFilter(_soundInSource.WaveFormat.SampleRate, filter.Frequency);
+                            break;
+                        case WasapiAudioFilterType.BandPass:
+                            biQuadSource.Filter = new BandpassFilter(_soundInSource.WaveFormat.SampleRate, filter.Frequency);
+                            break;
+                    }
+                }
+            }
+
+            _singleBlockNotificationStream = new SingleBlockNotificationStream(sampleSource);
+            _realtimeSource = _singleBlockNotificationStream.ToWaveSource();
+
+            var buffer = new byte[_realtimeSource.WaveFormat.BytesPerSecond / 2];
+
+            _soundInSource.DataAvailable += (s, ea) =>
+            {
+                while (_realtimeSource.Read(buffer, 0, buffer.Length) > 0)
+                {
+                    var spectrumData = _lineSpectrum.GetSpectrumData(MaxAudioValue);
+
+                    if (spectrumData != null)
+                    {
+                        _receiveAudio?.Invoke(spectrumData);
+                    }
+                }
+            };
+
+            _singleBlockNotificationStream.SingleBlockRead += SingleBlockNotificationStream_SingleBlockRead;
+        }
+
+        public void StopListen()
+        {
+            _singleBlockNotificationStream.SingleBlockRead -= SingleBlockNotificationStream_SingleBlockRead;
+
+            _soundInSource.Dispose();
+            _realtimeSource.Dispose();
+            _receiveAudio = null;
+            _wasapiCapture.Stop();
+            _wasapiCapture.Dispose();
+        }
+
+        private void SingleBlockNotificationStream_SingleBlockRead(object sender, SingleBlockReadEventArgs e)
+        {
+            _basicSpectrumProvider.Add(e.Left, e.Right);
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a3c269a428d97534b89ae32d45f9658a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,18 @@
+using System;
+
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public enum WasapiAudioFilterType
+    {
+        LowPass,
+        HighPass,
+        BandPass,
+    }
+
+    [Serializable]
+    public class WasapiAudioFilter
+    {
+        public WasapiAudioFilterType Type;
+        public int Frequency;
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 512a31747c43f524b9317c43013b7f98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,8 @@
+namespace Assets.WasapiAudio.Scripts.Core
+{
+    public enum WasapiCaptureType
+    {
+        Loopback,
+        Microphone
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 503e87bd4ebdf5b498b2683bb0bba127
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: