Move solution and projects to src

12 files changed, 1148 insertions, 0 deletions

diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/AuxiliaryBufferEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/AuxiliaryBufferEffect.cs
new file mode 100644
index 00000000..16406527
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/AuxiliaryBufferEffect.cs
@@ -0,0 +1,85 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ryujinx.Audio.Renderer.Dsp.State.AuxiliaryBufferHeader;
+using DspAddress = System.UInt64;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for an auxiliary buffer effect.
+    /// </summary>
+    public class AuxiliaryBufferEffect : BaseEffect
+    {
+        /// <summary>
+        /// The auxiliary buffer parameter.
+        /// </summary>
+        public AuxiliaryBufferParameter Parameter;
+
+        /// <summary>
+        /// Auxiliary buffer state.
+        /// </summary>
+        public AuxiliaryBufferAddresses State;
+
+        public override EffectType TargetEffectType => EffectType.AuxiliaryBuffer;
+
+        public override DspAddress GetWorkBuffer(int index)
+        {
+            return WorkBuffers[index].GetReference(true);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, AuxiliaryBufferParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            if (BufferUnmapped || parameter.IsNew)
+            {
+                ulong bufferSize = (ulong)Unsafe.SizeOf<int>() * Parameter.BufferStorageSize + (ulong)Unsafe.SizeOf<AuxiliaryBufferHeader>();
+
+                bool sendBufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], Parameter.SendBufferInfoAddress, bufferSize);
+                bool returnBufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[1], Parameter.ReturnBufferInfoAddress, bufferSize);
+
+                BufferUnmapped = sendBufferUnmapped && returnBufferUnmapped;
+
+                if (!BufferUnmapped)
+                {
+                    DspAddress sendDspAddress = WorkBuffers[0].GetReference(false);
+                    DspAddress returnDspAddress = WorkBuffers[1].GetReference(false);
+
+                    State.SendBufferInfo = sendDspAddress + (uint)Unsafe.SizeOf<AuxiliaryBufferInfo>();
+                    State.SendBufferInfoBase = sendDspAddress + (uint)Unsafe.SizeOf<AuxiliaryBufferHeader>();
+
+                    State.ReturnBufferInfo = returnDspAddress + (uint)Unsafe.SizeOf<AuxiliaryBufferInfo>();
+                    State.ReturnBufferInfoBase = returnDspAddress + (uint)Unsafe.SizeOf<AuxiliaryBufferHeader>();
+                }
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs
new file mode 100644
index 00000000..825b3bf7
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs
@@ -0,0 +1,272 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using Ryujinx.Audio.Renderer.Utils;
+using System;
+using System.Diagnostics;
+using static Ryujinx.Audio.Renderer.Common.BehaviourParameter;
+
+using DspAddress = System.UInt64;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Base class used as a server state for an effect.
+    /// </summary>
+    public class BaseEffect
+    {
+        /// <summary>
+        /// The <see cref="EffectType"/> of the effect.
+        /// </summary>
+        public EffectType Type;
+
+        /// <summary>
+        /// Set to true if the effect must be active.
+        /// </summary>
+        public bool IsEnabled;
+
+        /// <summary>
+        /// Set to true if the internal effect work buffers used wasn't mapped.
+        /// </summary>
+        public bool BufferUnmapped;
+
+        /// <summary>
+        /// The current state of the effect.
+        /// </summary>
+        public UsageState UsageState;
+
+        /// <summary>
+        /// The target mix id of the effect.
+        /// </summary>
+        public int MixId;
+
+        /// <summary>
+        /// Position of the effect while processing effects.
+        /// </summary>
+        public uint ProcessingOrder;
+
+        /// <summary>
+        /// Array of all the work buffer used by the effect.
+        /// </summary>
+        protected AddressInfo[] WorkBuffers;
+
+        /// <summary>
+        /// Create a new <see cref="BaseEffect"/>.
+        /// </summary>
+        public BaseEffect()
+        {
+            Type = TargetEffectType;
+            UsageState = UsageState.Invalid;
+
+            IsEnabled = false;
+            BufferUnmapped = false;
+            MixId = Constants.UnusedMixId;
+            ProcessingOrder = uint.MaxValue;
+
+            WorkBuffers = new AddressInfo[2];
+
+            foreach (ref AddressInfo info in WorkBuffers.AsSpan())
+            {
+                info = AddressInfo.Create();
+            }
+        }
+
+        /// <summary>
+        /// The target <see cref="EffectType"/> handled by this <see cref="BaseEffect"/>.
+        /// </summary>
+        public virtual EffectType TargetEffectType => EffectType.Invalid;
+
+        /// <summary>
+        /// Check if the <see cref="EffectType"/> sent by the user match the internal <see cref="EffectType"/>.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        /// <returns>Returns true if the <see cref="EffectType"/> sent by the user matches the internal <see cref="EffectType"/>.</returns>
+        public bool IsTypeValid<T>(ref T parameter) where T : unmanaged, IEffectInParameter
+        {
+            return parameter.Type == TargetEffectType;
+        }
+
+        /// <summary>
+        /// Update the usage state during command generation.
+        /// </summary>
+        protected void UpdateUsageStateForCommandGeneration()
+        {
+            UsageState = IsEnabled ? UsageState.Enabled : UsageState.Disabled;
+        }
+
+        /// <summary>
+        /// Update the internal common parameters from a user parameter.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        protected void UpdateParameterBase<T>(ref T parameter) where T : unmanaged, IEffectInParameter
+        {
+            MixId = parameter.MixId;
+            ProcessingOrder = parameter.ProcessingOrder;
+        }
+
+        /// <summary>
+        /// Force unmap all the work buffers.
+        /// </summary>
+        /// <param name="mapper">The mapper to use.</param>
+        public void ForceUnmapBuffers(PoolMapper mapper)
+        {
+            foreach (ref AddressInfo info in WorkBuffers.AsSpan())
+            {
+                if (info.GetReference(false) != 0)
+                {
+                    mapper.ForceUnmap(ref info);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if the effect needs to be skipped.
+        /// </summary>
+        /// <returns>Returns true if the effect needs to be skipped.</returns>
+        public bool ShouldSkip()
+        {
+            return BufferUnmapped;
+        }
+
+        /// <summary>
+        /// Update the <see cref="BaseEffect"/> state during command generation.
+        /// </summary>
+        public virtual void UpdateForCommandGeneration()
+        {
+            Debug.Assert(Type == TargetEffectType);
+        }
+
+        /// <summary>
+        /// Initialize the given <paramref name="state"/> result state.
+        /// </summary>
+        /// <param name="state">The state to initalize</param>
+        public virtual void InitializeResultState(ref EffectResultState state) { }
+
+        /// <summary>
+        /// Update the <paramref name="destState"/> result state with <paramref name="srcState"/>.
+        /// </summary>
+        /// <param name="destState">The destination result state</param>
+        /// <param name="srcState">The source result state</param>
+        public virtual void UpdateResultState(ref EffectResultState destState, ref EffectResultState srcState) { }
+
+        /// <summary>
+        /// Update the internal state from a user version 1 parameter.
+        /// </summary>
+        /// <param name="updateErrorInfo">The possible <see cref="ErrorInfo"/> that was generated.</param>
+        /// <param name="parameter">The user parameter.</param>
+        /// <param name="mapper">The mapper to use.</param>
+        public virtual void Update(out ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            updateErrorInfo = new ErrorInfo();
+        }
+
+        /// <summary>
+        /// Update the internal state from a user version 2 parameter.
+        /// </summary>
+        /// <param name="updateErrorInfo">The possible <see cref="ErrorInfo"/> that was generated.</param>
+        /// <param name="parameter">The user parameter.</param>
+        /// <param name="mapper">The mapper to use.</param>
+        public virtual void Update(out ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            updateErrorInfo = new ErrorInfo();
+        }
+
+        /// <summary>
+        /// Get the work buffer DSP address at the given index.
+        /// </summary>
+        /// <param name="index">The index of the work buffer</param>
+        /// <returns>The work buffer DSP address at the given index.</returns>
+        public virtual DspAddress GetWorkBuffer(int index)
+        {
+            throw new InvalidOperationException();
+        }
+
+        /// <summary>
+        /// Get the first work buffer DSP address.
+        /// </summary>
+        /// <returns>The first work buffer DSP address.</returns>
+        protected DspAddress GetSingleBuffer()
+        {
+            if (IsEnabled)
+            {
+                return WorkBuffers[0].GetReference(true);
+            }
+
+            if (UsageState != UsageState.Disabled)
+            {
+                DspAddress address = WorkBuffers[0].GetReference(false);
+                ulong size = WorkBuffers[0].Size;
+
+                if (address != 0 && size != 0)
+                {
+                    AudioProcessorMemoryManager.InvalidateDataCache(address, size);
+                }
+            }
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Store the output status to the given user output.
+        /// </summary>
+        /// <param name="outStatus">The given user output.</param>
+        /// <param name="isAudioRendererActive">If set to true, the <see cref="AudioRenderSystem"/> is active.</param>
+        public void StoreStatus<T>(ref T outStatus, bool isAudioRendererActive) where T : unmanaged, IEffectOutStatus
+        {
+            if (isAudioRendererActive)
+            {
+                if (UsageState == UsageState.Disabled)
+                {
+                    outStatus.State = EffectState.Disabled;
+                }
+                else
+                {
+                    outStatus.State = EffectState.Enabled;
+                }
+            }
+            else if (UsageState == UsageState.New)
+            {
+                outStatus.State = EffectState.Enabled;
+            }
+            else
+            {
+                outStatus.State = EffectState.Disabled;
+            }
+        }
+
+        /// <summary>
+        /// Get the <see cref="PerformanceDetailType"/> associated to the <see cref="Type"/> of this effect.
+        /// </summary>
+        /// <returns>The <see cref="PerformanceDetailType"/> associated to the <see cref="Type"/> of this effect.</returns>
+        public PerformanceDetailType GetPerformanceDetailType()
+        {
+            switch (Type)
+            {
+                case EffectType.BiquadFilter:
+                    return PerformanceDetailType.BiquadFilter;
+                case EffectType.AuxiliaryBuffer:
+                    return PerformanceDetailType.Aux;
+                case EffectType.Delay:
+                    return PerformanceDetailType.Delay;
+                case EffectType.Reverb:
+                    return PerformanceDetailType.Reverb;
+                case EffectType.Reverb3d:
+                    return PerformanceDetailType.Reverb3d;
+                case EffectType.BufferMix:
+                    return PerformanceDetailType.Mix;
+                case EffectType.Limiter:
+                    return PerformanceDetailType.Limiter;
+                case EffectType.CaptureBuffer:
+                    return PerformanceDetailType.CaptureBuffer;
+                case EffectType.Compressor:
+                    return PerformanceDetailType.Compressor;
+                default:
+                    throw new NotImplementedException($"{Type}");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/BiquadFilterEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/BiquadFilterEffect.cs
new file mode 100644
index 00000000..de91046d
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/BiquadFilterEffect.cs
@@ -0,0 +1,67 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a biquad filter effect.
+    /// </summary>
+    public class BiquadFilterEffect : BaseEffect
+    {
+        /// <summary>
+        /// The biquad filter parameter.
+        /// </summary>
+        public BiquadFilterEffectParameter Parameter;
+
+        /// <summary>
+        /// The biquad filter state.
+        /// </summary>
+        public Memory<BiquadFilterState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="BiquadFilterEffect"/>.
+        /// </summary>
+        public BiquadFilterEffect()
+        {
+            Parameter = new BiquadFilterEffectParameter();
+            State = new BiquadFilterState[Constants.ChannelCountMax];
+        }
+
+        public override EffectType TargetEffectType => EffectType.BiquadFilter;
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, BiquadFilterEffectParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/BufferMixEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/BufferMixEffect.cs
new file mode 100644
index 00000000..82c0a055
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/BufferMixEffect.cs
@@ -0,0 +1,49 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a buffer mix effect.
+    /// </summary>
+    public class BufferMixEffect : BaseEffect
+    {
+        /// <summary>
+        /// The buffer mix parameter.
+        /// </summary>
+        public BufferMixParameter Parameter;
+
+        public override EffectType TargetEffectType => EffectType.BufferMix;
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, BufferMixParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/CaptureBufferEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/CaptureBufferEffect.cs
new file mode 100644
index 00000000..c445798d
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/CaptureBufferEffect.cs
@@ -0,0 +1,82 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using DspAddress = System.UInt64;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for an capture buffer effect.
+    /// </summary>
+    public class CaptureBufferEffect : BaseEffect
+    {
+        /// <summary>
+        /// The capture buffer parameter.
+        /// </summary>
+        public AuxiliaryBufferParameter Parameter;
+
+        /// <summary>
+        /// Capture buffer state.
+        /// </summary>
+        public AuxiliaryBufferAddresses State;
+
+        public override EffectType TargetEffectType => EffectType.CaptureBuffer;
+
+        public override DspAddress GetWorkBuffer(int index)
+        {
+            return WorkBuffers[index].GetReference(true);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, AuxiliaryBufferParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            if (BufferUnmapped || parameter.IsNew)
+            {
+                ulong bufferSize = (ulong)Unsafe.SizeOf<int>() * Parameter.BufferStorageSize + (ulong)Unsafe.SizeOf<AuxiliaryBufferHeader>();
+
+                bool sendBufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], Parameter.SendBufferInfoAddress, bufferSize);
+
+                BufferUnmapped = sendBufferUnmapped;
+
+                if (!BufferUnmapped)
+                {
+                    DspAddress sendDspAddress = WorkBuffers[0].GetReference(false);
+
+                    // NOTE: Nintendo directly interact with the CPU side structure in the processing of the DSP command.
+                    State.SendBufferInfo = sendDspAddress;
+                    State.SendBufferInfoBase = sendDspAddress + (ulong)Unsafe.SizeOf<AuxiliaryBufferHeader>();
+                    State.ReturnBufferInfo = 0;
+                    State.ReturnBufferInfoBase = 0;
+                }
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/CompressorEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/CompressorEffect.cs
new file mode 100644
index 00000000..32162abc
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/CompressorEffect.cs
@@ -0,0 +1,67 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a compressor effect.
+    /// </summary>
+    public class CompressorEffect : BaseEffect
+    {
+        /// <summary>
+        /// The compressor parameter.
+        /// </summary>
+        public CompressorParameter Parameter;
+
+        /// <summary>
+        /// The compressor state.
+        /// </summary>
+        public Memory<CompressorState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="CompressorEffect"/>.
+        /// </summary>
+        public CompressorEffect()
+        {
+            State = new CompressorState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Compressor;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            // Nintendo doesn't do anything here but we still require updateErrorInfo to be initialised.
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, CompressorParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/DelayEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/DelayEffect.cs
new file mode 100644
index 00000000..3f5d70bc
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/DelayEffect.cs
@@ -0,0 +1,93 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using DspAddress = System.UInt64;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a delay effect.
+    /// </summary>
+    public class DelayEffect : BaseEffect
+    {
+        /// <summary>
+        /// The delay parameter.
+        /// </summary>
+        public DelayParameter Parameter;
+
+        /// <summary>
+        /// The delay state.
+        /// </summary>
+        public Memory<DelayState> State { get; }
+
+        public DelayEffect()
+        {
+            State = new DelayState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Delay;
+
+        public override DspAddress GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref DelayParameter delayParameter = ref MemoryMarshal.Cast<byte, DelayParameter>(parameter.SpecificData)[0];
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            if (delayParameter.IsChannelCountMaxValid())
+            {
+                UpdateParameterBase(ref parameter);
+
+                UsageState oldParameterStatus = Parameter.Status;
+
+                Parameter = delayParameter;
+
+                if (delayParameter.IsChannelCountValid())
+                {
+                    IsEnabled = parameter.IsEnabled;
+
+                    if (oldParameterStatus != UsageState.Enabled)
+                    {
+                        Parameter.Status = oldParameterStatus;
+                    }
+
+                    if (BufferUnmapped || parameter.IsNew)
+                    {
+                        UsageState = UsageState.New;
+                        Parameter.Status = UsageState.Invalid;
+
+                        BufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], parameter.BufferBase, parameter.BufferSize);
+                    }
+                }
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/EffectContext.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/EffectContext.cs
new file mode 100644
index 00000000..bfb6528b
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/EffectContext.cs
@@ -0,0 +1,123 @@
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Utils;
+using System;
+using System.Diagnostics;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Effect context.
+    /// </summary>
+    public class EffectContext
+    {
+        /// <summary>
+        /// Storage for <see cref="BaseEffect"/>.
+        /// </summary>
+        private BaseEffect[] _effects;
+
+        /// <summary>
+        /// The total effect count.
+        /// </summary>
+        private uint _effectCount;
+
+        private EffectResultState[] _resultStatesCpu;
+        private EffectResultState[] _resultStatesDsp;
+
+        /// <summary>
+        /// Create a new <see cref="EffectContext"/>.
+        /// </summary>
+        public EffectContext()
+        {
+            _effects = null;
+            _effectCount = 0;
+        }
+
+        /// <summary>
+        /// Initialize the <see cref="EffectContext"/>.
+        /// </summary>
+        /// <param name="effectCount">The total effect count.</param>
+        /// <param name="resultStateCount">The total result state count.</param>
+        public void Initialize(uint effectCount, uint resultStateCount)
+        {
+            _effectCount = effectCount;
+            _effects = new BaseEffect[effectCount];
+
+            for (int i = 0; i < _effectCount; i++)
+            {
+                _effects[i] = new BaseEffect();
+            }
+
+            _resultStatesCpu = new EffectResultState[resultStateCount];
+            _resultStatesDsp = new EffectResultState[resultStateCount];
+        }
+
+        /// <summary>
+        /// Get the total effect count.
+        /// </summary>
+        /// <returns>The total effect count.</returns>
+        public uint GetCount()
+        {
+            return _effectCount;
+        }
+
+        /// <summary>
+        /// Get a reference to a <see cref="BaseEffect"/> at the given <paramref name="index"/>.
+        /// </summary>
+        /// <param name="index">The index to use.</param>
+        /// <returns>A reference to a <see cref="BaseEffect"/> at the given <paramref name="index"/>.</returns>
+        public ref BaseEffect GetEffect(int index)
+        {
+            Debug.Assert(index >= 0 && index < _effectCount);
+
+            return ref _effects[index];
+        }
+
+        /// <summary>
+        /// Get a reference to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.
+        /// </summary>
+        /// <param name="index">The index to use.</param>
+        /// <returns>A reference to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.</returns>
+        /// <remarks>The returned <see cref="EffectResultState"/> should only be used when updating the server state.</remarks>
+        public ref EffectResultState GetState(int index)
+        {
+            Debug.Assert(index >= 0 && index < _resultStatesCpu.Length);
+
+            return ref _resultStatesCpu[index];
+        }
+
+        /// <summary>
+        /// Get a reference to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.
+        /// </summary>
+        /// <param name="index">The index to use.</param>
+        /// <returns>A reference to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.</returns>
+        /// <remarks>The returned <see cref="EffectResultState"/> should only be used in the context of processing on the <see cref="Dsp.AudioProcessor"/>.</remarks>
+        public ref EffectResultState GetDspState(int index)
+        {
+            Debug.Assert(index >= 0 && index < _resultStatesDsp.Length);
+
+            return ref _resultStatesDsp[index];
+        }
+
+        /// <summary>
+        /// Get a memory instance to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.
+        /// </summary>
+        /// <param name="index">The index to use.</param>
+        /// <returns>A memory instance to a <see cref="EffectResultState"/> at the given <paramref name="index"/>.</returns>
+        /// <remarks>The returned <see cref="Memory{EffectResultState}"/> should only be used in the context of processing on the <see cref="Dsp.AudioProcessor"/>.</remarks>
+        public Memory<EffectResultState> GetDspStateMemory(int index)
+        {
+            return SpanIOHelper.GetMemory(_resultStatesDsp.AsMemory(), index, (uint)_resultStatesDsp.Length);
+        }
+
+        /// <summary>
+        /// Update internal state during command generation.
+        /// </summary>
+        public void UpdateResultStateForCommandGeneration()
+        {
+            for (int index = 0; index < _resultStatesCpu.Length; index++)
+            {
+                _effects[index].UpdateResultState(ref _resultStatesCpu[index], ref _resultStatesDsp[index]);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/LimiterEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/LimiterEffect.cs
new file mode 100644
index 00000000..6e17ef3d
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/LimiterEffect.cs
@@ -0,0 +1,95 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a limiter effect.
+    /// </summary>
+    public class LimiterEffect : BaseEffect
+    {
+        /// <summary>
+        /// The limiter parameter.
+        /// </summary>
+        public LimiterParameter Parameter;
+
+        /// <summary>
+        /// The limiter state.
+        /// </summary>
+        public Memory<LimiterState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="LimiterEffect"/>.
+        /// </summary>
+        public LimiterEffect()
+        {
+            State = new LimiterState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Limiter;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref LimiterParameter limiterParameter = ref MemoryMarshal.Cast<byte, LimiterParameter>(parameter.SpecificData)[0];
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = limiterParameter;
+
+            IsEnabled = parameter.IsEnabled;
+
+            if (BufferUnmapped || parameter.IsNew)
+            {
+                UsageState = UsageState.New;
+                Parameter.Status = UsageState.Invalid;
+
+                BufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], parameter.BufferBase, parameter.BufferSize);
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+            Parameter.StatisticsReset = false;
+        }
+
+        public override void InitializeResultState(ref EffectResultState state)
+        {
+            ref LimiterStatistics statistics = ref MemoryMarshal.Cast<byte, LimiterStatistics>(state.SpecificData)[0];
+
+            statistics.Reset();
+        }
+
+        public override void UpdateResultState(ref EffectResultState destState, ref EffectResultState srcState)
+        {
+            destState = srcState;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/Reverb3dEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/Reverb3dEffect.cs
new file mode 100644
index 00000000..473fddb8
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/Reverb3dEffect.cs
@@ -0,0 +1,92 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a 3D reverberation effect.
+    /// </summary>
+    public class Reverb3dEffect : BaseEffect
+    {
+        /// <summary>
+        /// The 3D reverberation parameter.
+        /// </summary>
+        public Reverb3dParameter Parameter;
+
+        /// <summary>
+        /// The 3D reverberation state.
+        /// </summary>
+        public Memory<Reverb3dState> State { get; }
+
+        public Reverb3dEffect()
+        {
+            State = new Reverb3dState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Reverb3d;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref Reverb3dParameter reverbParameter = ref MemoryMarshal.Cast<byte, Reverb3dParameter>(parameter.SpecificData)[0];
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            if (reverbParameter.IsChannelCountMaxValid())
+            {
+                UpdateParameterBase(ref parameter);
+
+                UsageState oldParameterStatus = Parameter.ParameterStatus;
+
+                Parameter = reverbParameter;
+
+                if (reverbParameter.IsChannelCountValid())
+                {
+                    IsEnabled = parameter.IsEnabled;
+
+                    if (oldParameterStatus != UsageState.Enabled)
+                    {
+                        Parameter.ParameterStatus = oldParameterStatus;
+                    }
+
+                    if (BufferUnmapped || parameter.IsNew)
+                    {
+                        UsageState = UsageState.New;
+                        Parameter.ParameterStatus = UsageState.Invalid;
+
+                        BufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], parameter.BufferBase, parameter.BufferSize);
+                    }
+                }
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.ParameterStatus = UsageState.Enabled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/ReverbEffect.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/ReverbEffect.cs
new file mode 100644
index 00000000..e1543fd1
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/ReverbEffect.cs
@@ -0,0 +1,95 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a reverberation effect.
+    /// </summary>
+    public class ReverbEffect : BaseEffect
+    {
+        /// <summary>
+        /// The reverberation parameter.
+        /// </summary>
+        public ReverbParameter Parameter;
+
+        /// <summary>
+        /// The reverberation state.
+        /// </summary>
+        public Memory<ReverbState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="ReverbEffect"/>.
+        /// </summary>
+        public ReverbEffect()
+        {
+            State = new ReverbState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Reverb;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Update(out updateErrorInfo, ref parameter, mapper);
+        }
+
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            ref ReverbParameter reverbParameter = ref MemoryMarshal.Cast<byte, ReverbParameter>(parameter.SpecificData)[0];
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+
+            if (reverbParameter.IsChannelCountMaxValid())
+            {
+                UpdateParameterBase(ref parameter);
+
+                UsageState oldParameterStatus = Parameter.Status;
+
+                Parameter = reverbParameter;
+
+                if (reverbParameter.IsChannelCountValid())
+                {
+                    IsEnabled = parameter.IsEnabled;
+
+                    if (oldParameterStatus != UsageState.Enabled)
+                    {
+                        Parameter.Status = oldParameterStatus;
+                    }
+
+                    if (BufferUnmapped || parameter.IsNew)
+                    {
+                        UsageState = UsageState.New;
+                        Parameter.Status = UsageState.Invalid;
+
+                        BufferUnmapped = !mapper.TryAttachBuffer(out updateErrorInfo, ref WorkBuffers[0], parameter.BufferBase, parameter.BufferSize);
+                    }
+                }
+            }
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.Audio/Renderer/Server/Effect/UsageState.cs b/src/Ryujinx.Audio/Renderer/Server/Effect/UsageState.cs
new file mode 100644
index 00000000..8648aa2c
--- /dev/null
+++ b/src/Ryujinx.Audio/Renderer/Server/Effect/UsageState.cs
@@ -0,0 +1,28 @@
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// The usage state of an effect.
+    /// </summary>
+    public enum UsageState : byte
+    {
+        /// <summary>
+        /// The effect is in an invalid state.
+        /// </summary>
+        Invalid,
+
+        /// <summary>
+        /// The effect is new.
+        /// </summary>
+        New,
+
+        /// <summary>
+        /// The effect is enabled.
+        /// </summary>
+        Enabled,
+
+        /// <summary>
+        /// The effect is disabled.
+        /// </summary>
+        Disabled
+    }
+}
\ No newline at end of file