Create audio buffer

Author: ladvoc

Runtime/Scripts/Internal/AudioBuffer.cs

@@ -0,0 +1,101 @@
+using System;
+using LiveKit.Internal;
+
+namespace LiveKit
+{
+    /// <summary>
+    /// A thread-safe buffer for buffering audio samples.
+    /// </summary>
+    internal class AudioBuffer
+    {
+        private readonly uint _bufferDurationMs;
+        private RingBuffer _buffer;
+        private uint _channels;
+        private uint _sampleRate;
+        private object _lock = new object();
+
+        /// <summary>
+        /// Initializes a new audio sample buffer for holding samples for a given duration.
+        /// </summary>
+        internal AudioBuffer(uint bufferDurationMs = 200)
+        {
+            _bufferDurationMs = bufferDurationMs;
+        }
+
+        /// <summary>
+        /// Write audio samples.
+        /// </summary>
+        /// <remarks>
+        /// The float data will be converted to short format before being written to the buffer.
+        /// If the number of channels or sample rate changes, the buffer will be recreated.
+        /// </remarks>
+        /// <param name="data">The audio samples to write.</param>
+        /// <param name="channels">The number of channels in the audio data.</param>
+        /// <param name="sampleRate">The sample rate of the audio data in Hz.</param>
+        internal void Write(float[] data, uint channels, uint sampleRate)
+        {
+            static short FloatToS16(float v)
+            {
+                v *= 32768f;
+                v = Math.Min(v, 32767f);
+                v = Math.Max(v, -32768f);
+                return (short)(v + Math.Sign(v) * 0.5f);
+            }
+
+            var s16Data = new short[data.Length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                s16Data[i] = FloatToS16(data[i]);
+            }
+            Capture(s16Data, channels, sampleRate);
+        }
+
+        private void Capture(short[] data, uint channels, uint sampleRate)
+        {
+            lock (_lock)
+            {
+                if (_buffer == null || channels != _channels || sampleRate != _sampleRate)
+                {
+                    var size = (int)(channels * sampleRate * (_bufferDurationMs / 1000f));
+                    _buffer?.Dispose();
+                    _buffer = new RingBuffer(size * sizeof(short));
+                    _channels = channels;
+                    _sampleRate = sampleRate;
+                }
+                unsafe
+                {
+                    fixed (short* pData = data)
+                    {
+                        var byteData = new ReadOnlySpan<byte>(pData, data.Length * sizeof(short));
+                        _buffer.Write(byteData);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads a frame that is the length of the given duration.
+        /// </summary>
+        /// <param name="durationMs">The duration of the audio samples to read in milliseconds.</param>
+        /// <returns>An AudioFrame containing the read audio samples or if there is not enough samples, null.</returns>
+        internal AudioFrame ReadDuration(uint durationMs)
+        {
+            lock (_lock)
+            {
+                if (_buffer == null) return null;
+
+                var samplesForDuration = (uint)(_sampleRate * (durationMs / 1000f));
+                var requiredLength = samplesForDuration * _channels * sizeof(short);
+                if (_buffer.AvailableRead() < requiredLength) return null;
+
+                var frame = new AudioFrame(_sampleRate, _channels, samplesForDuration);
+                unsafe
+                {
+                    var frameData = new Span<byte>(frame.Data.ToPointer(), frame.Length);
+                    _buffer.Read(frameData);
+                }
+                return frame;
+            }
+        }
+    }
+}

Runtime/Scripts/Internal/AudioBuffer.cs.meta

@@ -0,0 +1,31 @@
+using System;
+using NUnit.Framework;
+
+namespace LiveKit.Tests
+{
+    public class AudioBufferTest
+    {
+        [Test]
+        [TestCase(24000u, 1u, 10u)]
+        [TestCase(48000u, 2u, 10u)]
+        public void TestWriteAndRead(uint sampleRate, uint channels, uint durationMs)
+        {
+            var buffer = new AudioBuffer();
+
+            Assert.IsNull(buffer.ReadDuration(durationMs), "Should not be able to read from empty buffer");
+
+            var samples = TestUtils.GenerateSineWave(channels, sampleRate, durationMs);
+            buffer.Write(samples, channels, sampleRate);
+
+            Assert.IsNull(buffer.ReadDuration(durationMs * 2), "Should not be enough samples for this read");
+
+            var frame = buffer.ReadDuration(durationMs);
+            Assert.IsNotNull(frame);
+            Assert.AreEqual(sampleRate, frame.SampleRate);
+            Assert.AreEqual(channels, frame.NumChannels);
+            Assert.AreEqual(samples.Length / channels, frame.SamplesPerChannel);
+
+            Assert.IsNull(buffer.ReadDuration(durationMs), "Should not be able to read again");
+        }
+    }
+}

Tests/AudioBuffer.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace LiveKit.Tests
+{
+    internal static class TestUtils
+    {
+        /// <summary>
+        /// Generates a sine wave with the specified parameters.
+        /// </summary>
+        /// <param name="channels">Number of audio channels.</param>
+        /// <param name="sampleRate">Sample rate in Hz.</param>
+        /// <param name="durationMs">Duration in milliseconds.</param>
+        /// <param name="frequency">Frequency of the sine wave in Hz.</param>
+        /// <returns>A float array containing the generated sine wave.</returns>
+        internal static float[] GenerateSineWave(uint channels, uint sampleRate, uint durationMs, uint frequency = 440)
+        {
+            var samplesPerChannel = sampleRate * durationMs / 1000;
+            var samples = new float[samplesPerChannel * channels];
+            for (int i = 0; i < samplesPerChannel; i++)
+            {
+                float sampleValue = (float)Math.Sin(2 * Math.PI * frequency * i / sampleRate);
+                for (int channel = 0; channel < channels; channel++)
+                    samples[i * channels + channel] = sampleValue;
+            }
+            return samples;
+        }
+    }
+}
+