Move solution and projects to src

src/Ryujinx.Audio/Renderer/Server/Sink/BaseSink.cs

@@ -0,0 +1,102 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System.Diagnostics;
+using static Ryujinx.Audio.Renderer.Common.BehaviourParameter;
+
+namespace Ryujinx.Audio.Renderer.Server.Sink
+{
+    /// <summary>
+    /// Base class used for server information of a sink.
+    /// </summary>
+    public class BaseSink
+    {
+        /// <summary>
+        /// The type of this <see cref="BaseSink"/>.
+        /// </summary>
+        public SinkType Type;
+
+        /// <summary>
+        /// Set to true if the sink is used.
+        /// </summary>
+        public bool IsUsed;
+
+        /// <summary>
+        /// Set to true if the sink need to be skipped because of invalid state.
+        /// </summary>
+        public bool ShouldSkip;
+
+        /// <summary>
+        /// The node id of the sink.
+        /// </summary>
+        public int NodeId;
+
+        /// <summary>
+        /// Create a new <see cref="BaseSink"/>.
+        /// </summary>
+        public BaseSink()
+        {
+            CleanUp();
+        }
+
+        /// <summary>
+        /// Clean up the internal state of the <see cref="BaseSink"/>.
+        /// </summary>
+        public virtual void CleanUp()
+        {
+            Type = TargetSinkType;
+            IsUsed = false;
+            ShouldSkip = false;
+        }
+
+        /// <summary>
+        /// The target <see cref="SinkType"/> handled by this <see cref="BaseSink"/>.
+        /// </summary>
+        public virtual SinkType TargetSinkType => SinkType.Invalid;
+
+        /// <summary>
+        /// Check if the <see cref="SinkType"/> sent by the user match the internal <see cref="SinkType"/>.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        /// <returns>Return true, if the <see cref="SinkType"/> sent by the user match the internal <see cref="SinkType"/>.</returns>
+        public bool IsTypeValid(ref SinkInParameter parameter)
+        {
+            return parameter.Type == TargetSinkType;
+        }
+
+        /// <summary>
+        /// Update the <see cref="BaseSink"/> state during command generation.
+        /// </summary>
+        public virtual void UpdateForCommandGeneration()
+        {
+            Debug.Assert(Type == TargetSinkType);
+        }
+
+        /// <summary>
+        /// Update the internal common parameters from user parameter.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        protected void UpdateStandardParameter(ref SinkInParameter parameter)
+        {
+            if (IsUsed != parameter.IsUsed)
+            {
+                IsUsed = parameter.IsUsed;
+                NodeId = parameter.NodeId;
+            }
+        }
+
+        /// <summary>
+        /// Update the internal state from user parameter.
+        /// </summary>
+        /// <param name="errorInfo">The possible <see cref="ErrorInfo"/> that was generated.</param>
+        /// <param name="parameter">The user parameter.</param>
+        /// <param name="outStatus">The user output status.</param>
+        /// <param name="mapper">The mapper to use.</param>
+        public virtual void Update(out ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            errorInfo = new ErrorInfo();
+        }
+    }
+}

src/Ryujinx.Audio/Renderer/Server/Sink/CircularBufferSink.cs

@@ -0,0 +1,109 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Sink;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Sink
+{
+    /// <summary>
+    /// Server information for a circular buffer sink.
+    /// </summary>
+    public class CircularBufferSink : BaseSink
+    {
+        /// <summary>
+        /// The circular buffer parameter.
+        /// </summary>
+        public CircularBufferParameter Parameter;
+
+        /// <summary>
+        /// The last written data offset on the circular buffer.
+        /// </summary>
+        private uint _lastWrittenOffset;
+
+        /// <summary>
+        /// THe previous written offset of the circular buffer.
+        /// </summary>
+        private uint _oldWrittenOffset;
+
+        /// <summary>
+        /// The current offset to write data on the circular buffer.
+        /// </summary>
+        public uint CurrentWriteOffset { get; private set; }
+
+        /// <summary>
+        /// The <see cref="AddressInfo"/> of the circular buffer.
+        /// </summary>
+        public AddressInfo CircularBufferAddressInfo;
+
+        public CircularBufferSink()
+        {
+            CircularBufferAddressInfo = AddressInfo.Create();
+        }
+
+        public override SinkType TargetSinkType => SinkType.CircularBuffer;
+
+        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        {
+            errorInfo = new BehaviourParameter.ErrorInfo();
+            outStatus = new SinkOutStatus();
+
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref CircularBufferParameter inputDeviceParameter = ref MemoryMarshal.Cast<byte, CircularBufferParameter>(parameter.SpecificData)[0];
+
+            if (parameter.IsUsed != IsUsed || ShouldSkip)
+            {
+                UpdateStandardParameter(ref parameter);
+
+                if (parameter.IsUsed)
+                {
+                    Debug.Assert(CircularBufferAddressInfo.CpuAddress == 0);
+                    Debug.Assert(CircularBufferAddressInfo.GetReference(false) == 0);
+
+                    ShouldSkip = !mapper.TryAttachBuffer(out errorInfo, ref CircularBufferAddressInfo, inputDeviceParameter.BufferAddress, inputDeviceParameter.BufferSize);
+                }
+                else
+                {
+                    Debug.Assert(CircularBufferAddressInfo.CpuAddress != 0);
+                    Debug.Assert(CircularBufferAddressInfo.GetReference(false) != 0);
+                }
+
+                Parameter = inputDeviceParameter;
+            }
+
+            outStatus.LastWrittenOffset = _lastWrittenOffset;
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            Debug.Assert(Type == TargetSinkType);
+
+            if (IsUsed)
+            {
+                uint frameSize = Constants.TargetSampleSize * Parameter.SampleCount * Parameter.InputCount;
+
+                _lastWrittenOffset = _oldWrittenOffset;
+
+                _oldWrittenOffset = CurrentWriteOffset;
+
+                CurrentWriteOffset += frameSize;
+
+                if (Parameter.BufferSize > 0)
+                {
+                    CurrentWriteOffset %= Parameter.BufferSize;
+                }
+            }
+        }
+
+        public override void CleanUp()
+        {
+            CircularBufferAddressInfo = AddressInfo.Create();
+            _lastWrittenOffset = 0;
+            _oldWrittenOffset = 0;
+            CurrentWriteOffset = 0;
+            base.CleanUp();
+        }
+    }
+}

src/Ryujinx.Audio/Renderer/Server/Sink/DeviceSink.cs

@@ -0,0 +1,75 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Sink;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using Ryujinx.Audio.Renderer.Server.Upsampler;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Sink
+{
+    /// <summary>
+    /// Server information for a device sink.
+    /// </summary>
+    public class DeviceSink : BaseSink
+    {
+        /// <summary>
+        /// The downmix coefficients.
+        /// </summary>
+        public float[] DownMixCoefficients;
+
+        /// <summary>
+        /// The device parameters.
+        /// </summary>
+        public DeviceParameter Parameter;
+
+        /// <summary>
+        /// The upsampler instance used by this sink.
+        /// </summary>
+        /// <remarks>Null if no upsampling is needed.</remarks>
+        public UpsamplerState UpsamplerState;
+
+        /// <summary>
+        /// Create a new <see cref="DeviceSink"/>.
+        /// </summary>
+        public DeviceSink()
+        {
+            DownMixCoefficients = new float[4];
+        }
+
+        public override void CleanUp()
+        {
+            UpsamplerState?.Release();
+
+            UpsamplerState = null;
+
+            base.CleanUp();
+        }
+
+        public override SinkType TargetSinkType => SinkType.Device;
+
+        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref DeviceParameter inputDeviceParameter = ref MemoryMarshal.Cast<byte, DeviceParameter>(parameter.SpecificData)[0];
+
+            if (parameter.IsUsed != IsUsed)
+            {
+                UpdateStandardParameter(ref parameter);
+                Parameter = inputDeviceParameter;
+            }
+            else
+            {
+                Parameter.DownMixParameterEnabled = inputDeviceParameter.DownMixParameterEnabled;
+                inputDeviceParameter.DownMixParameter.AsSpan().CopyTo(Parameter.DownMixParameter.AsSpan());
+            }
+
+            Parameter.DownMixParameter.AsSpan().CopyTo(DownMixCoefficients.AsSpan());
+
+            errorInfo = new BehaviourParameter.ErrorInfo();
+            outStatus = new SinkOutStatus();
+        }
+    }
+}

src/Ryujinx.Audio/Renderer/Server/Sink/SinkContext.cs

@@ -0,0 +1,56 @@
+using System.Diagnostics;
+
+namespace Ryujinx.Audio.Renderer.Server.Sink
+{
+    /// <summary>
+    /// Sink context.
+    /// </summary>
+    public class SinkContext
+    {
+        /// <summary>
+        /// Storage for <see cref="BaseSink"/>.
+        /// </summary>
+        private BaseSink[] _sinks;
+
+        /// <summary>
+        /// The total sink count.
+        /// </summary>
+        private uint _sinkCount;
+
+        /// <summary>
+        /// Initialize the <see cref="SinkContext"/>.
+        /// </summary>
+        /// <param name="sinksCount">The total sink count.</param>
+        public void Initialize(uint sinksCount)
+        {
+            _sinkCount = sinksCount;
+            _sinks = new BaseSink[_sinkCount];
+
+            for (int i = 0; i < _sinkCount; i++)
+            {
+                _sinks[i] = new BaseSink();
+            }
+        }
+
+        /// <summary>
+        /// Get the total sink count.
+        /// </summary>
+        /// <returns>The total sink count.</returns>
+        public uint GetCount()
+        {
+            return _sinkCount;
+        }
+
+        /// <summary>
+        /// Get a reference to a <see cref="BaseSink"/> at the given <paramref name="id"/>.
+        /// </summary>
+        /// <param name="id">The index to use.</param>
+        /// <returns>A reference to a <see cref="BaseSink"/> at the given <paramref name="id"/>.</returns>
+        public ref BaseSink GetSink(int id)
+        {
+            Debug.Assert(id >= 0 && id < _sinkCount);
+
+            return ref _sinks[id];
+        }
+    }
+}