Added new audio limiter & more:

 - Implemented audo limiter
 - Implemented improved audio file length and seeking calculation (WIP)
 - Fixed bug where untrimmed audio cues wouldn't loop
 - Fixed some audio meetering bugs
 - Implemented new vectorized methods
 - Peak file format updated to help with file seeking
 - UI tweaks + misc refactorings

Author: space928

QPlayer/Audio/AudioLimiterSampleProvider.cs

@@ -0,0 +1,231 @@
+using NAudio.Wave;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace QPlayer.Audio;
+
+public class AudioLimiterSampleProvider : ISamplePositionProvider
+{
+    private readonly ISamplePositionProvider source;
+    private readonly DelaySampleProvider delay;
+    private readonly int channelCount;
+    private readonly int fs;
+    private readonly float[] envBuff;
+    private int attack = 1;
+    private int release = 1;
+    private float threshold;
+    private readonly Lock lockObj;
+
+    // State
+    private float minHoldVal = 1;
+    private int minHoldTime = int.MaxValue;
+    private float relLastMin = 0;
+    private float relLastRes = 1;
+    private float smoothV1 = 1;
+    private float smoothV2 = 1;
+    private int meterSampleCount;
+    private float meterLastG = 1;
+
+    const int BLOCK_SIZE = 1024;
+    const int MAX_ATTACK = 4096;
+
+    public float AttackTime
+    {
+        get => attack / (float)(fs * channelCount);
+        set => attack = Math.Clamp((int)(value * (fs * channelCount)), 5, MAX_ATTACK);
+    }
+
+    public float ReleaseTime
+    {
+        get => release / (float)(fs * channelCount);
+        set => release = Math.Max(5, (int)(value * (fs * channelCount)));
+    }
+
+    public float Threshold
+    {
+        get => threshold;
+        set => threshold = value;
+    }
+
+    public bool Enabled { get; set; } = true;
+    public float InputGain { get; set; } = 1;
+
+    public long Position
+    {
+        get => Math.Max(0, source.Position - attack);
+        set => source.Position = Math.Max(0, source.Position - attack);
+    }
+
+    public WaveFormat WaveFormat => source.WaveFormat;
+
+    /// <summary>
+    /// The number of samples to read between each metering event.
+    /// </summary>
+    public int SamplesPerNotification { get; set; }
+
+    /// <summary>
+    /// An event raised every <see cref="SamplesPerNotification"/> samples with metering information.
+    /// </summary>
+    public event Action<float>? OnMeter;
+
+    public AudioLimiterSampleProvider(ISamplePositionProvider source)
+    {
+        this.source = source;
+        this.channelCount = source.WaveFormat.Channels;
+        this.fs = source.WaveFormat.SampleRate;
+        lockObj = new();
+        envBuff = new float[BLOCK_SIZE];
+        delay = new(source, MAX_ATTACK);
+    }
+
+    public int Read(float[] buffer, int offset, int count)
+    {
+        if (!Enabled)
+        {
+            return source.Read(buffer, offset, count);
+        }
+
+        using var _ = lockObj.EnterScope();
+
+        count = Math.Min(count, BLOCK_SIZE);
+        int read = delay.Read(envBuff, 0, count);
+
+        // Clip
+        VectorExtensions.ClipGR(envBuff.AsSpan(0, read), InputGain, threshold);
+
+        // Moving min --> vey slow, replaced with min-hold
+        /*movingMinDelay.Push(envBuff.AsSpan(0, read));
+        for (int i = 0; i < read; i++)
+        {
+            var first = movingMinDelay.GetDelayed(attack, read - i, out var second);
+            float min = VectorExtensions.Min(first);
+            if (second.Length > 0)
+                min = MathF.Min(min, VectorExtensions.Min(second));
+            envBuff[i] = min;
+        }*/
+
+        // Min hold
+        float minVal = minHoldVal;
+        int minTime = minHoldTime;
+        for (int i = 0; i < read; i++)
+        {
+            float v = envBuff[i];
+            if (v < minVal || minTime >= attack)
+            {
+                minTime = 0;
+                minVal = v;
+            }
+            else
+            {
+                minTime++;
+                envBuff[i] = v;
+            }
+        }
+        minHoldVal = minVal;
+        minHoldTime = minTime;
+
+        // Exponential release stage
+        float gradientFactor = 1f / (release + 1);
+        // releaseDelay.Push(envBuff.AsSpan(0, read));
+        float last = relLastMin;
+        float output = relLastRes;
+        for (int i = 0; i < read; i++)
+        {
+            float min = envBuff[i];
+            output += (min - output) * gradientFactor;
+            output = MathF.Min(output, min);
+            last = min;
+            envBuff[i] = output;
+        }
+        relLastMin = last;
+        relLastRes = output;
+
+        // Smoothing - A weighted moving average (a convolution of a window function) --> tooo slowww
+        /*smootherDelay.Push(envBuff.AsSpan(0, read));
+        float recip = 1f/windowSum;
+        for (int i = 0; i < read; i++)
+        {
+            var first = smootherDelay.GetDelayed(attack, read - i, out var second);
+            float sum = VectorExtensions.Convolve(first, smootherWindow);
+            if (second.Length > 0)
+                sum += VectorExtensions.Convolve(second, smootherWindow.AsSpan(first.Length));
+            envBuff[i] = sum * recip;
+        }*/
+        // Smoothing - Exponential/Constant rate hybrid
+        float rate = 5 / (float)attack;
+        float v1 = smoothV1;
+        float v2 = smoothV2;
+        for (int i = 0; i < read; i++)
+        {
+            var v = envBuff[i];
+            v1 = Math.Max(v, v1 + (v - 1) * rate);
+            var n = v2 + (v1 - v2) * rate * 3;
+            v2 = Math.Clamp(n, v1, 1);
+            envBuff[i] = v2;
+        }
+        smoothV1 = v1;
+        smoothV2 = v2;
+
+        // TODO: > 2 channel support?
+        if (channelCount == 2)
+        {
+            // Link stereo limiting by computing the min per 2-samples
+            VectorExtensions.StereoMin(envBuff);
+        }
+
+        int k = 0;
+        float meterMin = meterLastG;
+        while (k < read && SamplesPerNotification > 0)
+        {
+            int toTake = Math.Min(SamplesPerNotification - meterSampleCount, read - k);
+            meterMin = MathF.Min(meterMin, VectorExtensions.Min(envBuff.AsSpan(k, toTake)));
+            k += toTake;
+            meterSampleCount += toTake;
+            if (meterSampleCount >= SamplesPerNotification)
+            {
+                NotifySample(meterMin);//(1 / meterMin - 1);
+                meterMin = 1;
+            }
+        }
+        meterLastG = meterMin;
+
+        if (MathF.Abs(envBuff[0]) > 1.5f)
+            Debugger.Break();
+
+        read = delay.ReadDelayed(buffer, offset, read, attack);
+        VectorExtensions.Multiply(buffer.AsSpan(offset, read), envBuff.AsSpan(0, read));
+        VectorExtensions.Multiply(buffer.AsSpan(offset, read), InputGain);
+        return read;
+
+        void NotifySample(float meterMin)
+        {
+            float gr = 1 - meterMin;
+            OnMeter?.Invoke(gr);
+            meterSampleCount = 0;
+        }
+    }
+
+    /*[MemberNotNull(nameof(smootherWindow))]
+    private void CreateSmootherWindow()
+    {
+        smootherWindow = new float[attack];
+        // Blackmann window
+        float alpha = 0.16f;
+        float a0 = (1 - alpha) / 2;
+        float a1 = 0.5f;
+        float a2 = alpha / 2;
+        windowSum = 0;
+        for (int i = 0; i < smootherWindow.Length; i++)
+        {
+            float t = MathF.Tau * i / (float)smootherWindow.Length;
+            float x = a0 - a1 * MathF.Cos(t) + a2 * MathF.Cos(2 * t);
+            smootherWindow[i] = x;
+            windowSum += x;
+        }
+    }*/
+}

QPlayer/Audio/AudioPlaybackManager.cs

@@ -1,6 +1,5 @@
 using NAudio.CoreAudioApi;
 using NAudio.Wave;
-using NAudio.Wave.SampleProviders;
 using QPlayer.ViewModels;
 using System;
 using System.Collections.Generic;
@@ -79,6 +78,20 @@ public AudioPlaybackManager(MainViewModel mainViewModel)
         meteringProvider.SamplesPerNotification = mixer.WaveFormat.SampleRate / 30;
     }
 
+    /// <summary>
+    /// When building a mastering chain, use this sample provider as the source, it should never be read from directly.
+    /// </summary>
+    public ISamplePositionProvider MixerSampleProvider => mixer;
+
+    /// <summary>
+    /// Registers the given sample provider as a mastering chain, this is the last sample provider before the output.
+    /// </summary>
+    /// <param name="sampleProvider"></param>
+    public void RegisterMasterChain(ISampleProvider sampleProvider)
+    {
+        meteringProvider.Source = sampleProvider;
+    }
+
     public void Stop()
     {
         device?.Stop();

QPlayer/Audio/DelayBuffer.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Numerics;
+
+namespace QPlayer.Audio;
+
+public class DelayBuffer
+{
+    private readonly float[] delayBuff;
+    protected readonly int maxDelayTime;
+    private int headPos;
+
+    public DelayBuffer(uint maxDelayTime)
+    {
+        this.maxDelayTime = (int)maxDelayTime;
+        delayBuff = new float[BitOperations.RoundUpToPowerOf2(maxDelayTime) << 1];
+    }
+
+    public Span<float> GetDelayed(int count, int delaySamples, out Span<float> secondHalf)
+    {
+        // Rewind the head based on how much we're delaying and how many samples we need to retrieve
+        int pos = headPos - delaySamples - count;
+        int available = headPos - pos;
+        pos &= delayBuff.Length - 1; // Wrap the position
+        int toRead = Math.Min(count, available);
+        secondHalf = default;
+
+        int firstHalf = delayBuff.Length - pos;
+        if (toRead >= firstHalf)
+        {
+            // Split span
+            secondHalf = delayBuff.AsSpan(0, toRead - firstHalf);
+            return delayBuff.AsSpan(pos, firstHalf);
+        }
+        else
+        {
+            // Contiguous span
+            return delayBuff.AsSpan(pos, toRead);
+        }
+    }
+
+    /// <summary>
+    /// Pushes the span of samples into this delay buffer.
+    /// </summary>
+    /// <param name="values"></param>
+    public void Push(ReadOnlySpan<float> values)
+    {
+        int firstHalf = delayBuff.Length - headPos;
+        if (values.Length >= firstHalf)
+        {
+            // Split copy
+            values[..firstHalf].CopyTo(delayBuff.AsSpan(headPos, firstHalf));
+            values[firstHalf..].CopyTo(delayBuff.AsSpan(0));
+        }
+        else
+        {
+            // Contiguous copy
+            values.CopyTo(delayBuff.AsSpan(headPos));
+        }
+        headPos = (headPos + values.Length) & (delayBuff.Length - 1);
+    }
+}

QPlayer/Audio/DelaySampleProvider.cs

@@ -0,0 +1,64 @@
+using NAudio.Wave;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Text;
+using System.Threading;
+
+namespace QPlayer.Audio;
+
+public class DelaySampleProvider : DelayBuffer, ISamplePositionProvider
+{
+    private readonly ISamplePositionProvider source;
+    private readonly WaveFormat waveFormat;
+
+    public WaveFormat WaveFormat => waveFormat;
+
+    public long Position
+    {
+        get => source.Position;
+        set => source.Position = value;
+    }
+
+    public DelaySampleProvider(ISamplePositionProvider source, uint maxDelayTime) : base(maxDelayTime)
+    {
+        this.source = source;
+        this.waveFormat = source.WaveFormat;
+    }
+
+    /// <summary>
+    /// Reads the specified number of samples from the input stream and pushes them to the delay buffer.
+    /// </summary>
+    /// <param name="buffer"></param>
+    /// <param name="offset"></param>
+    /// <param name="count"></param>
+    /// <returns></returns>
+    public int Read(float[] buffer, int offset, int count)
+    {
+        // Read enough samples to fill at most half the buffer (half the buffer represents the maximum delay time)
+        int read = source.Read(buffer, offset, Math.Min(count, maxDelayTime));
+
+        // Now copy these samples into the delay buffer
+        Push(buffer.AsSpan(offset, read));
+
+        return read;
+    }
+
+    /// <summary>
+    /// Reads the specified number of samples from the delay buffer with the specified amount of delay. 
+    /// This should imediately preceed a call to <see cref="Read(float[], int, int)"/> and should read 
+    /// the same number of samples the read call returned.
+    /// </summary>
+    /// <param name="buffer"></param>
+    /// <param name="offset"></param>
+    /// <param name="count"></param>
+    /// <returns></returns>
+    public int ReadDelayed(float[] buffer, int offset, int count, int delaySamples)
+    {
+        var firstHalf = GetDelayed(count, delaySamples, out var secondHalf);
+        firstHalf.CopyTo(buffer.AsSpan(offset));
+        secondHalf.CopyTo(buffer.AsSpan(offset + firstHalf.Length));
+
+        return firstHalf.Length + secondHalf.Length;
+    }
+}