idea: Catch HorizonResultExceptions of result type ResultFsNonRealDataVerificationFailed

- log a more clear error message as to what 2002-4604 means for the user
- and return the result from the FileSystemProxy IStorage to pass the invalid data handling to the game instead of stopping emulation there and then.
  - this may be changed. i'm pretty sure this error is only thrown when you actually have integrity checking enabled in settings, so maybe it crashing with a friendler message is more desired than potentially continuing execution. we will see

Directory.Packages.props

@@ -3,25 +3,25 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="Avalonia" Version="11.0.13" />
-    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="11.0.13" />
-    <PackageVersion Include="Avalonia.Desktop" Version="11.0.13" />
-    <PackageVersion Include="Avalonia.Diagnostics" Version="11.0.13" />
-    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="11.0.13" />
-    <PackageVersion Include="Avalonia.Svg" Version="11.0.0.19" />
-    <PackageVersion Include="Avalonia.Svg.Skia" Version="11.0.0.19" />
+    <PackageVersion Include="Avalonia" Version="11.3.6" />
+    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="11.3.6" />
+    <PackageVersion Include="Avalonia.Desktop" Version="11.3.6" />
+    <PackageVersion Include="Avalonia.Diagnostics" Version="11.3.6" />
+    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="11.3.6" />
+    <PackageVersion Include="Svg.Controls.Avalonia" Version="11.3.6.2" />
+    <PackageVersion Include="Svg.Controls.Skia.Avalonia" Version="11.3.6.2" />
     <PackageVersion Include="Microsoft.Build.Framework" Version="17.11.4" />
     <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="17.12.6" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageVersion Include="Projektanker.Icons.Avalonia" Version="9.4.0" />
-    <PackageVersion Include="Projektanker.Icons.Avalonia.FontAwesome" Version="9.4.0"/>
-    <PackageVersion Include="Projektanker.Icons.Avalonia.MaterialDesign" Version="9.4.0"/>
+    <PackageVersion Include="Projektanker.Icons.Avalonia" Version="9.6.2" />
+    <PackageVersion Include="Projektanker.Icons.Avalonia.FontAwesome" Version="9.6.2" />
+    <PackageVersion Include="Projektanker.Icons.Avalonia.MaterialDesign" Version="9.6.2" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
-    <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.0"/>
+    <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageVersion Include="Concentus" Version="2.2.2" />
     <PackageVersion Include="DiscordRichPresence" Version="1.6.1.70" />
     <PackageVersion Include="DynamicData" Version="9.4.1" />
-    <PackageVersion Include="FluentAvaloniaUI" Version="2.0.5" />
+    <PackageVersion Include="FluentAvaloniaUI.NoAnim" Version="2.4.0-build3" />
     <PackageVersion Include="Humanizer" Version="2.14.1" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
@@ -40,11 +40,11 @@
     <PackageVersion Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies.AllArch" Version="6.1.2-build3" />
     <PackageVersion Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" />
-    <PackageVersion Include="Ryujinx.LibHac" Version="0.21.0-alpha.117" />
+    <PackageVersion Include="Ryujinx.LibHac" Version="0.21.0-alpha.126" />
     <PackageVersion Include="Ryujinx.SDL2-CS" Version="2.30.0-build32" />
     <PackageVersion Include="Ryujinx.UpdateClient" Version="1.0.44" />
     <PackageVersion Include="Ryujinx.Systems.Update.Common" Version="1.0.44" />
-    <PackageVersion Include="Gommon" Version="2.7.2.1" />
+    <PackageVersion Include="Gommon" Version="2.8.0.1" />
     <PackageVersion Include="securifybv.ShellLink" Version="0.1.0" />
     <PackageVersion Include="Sep" Version="0.11.1" />
     <PackageVersion Include="shaderc.net" Version="0.1.0" />
@@ -59,4 +59,4 @@
     <PackageVersion Include="System.Management" Version="9.0.2" />
     <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
   </ItemGroup>
-</Project>
+</Project>

distribution/macos/Info.plist

@@ -34,7 +34,7 @@
     <key>CFBundleInfoDictionaryVersion</key>
     <string>6.0</string>
     <key>CFBundleLongVersionString</key>
-    <string>%%RYUJINX_BUILD_VERSION%%-%%RYUJINX_BUILD_GIT_HASH%%"</string>
+    <string>%%RYUJINX_BUILD_VERSION%%-%%RYUJINX_BUILD_GIT_HASH%%</string>
     <key>CFBundleName</key>
     <string>Ryujinx</string>
     <key>CFBundlePackageType</key>
@@ -44,13 +44,13 @@
     <key>CFBundleSignature</key>
     <string>????</string>
     <key>CFBundleVersion</key>
-    <string>1.2.0</string>
+    <string>%%RYUJINX_BUILD_VERSION%%</string>
     <key>NSHighResolutionCapable</key>
     <true/>
     <key>CSResourcesFileMapped</key>
     <true/>
     <key>NSHumanReadableCopyright</key>
-    <string>Copyright © 2018 - 2023 Ryujinx Team and Contributors.</string>
+    <string>Copyright © 2018 - 2024 Ryujinx Team and Contributors. Copyright © 2024 - 2025 Ryubing and Contributors.</string>
     <key>LSApplicationCategoryType</key>
     <string>public.app-category.games</string>
     <key>LSMinimumSystemVersion</key>

src/ARMeilleure/CodeGen/X86/Assembler.cs

@@ -1107,17 +1107,17 @@ namespace ARMeilleure.CodeGen.X86
             }
             else
             {
-                if (flags.HasFlag(InstructionFlags.Prefix66))
+                if ((flags & InstructionFlags.Prefix66) != 0)
                 {
                     WriteByte(0x66);
                 }
 
-                if (flags.HasFlag(InstructionFlags.PrefixF2))
+                if ((flags & InstructionFlags.PrefixF2) != 0f)
                 {
                     WriteByte(0xf2);
                 }
 
-                if (flags.HasFlag(InstructionFlags.PrefixF3))
+                if ((flags & InstructionFlags.PrefixF3) != 0f)
                 {
                     WriteByte(0xf3);
                 }

src/ARMeilleure/CodeGen/X86/AssemblerTable.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace ARMeilleure.CodeGen.X86
 {

src/ARMeilleure/CodeGen/X86/CodeGenContext.cs

@@ -2,7 +2,6 @@ using ARMeilleure.CodeGen.RegisterAllocators;
 using ARMeilleure.IntermediateRepresentation;
 using Microsoft.IO;
 using Ryujinx.Common.Memory;
-using System.IO;
 using System.Numerics;
 
 namespace ARMeilleure.CodeGen.X86

src/ARMeilleure/CodeGen/X86/X86Register.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace ARMeilleure.CodeGen.X86
 {
     enum X86Register

src/ARMeilleure/Instructions/InstEmitMul.cs

@@ -2,7 +2,6 @@ using ARMeilleure.Decoders;
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.Translation;
 using System;
-using System.Diagnostics.CodeAnalysis;
 using static ARMeilleure.Instructions.InstEmitHelper;
 
 namespace ARMeilleure.Instructions

src/ARMeilleure/IntermediateRepresentation/Intrinsic.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace ARMeilleure.IntermediateRepresentation
 {

src/Ryujinx.Audio/Renderer/Dsp/Command/AdpcmDataSourceCommandVersion1.cs

@@ -11,27 +11,32 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.AdpcmDataSourceVersion1;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort OutputBufferIndex { get; }
-        public uint SampleRate { get; }
+        public ushort OutputBufferIndex { get; private set; }
+        public uint SampleRate { get; private set; }
 
-        public float Pitch { get; }
+        public float Pitch { get; private set; }
 
         public WaveBuffer[] WaveBuffers { get; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public ulong AdpcmParameter { get; }
-        public ulong AdpcmParameterSize { get; }
+        public ulong AdpcmParameter { get; private set; }
+        public ulong AdpcmParameterSize { get; private set; }
 
-        public DecodingBehaviour DecodingBehaviour { get; }
+        public DecodingBehaviour DecodingBehaviour { get; private set; }
 
-        public AdpcmDataSourceCommandVersion1(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, int nodeId)
+        public AdpcmDataSourceCommandVersion1()
+        {
+            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
+        }
+
+        public AdpcmDataSourceCommandVersion1 Initialize(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -42,8 +47,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             
             Span<Server.Voice.WaveBuffer> waveBufferSpan = serverInfo.WaveBuffers.AsSpan();
 
-            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
-
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
                 ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
@@ -55,6 +58,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             AdpcmParameterSize = serverInfo.DataSourceStateAddressInfo.Size;
             State = state;
             DecodingBehaviour = serverInfo.DecodingBehaviour;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/AuxiliaryBufferCommand.cs

@@ -12,26 +12,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.AuxiliaryBuffer;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint InputBufferIndex { get; }
-        public uint OutputBufferIndex { get; }
+        public uint InputBufferIndex { get; private set; }
+        public uint OutputBufferIndex { get; private set; }
 
-        public AuxiliaryBufferAddresses BufferInfo { get; }
+        public AuxiliaryBufferAddresses BufferInfo { get; private set; }
 
-        public CpuAddress InputBuffer { get; }
-        public CpuAddress OutputBuffer { get; }
-        public uint CountMax { get; }
-        public uint UpdateCount { get; }
-        public uint WriteOffset { get; }
+        public CpuAddress InputBuffer { get; private set; }
+        public CpuAddress OutputBuffer { get; private set; }
+        public uint CountMax { get; private set; }
+        public uint UpdateCount { get; private set; }
+        public uint WriteOffset { get; private set; }
 
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
-        public AuxiliaryBufferCommand(
+        public AuxiliaryBufferCommand()
+        {
+            
+        }
+        
+        public AuxiliaryBufferCommand Initialize(
             uint bufferOffset,
             byte inputBufferOffset,
             byte outputBufferOffset,
@@ -55,6 +60,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             UpdateCount = updateCount;
             WriteOffset = writeOffset;
             IsEffectEnabled = isEnabled;
+            
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/BiquadFilterAndMixCommand.cs

@@ -9,32 +9,37 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.BiquadFilterAndMix;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
         private BiquadFilterParameter2 _parameter;
 
-        public Memory<BiquadFilterState> BiquadFilterState { get; }
-        public Memory<BiquadFilterState> PreviousBiquadFilterState { get; }
+        public Memory<BiquadFilterState> BiquadFilterState { get; private set; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState { get; private set; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public int LastSampleIndex { get; }
+        public int LastSampleIndex { get; private set; }
 
-        public float Volume0 { get; }
-        public float Volume1 { get; }
+        public float Volume0 { get; private set; }
+        public float Volume1 { get; private set; }
 
-        public bool NeedInitialization { get; }
-        public bool HasVolumeRamp { get; }
-        public bool IsFirstMixBuffer { get; }
+        public bool NeedInitialization { get; private set; }
+        public bool HasVolumeRamp { get; private set; }
+        public bool IsFirstMixBuffer { get; private set; }
 
-        public BiquadFilterAndMixCommand(
+        public BiquadFilterAndMixCommand()
+        {
+            
+        }
+
+        public BiquadFilterAndMixCommand Initialize(
             float volume0,
             float volume1,
             uint inputBufferIndex,
@@ -68,6 +73,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             NeedInitialization = needInitialization;
             HasVolumeRamp = hasVolumeRamp;
             IsFirstMixBuffer = isFirstMixBuffer;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/BiquadFilterCommand.cs

@@ -8,20 +8,25 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.BiquadFilter;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public Memory<BiquadFilterState> BiquadFilterState { get; }
-        public int InputBufferIndex { get; }
-        public int OutputBufferIndex { get; }
-        public bool NeedInitialization { get; }
+        public Memory<BiquadFilterState> BiquadFilterState { get; private set; }
+        public int InputBufferIndex { get; private set; }
+        public int OutputBufferIndex { get; private set; }
+        public bool NeedInitialization { get; private set; }
 
         private BiquadFilterParameter2 _parameter;
 
-        public BiquadFilterCommand(
+        public BiquadFilterCommand()
+        {
+            
+        }
+
+        public BiquadFilterCommand Initialize(
             int baseIndex,
             ref BiquadFilterParameter2 filter,
             Memory<BiquadFilterState> biquadFilterStateMemory,
@@ -38,6 +43,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             Enabled = true;
             NodeId = nodeId;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/CaptureBufferCommand.cs

@@ -12,25 +12,30 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.CaptureBuffer;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint InputBufferIndex { get; }
+        public uint InputBufferIndex { get; private set; }
 
-        public ulong CpuBufferInfoAddress { get; }
-        public ulong DspBufferInfoAddress { get; }
+        public ulong CpuBufferInfoAddress { get; private set; }
+        public ulong DspBufferInfoAddress { get; private set; }
 
-        public CpuAddress OutputBuffer { get; }
-        public uint CountMax { get; }
-        public uint UpdateCount { get; }
-        public uint WriteOffset { get; }
+        public CpuAddress OutputBuffer { get; private set; }
+        public uint CountMax { get; private set; }
+        public uint UpdateCount { get; private set; }
+        public uint WriteOffset { get; private set; }
 
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
-        public CaptureBufferCommand(uint bufferOffset, byte inputBufferOffset, ulong sendBufferInfo, bool isEnabled,
+        public CaptureBufferCommand()
+        {
+            
+        }
+        
+        public CaptureBufferCommand Initialize(uint bufferOffset, byte inputBufferOffset, ulong sendBufferInfo, bool isEnabled,
                                     uint countMax, CpuAddress outputBuffer, uint updateCount, uint writeOffset, int nodeId)
         {
             Enabled = true;
@@ -43,6 +48,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             UpdateCount = updateCount;
             WriteOffset = writeOffset;
             IsEffectEnabled = isEnabled;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/CircularBufferSinkCommand.cs

@@ -9,25 +9,29 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.CircularBufferSink;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public ushort[] Input { get; }
-        public uint InputCount { get; }
+        public uint InputCount { get; private set; }
 
-        public ulong CircularBuffer { get; }
-        public ulong CircularBufferSize { get; }
-        public ulong CurrentOffset { get; }
+        public ulong CircularBuffer { get; private set; }
+        public ulong CircularBufferSize { get; private set; }
+        public ulong CurrentOffset { get; private set; }
 
-        public CircularBufferSinkCommand(uint bufferOffset, ref CircularBufferParameter parameter, ref AddressInfo circularBufferAddressInfo, uint currentOffset, int nodeId)
+        public CircularBufferSinkCommand()
+        {
+            Input = new ushort[Constants.ChannelCountMax];
+        }
+        
+        public CircularBufferSinkCommand Initialize(uint bufferOffset, ref CircularBufferParameter parameter, ref AddressInfo circularBufferAddressInfo, uint currentOffset, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
 
-            Input = new ushort[Constants.ChannelCountMax];
             InputCount = parameter.InputCount;
             
             Span<byte> inputSpan = parameter.Input.AsSpan();
@@ -42,6 +46,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             CurrentOffset = currentOffset;
 
             Debug.Assert(CircularBuffer != 0);
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/ClearMixBufferCommand.cs

@@ -4,16 +4,23 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.ClearMixBuffer;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ClearMixBufferCommand(int nodeId)
+        public ClearMixBufferCommand()
+        {
+            
+        }
+
+        public ClearMixBufferCommand Initialize(int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/CommandList.cs

@@ -20,6 +20,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         public Memory<float> Buffers { get; }
         public uint BufferCount { get; }
 
+        private readonly static ObjectPool<List<ICommand>> CommandsListPool = new(() => new List<ICommand>(256));
         public List<ICommand> Commands { get; }
 
         public IVirtualMemoryManager MemoryManager { get; }
@@ -46,7 +47,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             SampleRate = sampleRate;
             BufferCount = mixBufferCount + voiceChannelCountMax;
             Buffers = mixBuffer;
-            Commands = [];
+            Commands = CommandsListPool.Allocate();
             MemoryManager = memoryManager;
 
             _buffersEntryCount = Buffers.Length;
@@ -142,6 +143,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                         }
                     }
                 }
+                
+                CommandBuffer.ReleaseCommand(command);
             }
 
             EndTime = (ulong)PerformanceCounter.ElapsedNanoseconds;
@@ -149,6 +152,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public void Dispose()
         {
+            Commands.Clear();
+            CommandsListPool.Release(Commands);
             GC.SuppressFinalize(this);
             _buffersMemoryHandle.Dispose();
         }

src/Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs

@@ -15,22 +15,28 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Compressor;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public CompressorParameter Parameter => _parameter;
-        public Memory<CompressorState> State { get; }
-        public Memory<EffectResultState> ResultState { get; }
+        public Memory<CompressorState> State { get; private set; }
+        public Memory<EffectResultState> ResultState { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private CompressorParameter _parameter;
 
-        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, Memory<EffectResultState> resultState, bool isEnabled, int nodeId)
+        public CompressorCommand()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+
+        public CompressorCommand Initialize(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, Memory<EffectResultState> resultState, bool isEnabled, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -39,9 +45,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ResultState = resultState;
 
             IsEffectEnabled = isEnabled;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
             Span<byte> inputSpan = _parameter.Input.AsSpan();
             Span<byte> outputSpan = _parameter.Output.AsSpan();
@@ -51,6 +54,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                 InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
                 OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/CopyMixBufferCommand.cs

@@ -4,22 +4,29 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.CopyMixBuffer;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
-        public CopyMixBufferCommand(uint inputBufferIndex, uint outputBufferIndex, int nodeId)
+        public CopyMixBufferCommand()
+        {
+            
+        }
+
+        public CopyMixBufferCommand Initialize(uint inputBufferIndex, uint outputBufferIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
 
             InputBufferIndex = (ushort)inputBufferIndex;
             OutputBufferIndex = (ushort)outputBufferIndex;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/DataSourceVersion2Command.cs

@@ -11,35 +11,40 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
-        public CommandType CommandType { get; }
+        public CommandType CommandType { get; private set; }
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort OutputBufferIndex { get; }
-        public uint SampleRate { get; }
+        public ushort OutputBufferIndex { get; private set; }
+        public uint SampleRate { get; private set; }
 
-        public float Pitch { get; }
+        public float Pitch { get; private set; }
 
         public WaveBuffer[] WaveBuffers { get; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public ulong ExtraParameter { get; }
-        public ulong ExtraParameterSize { get; }
+        public ulong ExtraParameter { get; private set; }
+        public ulong ExtraParameterSize { get; private set; }
 
-        public uint ChannelIndex { get; }
+        public uint ChannelIndex { get; private set; }
 
-        public uint ChannelCount { get; }
+        public uint ChannelCount { get; private set; }
 
-        public DecodingBehaviour DecodingBehaviour { get; }
+        public DecodingBehaviour DecodingBehaviour { get; private set; }
 
-        public SampleFormat SampleFormat { get; }
+        public SampleFormat SampleFormat { get; private set; }
 
-        public SampleRateConversionQuality SrcQuality { get; }
+        public SampleRateConversionQuality SrcQuality { get; private set; }
 
-        public DataSourceVersion2Command(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
+        public DataSourceVersion2Command()
+        {
+            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
+        }
+
+        public DataSourceVersion2Command Initialize(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -55,8 +60,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             
             Span<Server.Voice.WaveBuffer> waveBufferSpan = serverInfo.WaveBuffers.AsSpan();
 
-            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
-
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
                 ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
@@ -72,6 +75,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             State = state;
             DecodingBehaviour = serverInfo.DecodingBehaviour;
+
+            return this;
         }
 
         private static CommandType GetCommandTypeBySampleFormat(SampleFormat sampleFormat)

src/Ryujinx.Audio/Renderer/Dsp/Command/DelayCommand.cs

@@ -13,24 +13,30 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Delay;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public DelayParameter Parameter => _parameter;
-        public Memory<DelayState> State { get; }
-        public ulong WorkBuffer { get; }
+        public Memory<DelayState> State { get; private set; }
+        public ulong WorkBuffer { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private DelayParameter _parameter;
 
         private const int FixedPointPrecision = 14;
 
-        public DelayCommand(uint bufferOffset, DelayParameter parameter, Memory<DelayState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
+        public DelayCommand()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+
+        public DelayCommand Initialize(uint bufferOffset, DelayParameter parameter, Memory<DelayState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -39,9 +45,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             WorkBuffer = workBuffer;
 
             IsEffectEnabled = isEnabled;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
             Span<byte> inputSpan = Parameter.Input.AsSpan();
             Span<byte> outputSpan = Parameter.Output.AsSpan();
@@ -54,6 +57,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             DataSourceHelper.RemapLegacyChannelEffectMappingToChannelResourceMapping(newEffectChannelMappingSupported, InputBufferIndices, Parameter.ChannelCount);
             DataSourceHelper.RemapLegacyChannelEffectMappingToChannelResourceMapping(newEffectChannelMappingSupported, OutputBufferIndices, Parameter.ChannelCount);
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]

src/Ryujinx.Audio/Renderer/Dsp/Command/DepopForMixBuffersCommand.cs

@@ -7,21 +7,26 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.DepopForMixBuffers;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint MixBufferOffset { get; }
+        public uint MixBufferOffset { get; private set; }
 
-        public uint MixBufferCount { get; }
+        public uint MixBufferCount { get; private set; }
 
-        public float Decay { get; }
+        public float Decay { get; private set; }
 
-        public Memory<float> DepopBuffer { get; }
+        public Memory<float> DepopBuffer { get; private set; }
 
-        public DepopForMixBuffersCommand(Memory<float> depopBuffer, uint bufferOffset, uint mixBufferCount, int nodeId, uint sampleRate)
+        public DepopForMixBuffersCommand()
+        {
+            
+        }
+
+        public DepopForMixBuffersCommand Initialize(Memory<float> depopBuffer, uint bufferOffset, uint mixBufferCount, int nodeId, uint sampleRate)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -37,6 +42,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             {
                 Decay = 0.943695f;
             }
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/DepopPrepareCommand.cs

@@ -7,27 +7,30 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.DepopPrepare;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint MixBufferCount { get; }
+        public uint MixBufferCount { get; private set; }
 
         public ushort[] OutputBufferIndices { get; }
 
-        public Memory<VoiceState> State { get; }
-        public Memory<float> DepopBuffer { get; }
+        public Memory<VoiceState> State { get; private set; }
+        public Memory<float> DepopBuffer { get; private set; }
 
-        public DepopPrepareCommand(Memory<VoiceState> state, Memory<float> depopBuffer, uint mixBufferCount, uint bufferOffset, int nodeId, bool enabled)
+        public DepopPrepareCommand()
+        {
+            OutputBufferIndices = new ushort[Constants.MixBufferCountMax];
+        }
+
+        public DepopPrepareCommand Initialize(Memory<VoiceState> state, Memory<float> depopBuffer, uint mixBufferCount, uint bufferOffset, int nodeId, bool enabled)
         {
             Enabled = enabled;
             NodeId = nodeId;
             MixBufferCount = mixBufferCount;
 
-            OutputBufferIndices = new ushort[Constants.MixBufferCountMax];
-
             for (int i = 0; i < Constants.MixBufferCountMax; i++)
             {
                 OutputBufferIndices[i] = (ushort)(bufferOffset + i);
@@ -35,6 +38,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             State = state;
             DepopBuffer = depopBuffer;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/DeviceSinkCommand.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Audio.Integration;
 using Ryujinx.Audio.Renderer.Server.Sink;
 using System;
+using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Text;
 
@@ -10,27 +11,34 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.DeviceSink;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public string DeviceName { get; }
+        public string DeviceName { get; private set; }
 
-        public int SessionId { get; }
+        public int SessionId { get; private set; }
 
-        public uint InputCount { get; }
-        public ushort[] InputBufferIndices { get; }
+        public uint InputCount { get; private set; }
+        public ushort[] InputBufferIndices { get; private set; }
 
-        public Memory<float> Buffers { get; }
+        public Memory<float> Buffers { get; private set; }
 
-        public DeviceSinkCommand(uint bufferOffset, DeviceSink sink, int sessionId, Memory<float> buffers, int nodeId)
+        public DeviceSinkCommand()
+        {
+            
+        }
+
+        public DeviceSinkCommand Initialize(uint bufferOffset, DeviceSink sink, int sessionId, Memory<float> buffers, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
 
-            DeviceName = Encoding.ASCII.GetString(sink.Parameter.DeviceName).TrimEnd('\0');
+            // Unused and wasting time and memory, re-add if needed
+            // DeviceName = Encoding.ASCII.GetString(sink.Parameter.DeviceName).TrimEnd('\0');
+            
             SessionId = sessionId;
             InputCount = sink.Parameter.InputCount;
             InputBufferIndices = new ushort[InputCount];
@@ -50,6 +58,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             {
                 Buffers = buffers;
             }
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -81,7 +91,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                     inputCount = bufferCount;
                 }
 
-                short[] outputBuffer = new short[inputCount * SampleCount];
+                short[] outputBuffer = ArrayPool<short>.Shared.Rent((int)inputCount * SampleCount);
 
                 for (int i = 0; i < bufferCount; i++)
                 {
@@ -93,7 +103,9 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                     }
                 }
 
-                device.AppendBuffer(outputBuffer, inputCount);
+                device.AppendBuffer(outputBuffer.AsSpan(..((int)inputCount * SampleCount)), inputCount);
+                
+                ArrayPool<short>.Shared.Return(outputBuffer);
             }
             else
             {

src/Ryujinx.Audio/Renderer/Dsp/Command/DownMixSurroundToStereoCommand.cs

@@ -7,7 +7,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.DownMixSurroundToStereo;
 
@@ -16,16 +16,19 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         public ushort[] InputBufferIndices { get; }
         public ushort[] OutputBufferIndices { get; }
 
-        public float[] Coefficients { get; }
+        public float[] Coefficients { get; private set; }
 
-        public DownMixSurroundToStereoCommand(uint bufferOffset, Span<byte> inputBufferOffset, Span<byte> outputBufferOffset, float[] downMixParameter, int nodeId)
+        public DownMixSurroundToStereoCommand()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+
+        public DownMixSurroundToStereoCommand Initialize(uint bufferOffset, Span<byte> inputBufferOffset, Span<byte> outputBufferOffset, float[] downMixParameter, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
 
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-
             for (int i = 0; i < Constants.VoiceChannelCountMax; i++)
             {
                 InputBufferIndices[i] = (ushort)(bufferOffset + inputBufferOffset[i]);
@@ -33,6 +36,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
 
             Coefficients = downMixParameter;
+            
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/FillBufferCommand.cs

@@ -1,5 +1,4 @@
 using Ryujinx.Audio.Renderer.Server.Splitter;
-using System;
 using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Audio.Renderer.Dsp.Command
@@ -8,38 +7,43 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.FillBuffer;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public SplitterDestinationVersion1 Destination1 { get; }
-        public SplitterDestinationVersion2 Destination2 { get; }
-        public bool IsV2 { get; }
-        public int Length { get; }
-        public float Value { get; }
+        public SplitterDestinationVersion1 Destination1 { get; private set; }
+        public SplitterDestinationVersion2 Destination2 { get; private set; }
+        public bool IsV2 { get; private set; }
+        public int Length { get; private set; }
+        public float Value { get; private set; }
 
-        public FillBufferCommand(SplitterDestinationVersion1 destination, int length, float value, int nodeId)
+        public FillBufferCommand()
         {
-            Enabled = true;
-            NodeId = nodeId;
-
-            Destination1 = destination;
-            IsV2 = false;
-            Length = length;
-            Value = value;
+            
         }
         
-        public FillBufferCommand(SplitterDestinationVersion2 destination, int length, float value, int nodeId)
+        public FillBufferCommand Initialize(SplitterDestination destination, int length, float value, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
+
+            if (Unsafe.IsNullRef(ref destination.GetV2RefOrNull()))
+            {
+                Destination1 = destination.GetV1RefOrNull();
+                IsV2 = false;
+            }
+            else
+            {
+                Destination2 = destination.GetV2RefOrNull();
+                IsV2 = true;
+            }
             
-            Destination2 = destination;
-            IsV2 = true;
             Length = length;
             Value = value;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion1.cs

@@ -10,22 +10,28 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.LimiterVersion1;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public LimiterParameter Parameter => _parameter;
-        public Memory<LimiterState> State { get; }
-        public ulong WorkBuffer { get; }
+        public Memory<LimiterState> State { get; private set; }
+        public ulong WorkBuffer { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private LimiterParameter _parameter;
 
-        public LimiterCommandVersion1(uint bufferOffset, LimiterParameter parameter, Memory<LimiterState> state, bool isEnabled, ulong workBuffer, int nodeId)
+        public LimiterCommandVersion1()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+        
+        public LimiterCommandVersion1 Initialize(uint bufferOffset, LimiterParameter parameter, Memory<LimiterState> state, bool isEnabled, ulong workBuffer, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -35,9 +41,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             IsEffectEnabled = isEnabled;
 
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            
             Span<byte> inputSpan = _parameter.Input.AsSpan();
             Span<byte> outputSpan = _parameter.Output.AsSpan();
 
@@ -46,6 +49,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                 InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
                 OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion2.cs

@@ -12,23 +12,29 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.LimiterVersion2;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public LimiterParameter Parameter => _parameter;
-        public Memory<LimiterState> State { get; }
-        public Memory<EffectResultState> ResultState { get; }
-        public ulong WorkBuffer { get; }
+        public Memory<LimiterState> State { get; private set; }
+        public Memory<EffectResultState> ResultState { get; private set; }
+        public ulong WorkBuffer { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private LimiterParameter _parameter;
 
-        public LimiterCommandVersion2(
+        public LimiterCommandVersion2()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+        
+        public LimiterCommandVersion2 Initialize(
             uint bufferOffset,
             LimiterParameter parameter,
             Memory<LimiterState> state,
@@ -45,9 +51,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             WorkBuffer = workBuffer;
 
             IsEffectEnabled = isEnabled;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
             Span<byte> inputSpan = _parameter.Input.AsSpan();
             Span<byte> outputSpan = _parameter.Output.AsSpan();
@@ -57,6 +60,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                 InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
                 OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
+            
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/MixCommand.cs

@@ -11,18 +11,23 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Mix;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
-        public float Volume { get; }
+        public float Volume { get; private set; }
 
-        public MixCommand(uint inputBufferIndex, uint outputBufferIndex, int nodeId, float volume)
+        public MixCommand()
+        {
+            
+        }
+        
+        public MixCommand Initialize(uint inputBufferIndex, uint outputBufferIndex, int nodeId, float volume)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -31,6 +36,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             OutputBufferIndex = (ushort)outputBufferIndex;
 
             Volume = volume;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/MixRampCommand.cs

@@ -8,23 +8,28 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.MixRamp;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
-        public float Volume0 { get; }
-        public float Volume1 { get; }
+        public float Volume0 { get; private set; }
+        public float Volume1 { get; private set; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public int LastSampleIndex { get; }
+        public int LastSampleIndex { get; private set; }
 
-        public MixRampCommand(float volume0, float volume1, uint inputBufferIndex, uint outputBufferIndex, int lastSampleIndex, Memory<VoiceState> state, int nodeId)
+        public MixRampCommand()
+        {
+            
+        }
+
+        public MixRampCommand Initialize(float volume0, float volume1, uint inputBufferIndex, uint outputBufferIndex, int lastSampleIndex, Memory<VoiceState> state, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -37,6 +42,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             State = state;
             LastSampleIndex = lastSampleIndex;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/MixRampGroupedCommand.cs

@@ -8,23 +8,28 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.MixRampGrouped;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint MixBufferCount { get; }
+        public uint MixBufferCount { get; private set; }
 
-        public ushort[] InputBufferIndices { get; }
-        public ushort[] OutputBufferIndices { get; }
+        public ushort[] InputBufferIndices { get; private set; }
+        public ushort[] OutputBufferIndices { get; private set; }
 
-        public float[] Volume0 { get; }
-        public float[] Volume1 { get; }
+        public float[] Volume0 { get; private set; }
+        public float[] Volume1 { get; private set; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public MixRampGroupedCommand(
+        public MixRampGroupedCommand()
+        {
+            
+        }
+
+        public MixRampGroupedCommand Initialize(
             uint mixBufferCount,
             uint inputBufferIndex,
             uint outputBufferIndex,
@@ -52,6 +57,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
 
             State = state;
+            
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/MultiTapBiquadFilterAndMixCommand.cs

@@ -9,36 +9,41 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.MultiTapBiquadFilterAndMix;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
         private BiquadFilterParameter2 _parameter0;
         private BiquadFilterParameter2 _parameter1;
 
-        public Memory<BiquadFilterState> BiquadFilterState0 { get; }
-        public Memory<BiquadFilterState> BiquadFilterState1 { get; }
-        public Memory<BiquadFilterState> PreviousBiquadFilterState0 { get; }
-        public Memory<BiquadFilterState> PreviousBiquadFilterState1 { get; }
+        public Memory<BiquadFilterState> BiquadFilterState0 { get; private set; }
+        public Memory<BiquadFilterState> BiquadFilterState1 { get; private set; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState0 { get; private set; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState1 { get; private set; }
 
-        public Memory<VoiceState> State { get; }
+        public Memory<VoiceState> State { get; private set; }
 
-        public int LastSampleIndex { get; }
+        public int LastSampleIndex { get; private set; }
 
-        public float Volume0 { get; }
-        public float Volume1 { get; }
+        public float Volume0 { get; private set; }
+        public float Volume1 { get; private set; }
 
-        public bool NeedInitialization0 { get; }
-        public bool NeedInitialization1 { get; }
-        public bool HasVolumeRamp { get; }
-        public bool IsFirstMixBuffer { get; }
+        public bool NeedInitialization0 { get; private set; }
+        public bool NeedInitialization1 { get; private set; }
+        public bool HasVolumeRamp { get; private set; }
+        public bool IsFirstMixBuffer { get; private set; }
 
-        public MultiTapBiquadFilterAndMixCommand(
+        public MultiTapBiquadFilterAndMixCommand()
+        {
+            
+        }
+
+        public MultiTapBiquadFilterAndMixCommand Initialize(
             float volume0,
             float volume1,
             uint inputBufferIndex,
@@ -80,6 +85,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             NeedInitialization1 = needInitialization1;
             HasVolumeRamp = hasVolumeRamp;
             IsFirstMixBuffer = isFirstMixBuffer;
+
+            return this;
         }
 
         private void UpdateState(Memory<BiquadFilterState> state, Memory<BiquadFilterState> previousState, bool needInitialization)

src/Ryujinx.Audio/Renderer/Dsp/Command/MultiTapBiquadFilterCommand.cs

@@ -8,40 +8,47 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.MultiTapBiquadFilter;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        private readonly BiquadFilterParameter2[] _parameters;
-        private readonly Memory<BiquadFilterState> _biquadFilterStates;
-        private readonly int _inputBufferIndex;
-        private readonly int _outputBufferIndex;
-        private readonly bool[] _isInitialized;
+        public BiquadFilterParameter2[] Parameters { get; private set; }
+        public Memory<BiquadFilterState> BiquadFilterStates { get; private set; }
+        public int InputBufferIndex { get; private set; }
+        public int OutputBufferIndex { get; private set; }
+        public bool[] IsInitialized { get; private set; }
 
-        public MultiTapBiquadFilterCommand(int baseIndex, ReadOnlySpan<BiquadFilterParameter2> filters, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
+        public MultiTapBiquadFilterCommand()
         {
-            _parameters = filters.ToArray();
-            _biquadFilterStates = biquadFilterStateMemory;
-            _inputBufferIndex = baseIndex + inputBufferOffset;
-            _outputBufferIndex = baseIndex + outputBufferOffset;
-            _isInitialized = isInitialized.ToArray();
+            
+        }
+
+        public MultiTapBiquadFilterCommand Initialize(int baseIndex, ReadOnlySpan<BiquadFilterParameter2> filters, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
+        {
+            Parameters = filters.ToArray();
+            BiquadFilterStates = biquadFilterStateMemory;
+            InputBufferIndex = baseIndex + inputBufferOffset;
+            OutputBufferIndex = baseIndex + outputBufferOffset;
+            IsInitialized = isInitialized.ToArray();
 
             Enabled = true;
             NodeId = nodeId;
+            
+            return this;
         }
 
         public void Process(CommandList context)
         {
-            Span<BiquadFilterState> states = _biquadFilterStates.Span;
+            Span<BiquadFilterState> states = BiquadFilterStates.Span;
 
-            ReadOnlySpan<float> inputBuffer = context.GetBuffer(_inputBufferIndex);
-            Span<float> outputBuffer = context.GetBuffer(_outputBufferIndex);
+            ReadOnlySpan<float> inputBuffer = context.GetBuffer(InputBufferIndex);
+            Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);
 
-            for (int i = 0; i < _parameters.Length; i++)
+            for (int i = 0; i < Parameters.Length; i++)
             {
-                if (!_isInitialized[i])
+                if (!IsInitialized[i])
                 {
                     states[i] = new BiquadFilterState();
                 }
@@ -49,13 +56,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             // NOTE: Nintendo only implement single and double biquad filters but no generic path when the command definition suggests it could be done.
             // As such we currently only implement a generic path for simplicity for double biquad.
-            if (_parameters.Length == 1)
+            if (Parameters.Length == 1)
             {
-                BiquadFilterHelper.ProcessBiquadFilter(ref _parameters[0], ref states[0], outputBuffer, inputBuffer, context.SampleCount);
+                BiquadFilterHelper.ProcessBiquadFilter(ref Parameters[0], ref states[0], outputBuffer, inputBuffer, context.SampleCount);
             }
             else
             {
-                BiquadFilterHelper.ProcessBiquadFilter(_parameters, states, outputBuffer, inputBuffer, context.SampleCount);
+                BiquadFilterHelper.ProcessBiquadFilter(Parameters, states, outputBuffer, inputBuffer, context.SampleCount);
             }
         }
     }

src/Ryujinx.Audio/Renderer/Dsp/Command/PcmFloatDataSourceCommandVersion1.cs

@@ -11,26 +11,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.PcmFloatDataSourceVersion1;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort OutputBufferIndex { get; }
-        public uint SampleRate { get; }
-        public uint ChannelIndex { get; }
+        public ushort OutputBufferIndex { get; private set; }
+        public uint SampleRate { get; private set; }
+        public uint ChannelIndex { get; private set; }
 
-        public uint ChannelCount { get; }
+        public uint ChannelCount { get; private set; }
 
-        public float Pitch { get; }
+        public float Pitch { get; private set; }
 
         public WaveBuffer[] WaveBuffers { get; }
 
-        public Memory<VoiceState> State { get; }
-        public DecodingBehaviour DecodingBehaviour { get; }
+        public Memory<VoiceState> State { get; private set; }
+        public DecodingBehaviour DecodingBehaviour { get; private set; }
 
-        public PcmFloatDataSourceCommandVersion1(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
+        public PcmFloatDataSourceCommandVersion1()
+        {
+            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
+        }
+
+        public PcmFloatDataSourceCommandVersion1 Initialize(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -40,8 +45,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ChannelIndex = channelIndex;
             ChannelCount = serverInfo.ChannelsCount;
             Pitch = serverInfo.Pitch;
-
-            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
             
             Span<Server.Voice.WaveBuffer> waveBufferSpan = serverInfo.WaveBuffers.AsSpan();
 
@@ -54,6 +57,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             State = state;
             DecodingBehaviour = serverInfo.DecodingBehaviour;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/PcmInt16DataSourceCommandVersion1.cs

@@ -11,26 +11,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.PcmInt16DataSourceVersion1;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort OutputBufferIndex { get; }
-        public uint SampleRate { get; }
-        public uint ChannelIndex { get; }
+        public ushort OutputBufferIndex { get; private set; }
+        public uint SampleRate { get; private set; }
+        public uint ChannelIndex { get; private set; }
 
-        public uint ChannelCount { get; }
+        public uint ChannelCount { get; private set; }
 
-        public float Pitch { get; }
+        public float Pitch { get; private set; }
 
         public WaveBuffer[] WaveBuffers { get; }
 
-        public Memory<VoiceState> State { get; }
-        public DecodingBehaviour DecodingBehaviour { get; }
+        public Memory<VoiceState> State { get; private set; }
+        public DecodingBehaviour DecodingBehaviour { get; private set; }
 
-        public PcmInt16DataSourceCommandVersion1(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
+        public PcmInt16DataSourceCommandVersion1()
+        {
+            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
+        }
+
+        public PcmInt16DataSourceCommandVersion1 Initialize(ref VoiceInfo serverInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -40,8 +45,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ChannelIndex = channelIndex;
             ChannelCount = serverInfo.ChannelsCount;
             Pitch = serverInfo.Pitch;
-
-            WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
             
             Span<Server.Voice.WaveBuffer> waveBufferSpan = serverInfo.WaveBuffers.AsSpan();
 
@@ -54,6 +57,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             State = state;
             DecodingBehaviour = serverInfo.DecodingBehaviour;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/PerformanceCommand.cs

@@ -13,22 +13,34 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Performance;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public PerformanceEntryAddresses PerformanceEntryAddresses { get; }
+        public PerformanceEntryAddresses PerformanceEntryAddresses { get; private set; }
 
         public Type PerformanceType { get; set; }
 
-        public PerformanceCommand(ref PerformanceEntryAddresses performanceEntryAddresses, Type performanceType, int nodeId)
+        public PerformanceCommand()
         {
+            
+        }
+
+        public PerformanceCommand Initialize(ref PerformanceEntryAddresses performanceEntryAddresses, Type performanceType, int nodeId)
+        {
+            if (PerformanceEntryAddresses is not null)
+            {
+                PerformanceEntryAddresses.PerformanceEntryAddressesPool.Release(PerformanceEntryAddresses);
+            }
+            
             Enabled = true;
             PerformanceEntryAddresses = performanceEntryAddresses;
             PerformanceType = performanceType;
             NodeId = nodeId;
+
+            return this;
         }
 
         public void Process(CommandList context)

src/Ryujinx.Audio/Renderer/Dsp/Command/Reverb3dCommand.cs

@@ -35,26 +35,32 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Reverb3d;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
         public Reverb3dParameter Parameter => _parameter;
-        public Memory<Reverb3dState> State { get; }
-        public ulong WorkBuffer { get; }
+        public Memory<Reverb3dState> State { get; private set; }
+        public ulong WorkBuffer { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
 
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private Reverb3dParameter _parameter;
 
-        public Reverb3dCommand(uint bufferOffset, Reverb3dParameter parameter, Memory<Reverb3dState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
+        public Reverb3dCommand()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+
+        public Reverb3dCommand Initialize(uint bufferOffset, Reverb3dParameter parameter, Memory<Reverb3dState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
         {
             Enabled = true;
             IsEffectEnabled = isEnabled;
@@ -62,9 +68,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             _parameter = parameter;
             State = state;
             WorkBuffer = workBuffer;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
             Span<byte> inputSpan = Parameter.Input.AsSpan();
             Span<byte> outputSpan = Parameter.Output.AsSpan();
@@ -79,6 +82,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             // TODO: Update reverb 3d processing and remove this to use RemapLegacyChannelEffectMappingToChannelResourceMapping.
             DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, InputBufferIndices, Parameter.ChannelCount);
             DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, OutputBufferIndices, Parameter.ChannelCount);
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs

@@ -33,26 +33,32 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Reverb;
 
         public uint EstimatedProcessingTime { get; set; }
 
         public ReverbParameter Parameter => _parameter;
-        public Memory<ReverbState> State { get; }
-        public ulong WorkBuffer { get; }
+        public Memory<ReverbState> State { get; private set; }
+        public ulong WorkBuffer { get; private set; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
-        public bool IsLongSizePreDelaySupported { get; }
+        public bool IsLongSizePreDelaySupported { get; private set; }
 
-        public bool IsEffectEnabled { get; }
+        public bool IsEffectEnabled { get; private set; }
 
         private ReverbParameter _parameter;
 
         private const int FixedPointPrecision = 14;
 
-        public ReverbCommand(uint bufferOffset, ReverbParameter parameter, Memory<ReverbState> state, bool isEnabled, ulong workBuffer, int nodeId, bool isLongSizePreDelaySupported, bool newEffectChannelMappingSupported)
+        public ReverbCommand()
+        {
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+        }
+
+        public ReverbCommand Initialize(uint bufferOffset, ReverbParameter parameter, Memory<ReverbState> state, bool isEnabled, ulong workBuffer, int nodeId, bool isLongSizePreDelaySupported, bool newEffectChannelMappingSupported)
         {
             Enabled = true;
             IsEffectEnabled = isEnabled;
@@ -60,9 +66,6 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             _parameter = parameter;
             State = state;
             WorkBuffer = workBuffer;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
             Span<byte> inputSpan = Parameter.Input.AsSpan();
             Span<byte> outputSpan = Parameter.Output.AsSpan();
@@ -79,6 +82,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             // TODO: Update reverb processing and remove this to use RemapLegacyChannelEffectMappingToChannelResourceMapping.
             DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, InputBufferIndices, Parameter.ChannelCount);
             DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, OutputBufferIndices, Parameter.ChannelCount);
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/UpsampleCommand.cs

@@ -7,22 +7,27 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Upsample;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public uint BufferCount { get; }
-        public uint InputBufferIndex { get; }
-        public uint InputSampleCount { get; }
-        public uint InputSampleRate { get; }
+        public uint BufferCount { get; private set; }
+        public uint InputBufferIndex { get; private set; }
+        public uint InputSampleCount { get; private set; }
+        public uint InputSampleRate { get; private set; }
 
-        public UpsamplerInfo UpsamplerInfo { get; }
+        public UpsamplerInfo UpsamplerInfo { get; private set; }
 
-        public Memory<float> OutBuffer { get; }
+        public Memory<float> OutBuffer { get; private set; }
 
-        public UpsampleCommand(uint bufferOffset, UpsamplerInfo info, uint inputCount, Span<byte> inputBufferOffset, uint bufferCount, uint sampleCount, uint sampleRate, int nodeId)
+        public UpsampleCommand()
+        {
+            
+        }
+
+        public UpsampleCommand Initialize(uint bufferOffset, UpsamplerInfo info, uint inputCount, Span<byte> inputBufferOffset, uint bufferCount, uint sampleCount, uint sampleRate, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -47,6 +52,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
 
             UpsamplerInfo = info;
+
+            return this;
         }
 
         private Span<float> GetBuffer(int index, int sampleCount)

src/Ryujinx.Audio/Renderer/Dsp/Command/VolumeCommand.cs

@@ -11,18 +11,23 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.Volume;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
-        public float Volume { get; }
+        public float Volume { get; private set; }
 
-        public VolumeCommand(float volume, uint bufferIndex, int nodeId)
+        public VolumeCommand()
+        {
+            
+        }
+
+        public VolumeCommand Initialize(float volume, uint bufferIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -31,6 +36,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             OutputBufferIndex = (ushort)bufferIndex;
 
             Volume = volume;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Dsp/Command/VolumeRampCommand.cs

@@ -7,19 +7,24 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
     {
         public bool Enabled { get; set; }
 
-        public int NodeId { get; }
+        public int NodeId { get; private set; }
 
         public CommandType CommandType => CommandType.VolumeRamp;
 
         public uint EstimatedProcessingTime { get; set; }
 
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
+        public ushort InputBufferIndex { get; private set; }
+        public ushort OutputBufferIndex { get; private set; }
 
-        public float Volume0 { get; }
-        public float Volume1 { get; }
+        public float Volume0 { get; private set; }
+        public float Volume1 { get; private set; }
 
-        public VolumeRampCommand(float volume0, float volume1, uint bufferIndex, int nodeId)
+        public VolumeRampCommand()
+        {
+            
+        }
+        
+        public VolumeRampCommand Initialize(float volume0, float volume1, uint bufferIndex, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
@@ -29,6 +34,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             Volume0 = volume0;
             Volume1 = volume1;
+
+            return this;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Ryujinx.Audio/Renderer/Parameter/EffectInParameterVersion3.cs

@@ -1,97 +0,0 @@
-using Ryujinx.Audio.Renderer.Common;
-using Ryujinx.Common.Utilities;
-using System;
-using System.Runtime.InteropServices;
-
-namespace Ryujinx.Audio.Renderer.Parameter
-{
-    /// <summary>
-    /// Input information for an effect version 2. (added with REV9)
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 1)]
-    public struct EffectInParameterVersion3 : IEffectInParameter
-    {
-        /// <summary>
-        /// Type of the effect.
-        /// </summary>
-        public EffectType Type;
-
-        /// <summary>
-        /// Set to true if the effect is new.
-        /// </summary>
-        [MarshalAs(UnmanagedType.I1)]
-        public bool IsNew;
-
-        /// <summary>
-        /// Set to true if the effect must be active.
-        /// </summary>
-        [MarshalAs(UnmanagedType.I1)]
-        public bool IsEnabled;
-
-        /// <summary>
-        /// Reserved/padding.
-        /// </summary>
-        private readonly byte _reserved1;
-
-        /// <summary>
-        /// The target mix id of the effect.
-        /// </summary>
-        public int MixId;
-
-        /// <summary>
-        /// Address of the processing workbuffer.
-        /// </summary>
-        /// <remarks>This is additional data that could be required by the effect processing.</remarks>
-        public ulong BufferBase;
-
-        /// <summary>
-        /// Size of the processing workbuffer.
-        /// </summary>
-        /// <remarks>This is additional data that could be required by the effect processing.</remarks>
-        public ulong BufferSize;
-
-        /// <summary>
-        /// Position of the effect while processing effects.
-        /// </summary>
-        public uint ProcessingOrder;
-
-        /// <summary>
-        /// Reserved/padding.
-        /// </summary>
-        private readonly uint _reserved2;
-
-        /// <summary>
-        /// Specific data storage.
-        /// </summary>
-        private SpecificDataStruct _specificDataStart;
-
-        [StructLayout(LayoutKind.Sequential, Size = 0xA0, Pack = 1)]
-        private struct SpecificDataStruct { }
-
-        public Span<byte> SpecificData => SpanHelpers.AsSpan<SpecificDataStruct, byte>(ref _specificDataStart);
-
-        readonly EffectType IEffectInParameter.Type => Type;
-
-        readonly bool IEffectInParameter.IsNew => IsNew;
-
-        readonly bool IEffectInParameter.IsEnabled => IsEnabled;
-
-        readonly int IEffectInParameter.MixId => MixId;
-
-        readonly ulong IEffectInParameter.BufferBase => BufferBase;
-
-        readonly ulong IEffectInParameter.BufferSize => BufferSize;
-
-        readonly uint IEffectInParameter.ProcessingOrder => ProcessingOrder;
-
-        /// <summary>
-        ///  Check if the given channel count is valid.
-        /// </summary>
-        /// <param name="channelCount">The channel count to check</param>
-        /// <returns>Returns true if the channel count is valid.</returns>
-        public static bool IsChannelCountValid(int channelCount)
-        {
-            return channelCount is 1 or 2 or 4 or 6;
-        }
-    }
-}

src/Ryujinx.Audio/Renderer/Parameter/VoiceInParameter2.cs

@@ -1,9 +1,6 @@
 using Ryujinx.Audio.Common;
 using Ryujinx.Audio.Renderer.Common;
-using Ryujinx.Audio.Renderer.Dsp;
 using Ryujinx.Common.Memory;
-using System;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.Audio.Renderer.Parameter

src/Ryujinx.Audio/Renderer/Server/CommandBuffer.cs

@@ -8,8 +8,8 @@ using Ryujinx.Audio.Renderer.Server.Sink;
 using Ryujinx.Audio.Renderer.Server.Splitter;
 using Ryujinx.Audio.Renderer.Server.Upsampler;
 using Ryujinx.Audio.Renderer.Server.Voice;
+using Ryujinx.Common;
 using System;
-using System.Runtime.CompilerServices;
 using CpuAddress = System.UInt64;
 
 namespace Ryujinx.Audio.Renderer.Server
@@ -34,6 +34,162 @@ namespace Ryujinx.Audio.Renderer.Server
         /// </summary>
         public CommandList CommandList { get; }
 
+        private readonly static ObjectPool<PcmInt16DataSourceCommandVersion1> _pcmInt16DataSourceCommandVersion1Pool = new(() => new PcmInt16DataSourceCommandVersion1());
+        private readonly static ObjectPool<PcmFloatDataSourceCommandVersion1> _pcmFloatDataSourceCommandVersion1Pool = new(() => new PcmFloatDataSourceCommandVersion1());
+        private readonly static ObjectPool<AdpcmDataSourceCommandVersion1> _adpcmDataSourceCommandVersion1Pool = new(() => new AdpcmDataSourceCommandVersion1());
+        private readonly static ObjectPool<DataSourceVersion2Command> _dataSourceVersion2CommandPool = new(() => new DataSourceVersion2Command());
+        private readonly static ObjectPool<VolumeCommand> _volumeCommandPool = new(() => new VolumeCommand());
+        private readonly static ObjectPool<VolumeRampCommand> _volumeRampCommandPool = new(() => new VolumeRampCommand());
+        private readonly static ObjectPool<BiquadFilterCommand> _biquadFilterCommandPool = new(() => new BiquadFilterCommand());
+        private readonly static ObjectPool<MixCommand> _mixCommandPool = new(() => new MixCommand());
+        private readonly static ObjectPool<MixRampCommand> _mixRampCommandPool = new(() => new MixRampCommand());
+        private readonly static ObjectPool<MixRampGroupedCommand> _mixRampGroupedCommandPool = new(() => new MixRampGroupedCommand());
+        private readonly static ObjectPool<DepopPrepareCommand> _depopPrepareCommandPool = new(() => new DepopPrepareCommand());
+        private readonly static ObjectPool<DepopForMixBuffersCommand> _depopForMixBuffersCommandPool = new(() => new DepopForMixBuffersCommand());
+        private readonly static ObjectPool<DelayCommand> _delayCommandPool = new(() => new DelayCommand());
+        private readonly static ObjectPool<UpsampleCommand> _upsampleCommandPool = new(() => new UpsampleCommand());
+        private readonly static ObjectPool<DownMixSurroundToStereoCommand> _downMixSurroundToStereoCommandPool = new(() => new DownMixSurroundToStereoCommand());
+        private readonly static ObjectPool<AuxiliaryBufferCommand> _auxiliaryBufferCommandPool = new(() => new AuxiliaryBufferCommand());
+        private readonly static ObjectPool<DeviceSinkCommand> _deviceSinkCommandPool = new(() => new DeviceSinkCommand());
+        private readonly static ObjectPool<CircularBufferSinkCommand> _circularBufferSinkCommandPool = new(() => new CircularBufferSinkCommand());
+        private readonly static ObjectPool<ReverbCommand> _reverbCommandPool = new(() => new ReverbCommand());
+        private readonly static ObjectPool<Reverb3dCommand> _reverb3dCommandPool = new(() => new Reverb3dCommand());
+        private readonly static ObjectPool<PerformanceCommand> _performanceCommandPool = new(() => new PerformanceCommand());
+        private readonly static ObjectPool<ClearMixBufferCommand> _clearMixBufferCommandPool = new(() => new ClearMixBufferCommand());
+        private readonly static ObjectPool<CopyMixBufferCommand> _copyMixBufferCommandPool = new(() => new CopyMixBufferCommand());
+        private readonly static ObjectPool<LimiterCommandVersion1> _limiterCommandVersion1Pool = new(() => new LimiterCommandVersion1());
+        private readonly static ObjectPool<LimiterCommandVersion2> _limiterCommandVersion2Pool = new(() => new LimiterCommandVersion2());
+        private readonly static ObjectPool<MultiTapBiquadFilterCommand> _multiTapBiquadFilterCommandPool = new(() => new MultiTapBiquadFilterCommand());
+        private readonly static ObjectPool<CaptureBufferCommand> _captureBufferCommandPool = new(() => new CaptureBufferCommand());
+        private readonly static ObjectPool<CompressorCommand> _compressorCommandPool = new(() => new CompressorCommand());
+        private readonly static ObjectPool<BiquadFilterAndMixCommand> _biquadFilterAndMixCommandPool = new(() => new BiquadFilterAndMixCommand());
+        private readonly static ObjectPool<MultiTapBiquadFilterAndMixCommand> _multiTapBiquadFilterAndMixCommandPool = new(() => new MultiTapBiquadFilterAndMixCommand());
+        private readonly static ObjectPool<FillBufferCommand> _fillBufferCommandPool = new(() => new FillBufferCommand());
+
+        public static void ReleaseCommand(ICommand command)
+        {
+            switch (command.CommandType)
+            {
+                case CommandType.PcmInt16DataSourceVersion1:
+                    _pcmInt16DataSourceCommandVersion1Pool.Release((PcmInt16DataSourceCommandVersion1)command);
+                    break;
+                case CommandType.PcmInt16DataSourceVersion2:
+                    _dataSourceVersion2CommandPool.Release((DataSourceVersion2Command)command);
+                    break;
+                case CommandType.PcmFloatDataSourceVersion1:
+                    _pcmFloatDataSourceCommandVersion1Pool.Release((PcmFloatDataSourceCommandVersion1)command);
+                    break;
+                case CommandType.PcmFloatDataSourceVersion2:
+                    _dataSourceVersion2CommandPool.Release((DataSourceVersion2Command)command);
+                    break;
+                case CommandType.AdpcmDataSourceVersion1:
+                    _adpcmDataSourceCommandVersion1Pool.Release((AdpcmDataSourceCommandVersion1)command);
+                    break;
+                case CommandType.AdpcmDataSourceVersion2:
+                    _dataSourceVersion2CommandPool.Release((DataSourceVersion2Command)command);
+                    break;
+                case CommandType.Volume:
+                    _volumeCommandPool.Release((VolumeCommand)command);
+                    break;
+                case CommandType.VolumeRamp:
+                    _volumeRampCommandPool.Release((VolumeRampCommand)command);
+                    break;
+                case CommandType.BiquadFilter:
+                    _biquadFilterCommandPool.Release((BiquadFilterCommand)command);
+                    break;
+                case CommandType.BiquadFilterFloatCoeff:
+                    throw new NotImplementedException();
+                case CommandType.Mix:
+                    _mixCommandPool.Release((MixCommand)command);
+                    break;
+                case CommandType.MixRamp:
+                    _mixRampCommandPool.Release((MixRampCommand)command);
+                    break;
+                case CommandType.MixRampGrouped:
+                    _mixRampGroupedCommandPool.Release((MixRampGroupedCommand)command);
+                    break;
+                case CommandType.DepopPrepare:
+                    _depopPrepareCommandPool.Release((DepopPrepareCommand)command);
+                    break;
+                case CommandType.DepopForMixBuffers:
+                    _depopForMixBuffersCommandPool.Release((DepopForMixBuffersCommand)command);
+                    break;
+                case CommandType.Delay:
+                    _delayCommandPool.Release((DelayCommand)command);
+                    break;
+                case CommandType.Upsample:
+                    _upsampleCommandPool.Release((UpsampleCommand)command);
+                    break;
+                case CommandType.DownMixSurroundToStereo:
+                    _downMixSurroundToStereoCommandPool.Release((DownMixSurroundToStereoCommand)command);
+                    break;
+                case CommandType.AuxiliaryBuffer:
+                    _auxiliaryBufferCommandPool.Release((AuxiliaryBufferCommand)command);
+                    break;
+                case CommandType.DeviceSink:
+                    _deviceSinkCommandPool.Release((DeviceSinkCommand)command);
+                    break;
+                case CommandType.CircularBufferSink:
+                    _circularBufferSinkCommandPool.Release((CircularBufferSinkCommand)command);
+                    break;
+                case CommandType.Reverb:
+                    _reverbCommandPool.Release((ReverbCommand)command);
+                    break;
+                case CommandType.Reverb3d:
+                    _reverb3dCommandPool.Release((Reverb3dCommand)command);
+                    break;
+                case CommandType.Performance:
+                    _performanceCommandPool.Release((PerformanceCommand)command);
+                    break;
+                case CommandType.ClearMixBuffer:
+                    _clearMixBufferCommandPool.Release((ClearMixBufferCommand)command);
+                    break;
+                case CommandType.CopyMixBuffer:
+                    _copyMixBufferCommandPool.Release((CopyMixBufferCommand)command);
+                    break;
+                case CommandType.LimiterVersion1:
+                    _limiterCommandVersion1Pool.Release((LimiterCommandVersion1)command);
+                    break;
+                case CommandType.LimiterVersion2:
+                    _limiterCommandVersion2Pool.Release((LimiterCommandVersion2)command);
+                    break;
+                case CommandType.MultiTapBiquadFilter:
+                    _multiTapBiquadFilterCommandPool.Release((MultiTapBiquadFilterCommand)command);
+                    break;
+                case CommandType.MultiTapBiquadFilterFloatCoeff:
+                    throw new NotImplementedException();
+                case CommandType.CaptureBuffer:
+                    _captureBufferCommandPool.Release((CaptureBufferCommand)command);
+                    break;
+                case CommandType.Compressor:
+                    _compressorCommandPool.Release((CompressorCommand)command);
+                    break;
+                case CommandType.BiquadFilterAndMix:
+                    _biquadFilterAndMixCommandPool.Release((BiquadFilterAndMixCommand)command);
+                    break;
+                case CommandType.BiquadFilterAndMixFloatCoeff:
+                    throw new NotImplementedException();
+                case CommandType.MultiTapBiquadFilterAndMix:
+                    _multiTapBiquadFilterAndMixCommandPool.Release((MultiTapBiquadFilterAndMixCommand)command);
+                    break;
+                case CommandType.MultiTapBiquadFilterAndMixFloatCoef:
+                    throw new NotImplementedException();
+                case CommandType.AuxiliaryBufferGrouped:
+                    throw new NotImplementedException();
+                case CommandType.FillMixBuffer:
+                    throw new NotImplementedException();
+                case CommandType.BiquadFilterCrossFade:
+                    throw new NotImplementedException();
+                case CommandType.MultiTapBiquadFilterCrossFade:
+                    throw new NotImplementedException();
+                case CommandType.FillBuffer:
+                    _fillBufferCommandPool.Release((FillBufferCommand)command);
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+        
         /// <summary>
         /// Create a new <see cref="CommandBuffer"/>.
         /// </summary>
@@ -63,7 +219,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateClearMixBuffer(int nodeId)
         {
-            ClearMixBufferCommand command = new(nodeId);
+            ClearMixBufferCommand command = _clearMixBufferCommandPool.Allocate().Initialize(nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -81,7 +237,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="wasPlaying">Set to true if the voice was playing previously.</param>
         public void GenerateDepopPrepare(Memory<VoiceState> state, Memory<float> depopBuffer, uint bufferCount, uint bufferOffset, int nodeId, bool wasPlaying)
         {
-            DepopPrepareCommand command = new(state, depopBuffer, bufferCount, bufferOffset, nodeId, wasPlaying);
+            DepopPrepareCommand command = _depopPrepareCommandPool.Allocate().Initialize(state, depopBuffer, bufferCount, bufferOffset, nodeId, wasPlaying);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -96,7 +252,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GeneratePerformance(ref PerformanceEntryAddresses performanceEntryAddresses, PerformanceCommand.Type type, int nodeId)
         {
-            PerformanceCommand command = new(ref performanceEntryAddresses, type, nodeId);
+            PerformanceCommand command = _performanceCommandPool.Allocate().Initialize(ref performanceEntryAddresses, type, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -112,7 +268,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateVolumeRamp(float previousVolume, float volume, uint bufferIndex, int nodeId)
         {
-            VolumeRampCommand command = new(previousVolume, volume, bufferIndex, nodeId);
+            VolumeRampCommand command = _volumeRampCommandPool.Allocate().Initialize(previousVolume, volume, bufferIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -129,7 +285,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateDataSourceVersion2(ref VoiceInfo voiceInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
-            DataSourceVersion2Command command = new(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
+            DataSourceVersion2Command command = _dataSourceVersion2CommandPool.Allocate().Initialize(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -146,7 +302,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GeneratePcmInt16DataSourceVersion1(ref VoiceInfo voiceInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
-            PcmInt16DataSourceCommandVersion1 command = new(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
+            PcmInt16DataSourceCommandVersion1 command = _pcmInt16DataSourceCommandVersion1Pool.Allocate().Initialize(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -163,7 +319,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GeneratePcmFloatDataSourceVersion1(ref VoiceInfo voiceInfo, Memory<VoiceState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId)
         {
-            PcmFloatDataSourceCommandVersion1 command = new(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
+            PcmFloatDataSourceCommandVersion1 command = _pcmFloatDataSourceCommandVersion1Pool.Allocate().Initialize(ref voiceInfo, state, outputBufferIndex, channelIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -179,7 +335,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateAdpcmDataSourceVersion1(ref VoiceInfo voiceInfo, Memory<VoiceState> state, ushort outputBufferIndex, int nodeId)
         {
-            AdpcmDataSourceCommandVersion1 command = new(ref voiceInfo, state, outputBufferIndex, nodeId);
+            AdpcmDataSourceCommandVersion1 command = _adpcmDataSourceCommandVersion1Pool.Allocate().Initialize(ref voiceInfo, state, outputBufferIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -198,7 +354,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateBiquadFilter(int baseIndex, ref BiquadFilterParameter2 filter, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, bool needInitialization, int nodeId)
         {
-            BiquadFilterCommand command = new(baseIndex, ref filter, biquadFilterStateMemory, inputBufferOffset, outputBufferOffset, needInitialization, nodeId);
+            BiquadFilterCommand command = _biquadFilterCommandPool.Allocate().Initialize(baseIndex, ref filter, biquadFilterStateMemory, inputBufferOffset, outputBufferOffset, needInitialization, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -217,7 +373,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateMultiTapBiquadFilter(int baseIndex, ReadOnlySpan<BiquadFilterParameter2> filters, Memory<BiquadFilterState> biquadFilterStatesMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
         {
-            MultiTapBiquadFilterCommand command = new(baseIndex, filters, biquadFilterStatesMemory, inputBufferOffset, outputBufferOffset, isInitialized, nodeId);
+            MultiTapBiquadFilterCommand command = _multiTapBiquadFilterCommandPool.Allocate().Initialize(baseIndex, filters, biquadFilterStatesMemory, inputBufferOffset, outputBufferOffset, isInitialized, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -236,7 +392,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateMixRampGrouped(uint mixBufferCount, uint inputBufferIndex, uint outputBufferIndex, ReadOnlySpan<float> previousVolume, ReadOnlySpan<float> volume, Memory<VoiceState> state, int nodeId)
         {
-            MixRampGroupedCommand command = new(mixBufferCount, inputBufferIndex, outputBufferIndex, previousVolume, volume, state, nodeId);
+            MixRampGroupedCommand command = _mixRampGroupedCommandPool.Allocate().Initialize(mixBufferCount, inputBufferIndex, outputBufferIndex, previousVolume, volume, state, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -255,7 +411,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateMixRamp(float previousVolume, float volume, uint inputBufferIndex, uint outputBufferIndex, int lastSampleIndex, Memory<VoiceState> state, int nodeId)
         {
-            MixRampCommand command = new(previousVolume, volume, inputBufferIndex, outputBufferIndex, lastSampleIndex, state, nodeId);
+            MixRampCommand command = _mixRampCommandPool.Allocate().Initialize(previousVolume, volume, inputBufferIndex, outputBufferIndex, lastSampleIndex, state, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -293,7 +449,7 @@ namespace Ryujinx.Audio.Renderer.Server
             bool isFirstMixBuffer,
             int nodeId)
         {
-            BiquadFilterAndMixCommand command = new(
+            BiquadFilterAndMixCommand command = _biquadFilterAndMixCommandPool.Allocate().Initialize(
                 previousVolume,
                 volume,
                 inputBufferIndex,
@@ -352,7 +508,7 @@ namespace Ryujinx.Audio.Renderer.Server
             bool isFirstMixBuffer,
             int nodeId)
         {
-            MultiTapBiquadFilterAndMixCommand command = new(
+            MultiTapBiquadFilterAndMixCommand command = _multiTapBiquadFilterAndMixCommandPool.Allocate().Initialize(
                 previousVolume,
                 volume,
                 inputBufferIndex,
@@ -386,7 +542,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="sampleRate">The target sample rate in use.</param>
         public void GenerateDepopForMixBuffers(Memory<float> depopBuffer, uint bufferOffset, uint bufferCount, int nodeId, uint sampleRate)
         {
-            DepopForMixBuffersCommand command = new(depopBuffer, bufferOffset, bufferCount, nodeId, sampleRate);
+            DepopForMixBuffersCommand command = _depopForMixBuffersCommandPool.Allocate().Initialize(depopBuffer, bufferOffset, bufferCount, nodeId, sampleRate);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -401,7 +557,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateCopyMixBuffer(uint inputBufferIndex, uint outputBufferIndex, int nodeId)
         {
-            CopyMixBufferCommand command = new(inputBufferIndex, outputBufferIndex, nodeId);
+            CopyMixBufferCommand command = _copyMixBufferCommandPool.Allocate().Initialize(inputBufferIndex, outputBufferIndex, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -417,7 +573,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="volume">The mix volume.</param>
         public void GenerateMix(uint inputBufferIndex, uint outputBufferIndex, int nodeId, float volume)
         {
-            MixCommand command = new(inputBufferIndex, outputBufferIndex, nodeId, volume);
+            MixCommand command = _mixCommandPool.Allocate().Initialize(inputBufferIndex, outputBufferIndex, nodeId, volume);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -439,7 +595,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                ReverbCommand command = new(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, isLongSizePreDelaySupported, newEffectChannelMappingSupported);
+                ReverbCommand command = _reverbCommandPool.Allocate().Initialize(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, isLongSizePreDelaySupported, newEffectChannelMappingSupported);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -461,7 +617,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                Reverb3dCommand command = new(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, newEffectChannelMappingSupported);
+                Reverb3dCommand command = _reverb3dCommandPool.Allocate().Initialize(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, newEffectChannelMappingSupported);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -483,7 +639,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                DelayCommand command = new(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, newEffectChannelMappingSupported);
+                DelayCommand command = _delayCommandPool.Allocate().Initialize(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId, newEffectChannelMappingSupported);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -504,7 +660,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                LimiterCommandVersion1 command = new(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId);
+                LimiterCommandVersion1 command = _limiterCommandVersion1Pool.Allocate().Initialize(bufferOffset, parameter, state, isEnabled, workBuffer, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -526,7 +682,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                LimiterCommandVersion2 command = new(bufferOffset, parameter, state, effectResultState, isEnabled, workBuffer, nodeId);
+                LimiterCommandVersion2 command = _limiterCommandVersion2Pool.Allocate().Initialize(bufferOffset, parameter, state, effectResultState, isEnabled, workBuffer, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -552,7 +708,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (state.SendBufferInfoBase != 0 && state.ReturnBufferInfoBase != 0)
             {
-                AuxiliaryBufferCommand command = new(bufferOffset, inputBufferOffset, outputBufferOffset, ref state, isEnabled, countMax, outputBuffer, inputBuffer, updateCount, writeOffset, nodeId);
+                AuxiliaryBufferCommand command = _auxiliaryBufferCommandPool.Allocate().Initialize(bufferOffset, inputBufferOffset, outputBufferOffset, ref state, isEnabled, countMax, outputBuffer, inputBuffer, updateCount, writeOffset, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -576,7 +732,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (sendBufferInfo != 0)
             {
-                CaptureBufferCommand command = new(bufferOffset, inputBufferOffset, sendBufferInfo, isEnabled, countMax, outputBuffer, updateCount, writeOffset, nodeId);
+                CaptureBufferCommand command = _captureBufferCommandPool.Allocate().Initialize(bufferOffset, inputBufferOffset, sendBufferInfo, isEnabled, countMax, outputBuffer, updateCount, writeOffset, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -597,7 +753,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             if (parameter.IsChannelCountValid())
             {
-                CompressorCommand command = new(bufferOffset, parameter, state, effectResultState, isEnabled, nodeId);
+                CompressorCommand command = _compressorCommandPool.Allocate().Initialize(bufferOffset, parameter, state, effectResultState, isEnabled, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -613,7 +769,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateVolume(float volume, uint bufferOffset, int nodeId)
         {
-            VolumeCommand command = new(volume, bufferOffset, nodeId);
+            VolumeCommand command = _volumeCommandPool.Allocate().Initialize(volume, bufferOffset, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -628,7 +784,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateCircularBuffer(uint bufferOffset, CircularBufferSink sink, int nodeId)
         {
-            CircularBufferSinkCommand command = new(bufferOffset, ref sink.Parameter, ref sink.CircularBufferAddressInfo, sink.CurrentWriteOffset, nodeId);
+            CircularBufferSinkCommand command = _circularBufferSinkCommandPool.Allocate().Initialize(bufferOffset, ref sink.Parameter, ref sink.CircularBufferAddressInfo, sink.CurrentWriteOffset, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -645,7 +801,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateDownMixSurroundToStereo(uint bufferOffset, Span<byte> inputBufferOffset, Span<byte> outputBufferOffset, float[] downMixParameter, int nodeId)
         {
-            DownMixSurroundToStereoCommand command = new(bufferOffset, inputBufferOffset, outputBufferOffset, downMixParameter, nodeId);
+            DownMixSurroundToStereoCommand command = _downMixSurroundToStereoCommandPool.Allocate().Initialize(bufferOffset, inputBufferOffset, outputBufferOffset, downMixParameter, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -665,7 +821,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateUpsample(uint bufferOffset, UpsamplerInfo upsampler, uint inputCount, Span<byte> inputBufferOffset, uint bufferCountPerSample, uint sampleCount, uint sampleRate, int nodeId)
         {
-            UpsampleCommand command = new(bufferOffset, upsampler, inputCount, inputBufferOffset, bufferCountPerSample, sampleCount, sampleRate, nodeId);
+            UpsampleCommand command = _upsampleCommandPool.Allocate().Initialize(bufferOffset, upsampler, inputCount, inputBufferOffset, bufferCountPerSample, sampleCount, sampleRate, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -682,7 +838,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="nodeId">The node id associated to this command.</param>
         public void GenerateDeviceSink(uint bufferOffset, DeviceSink sink, int sessionId, Memory<float> buffer, int nodeId)
         {
-            DeviceSinkCommand command = new(bufferOffset, sink, sessionId, buffer, nodeId);
+            DeviceSinkCommand command = _deviceSinkCommandPool.Allocate().Initialize(bufferOffset, sink, sessionId, buffer, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -691,16 +847,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
         public void GenerateFillBuffer(SplitterDestination destination, float value, int length, int nodeId)
         {
-            FillBufferCommand command;
-
-            if (Unsafe.IsNullRef(ref destination.GetV2RefOrNull()))
-            {
-                command = new(destination.GetV1RefOrNull(), length, value, nodeId);
-            }
-            else
-            {
-                command = new(destination.GetV2RefOrNull(), length, value, nodeId);
-            }
+            FillBufferCommand command = _fillBufferCommandPool.Allocate().Initialize(destination, length, value, nodeId);
             
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
             

src/Ryujinx.Audio/Renderer/Server/CommandGenerator.cs

@@ -1,6 +1,5 @@
 using Ryujinx.Audio.Common;
 using Ryujinx.Audio.Renderer.Common;
-using Ryujinx.Audio.Renderer.Dsp;
 using Ryujinx.Audio.Renderer.Dsp.Command;
 using Ryujinx.Audio.Renderer.Dsp.State;
 using Ryujinx.Audio.Renderer.Parameter;
@@ -339,7 +338,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
                 bool performanceInitialized = false;
 
-                PerformanceEntryAddresses performanceEntry = new();
+                PerformanceEntryAddresses performanceEntry = null;
 
                 if (_performanceManager != null && _performanceManager.IsTargetNodeId(nodeId) && _performanceManager.GetNextEntry(out performanceEntry, dataSourceDetailType, PerformanceEntryType.Voice, nodeId))
                 {
@@ -500,7 +499,7 @@ namespace Ryujinx.Audio.Renderer.Server
                 {
                     int nodeId = sortedInfo.NodeId;
 
-                    PerformanceEntryAddresses performanceEntry = new();
+                    PerformanceEntryAddresses performanceEntry = null;
 
                     bool performanceInitialized = false;
 
@@ -786,7 +785,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             bool isFinalMix = mix.MixId == Constants.FinalMixId;
 
-            PerformanceEntryAddresses performanceEntry = new();
+            PerformanceEntryAddresses performanceEntry = null;
 
             bool performanceInitialized = false;
 
@@ -1050,7 +1049,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             GenerateEffects(ref subMix);
 
-            PerformanceEntryAddresses performanceEntry = new();
+            PerformanceEntryAddresses performanceEntry = null;
 
             int nodeId = subMix.NodeId;
 
@@ -1081,7 +1080,7 @@ namespace Ryujinx.Audio.Renderer.Server
                 {
                     int nodeId = sortedInfo.NodeId;
 
-                    PerformanceEntryAddresses performanceEntry = new();
+                    PerformanceEntryAddresses performanceEntry = null;
 
                     bool performanceInitialized = false;
 
@@ -1115,7 +1114,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             GenerateEffects(ref finalMix);
 
-            PerformanceEntryAddresses performanceEntry = new();
+            PerformanceEntryAddresses performanceEntry = null;
 
             int nodeId = finalMix.NodeId;
 
@@ -1164,7 +1163,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             int nodeId = _mixContext.GetFinalState().NodeId;
 
-            PerformanceEntryAddresses performanceEntry = new();
+            PerformanceEntryAddresses performanceEntry = null;
 
             bool performanceInitialized = false;
 
@@ -1244,7 +1243,7 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             bool performanceInitialized = false;
 
-            PerformanceEntryAddresses performanceEntry = new();
+            PerformanceEntryAddresses performanceEntry = null;
 
             if (_performanceManager != null && _performanceManager.GetNextEntry(out performanceEntry, PerformanceEntryType.Sink, sink.NodeId))
             {

src/Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs

@@ -174,19 +174,6 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
             updateErrorInfo = new ErrorInfo();
         }
-        
-        /// <summary>
-        /// Update the internal state from a user version 3 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, in EffectInParameterVersion3 parameter, PoolMapper mapper)
-        {
-            Debug.Assert(IsTypeValid(in parameter));
-
-            updateErrorInfo = new ErrorInfo();
-        }
 
         /// <summary>
         /// Get the work buffer DSP address at the given index.

src/Ryujinx.Audio/Renderer/Server/Effect/BiquadFilterEffect.cs

@@ -25,13 +25,19 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// </summary>
         public Memory<BiquadFilterState> State { get; }
 
+        /// <summary>
+        /// The biquad filter effect version.
+        /// </summary>
+        public int BiquadFilterEffectVersion;
+
         /// <summary>
         /// Create a new <see cref="BiquadFilterEffect"/>.
         /// </summary>
-        public BiquadFilterEffect()
+        public BiquadFilterEffect(int version)
         {
             Parameter = new BiquadFilterEffectParameter2();
             State = new BiquadFilterState[Constants.ChannelCountMax];
+            BiquadFilterEffectVersion = version;
         }
 
         public override EffectType TargetEffectType => EffectType.BiquadFilter;
@@ -45,11 +51,6 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         {
             Update(out updateErrorInfo, in parameter, mapper);
         }
-        
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion3 parameter, PoolMapper mapper)
-        {
-            Update(out updateErrorInfo, in parameter, mapper);
-        }
 
         public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
@@ -57,7 +58,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
             UpdateParameterBase(in parameter);
 
-            if (typeof(T) == typeof(EffectInParameterVersion3))
+            if (BiquadFilterEffectVersion == 2)
             {
                 Parameter = MemoryMarshal.Cast<byte, BiquadFilterEffectParameter2>(parameter.SpecificData)[0];
             }

src/Ryujinx.Audio/Renderer/Server/Performance/PerformanceEntryAddresses.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common;
 using System;
 
 namespace Ryujinx.Audio.Renderer.Server.Performance
@@ -7,6 +8,8 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
     /// </summary>
     public class PerformanceEntryAddresses
     {
+        public static readonly ObjectPool<PerformanceEntryAddresses> PerformanceEntryAddressesPool = new(() => new PerformanceEntryAddresses());
+        
         /// <summary>
         /// The memory storing the performance entry.
         /// </summary>
@@ -52,5 +55,10 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
         {
             BaseMemory.Span[(int)ProcessingTimeOffset / 4] = (int)(endTimeNano / 1000) - BaseMemory.Span[(int)StartTimeOffset / 4];
         }
+
+        public void Clear()
+        {
+            
+        }
     }
 }

src/Ryujinx.Audio/Renderer/Server/Performance/PerformanceManagerGeneric.cs

@@ -208,11 +208,9 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
 
         public override bool GetNextEntry(out PerformanceEntryAddresses performanceEntry, PerformanceEntryType entryType, int nodeId)
         {
-            performanceEntry = new PerformanceEntryAddresses
-            {
-                BaseMemory = SpanMemoryManager<int>.Cast(CurrentBuffer),
-                EntryCountOffset = (uint)CurrentHeader.GetEntryCountOffset(),
-            };
+            performanceEntry = PerformanceEntryAddresses.PerformanceEntryAddressesPool.Allocate();
+            performanceEntry.BaseMemory = SpanMemoryManager<int>.Cast(CurrentBuffer);
+            performanceEntry.EntryCountOffset = (uint)CurrentHeader.GetEntryCountOffset();
 
             uint baseEntryOffset = (uint)(Unsafe.SizeOf<THeader>() + Unsafe.SizeOf<TEntry>() * _entryIndex);
 
@@ -238,12 +236,10 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
             {
                 return false;
             }
-
-            performanceEntry = new PerformanceEntryAddresses
-            {
-                BaseMemory = SpanMemoryManager<int>.Cast(CurrentBuffer),
-                EntryCountOffset = (uint)CurrentHeader.GetEntryCountOffset(),
-            };
+            
+            performanceEntry = PerformanceEntryAddresses.PerformanceEntryAddressesPool.Allocate();
+            performanceEntry.BaseMemory = SpanMemoryManager<int>.Cast(CurrentBuffer);
+            performanceEntry.EntryCountOffset = (uint)CurrentHeader.GetEntryCountOffset();
 
             uint baseEntryOffset = (uint)(Unsafe.SizeOf<THeader>() + GetEntriesSize() + Unsafe.SizeOf<TEntryDetail>() * _entryDetailIndex);
 

src/Ryujinx.Audio/Renderer/Server/Splitter/SplitterDestinationVersion2.cs

@@ -1,4 +1,3 @@
-using Ryujinx.Audio.Renderer.Dsp;
 using Ryujinx.Audio.Renderer.Parameter;
 using Ryujinx.Common.Memory;
 using Ryujinx.Common.Utilities;

src/Ryujinx.Audio/Renderer/Server/StateUpdater.cs

@@ -300,7 +300,7 @@ namespace Ryujinx.Audio.Renderer.Server
             return ResultCode.Success;
         }
 
-        private static void ResetEffect<T>(ref BaseEffect effect, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        private void ResetEffect<T>(ref BaseEffect effect, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
             effect.ForceUnmapBuffers(mapper);
 
@@ -312,7 +312,8 @@ namespace Ryujinx.Audio.Renderer.Server
                 EffectType.Delay => new DelayEffect(),
                 EffectType.Reverb => new ReverbEffect(),
                 EffectType.Reverb3d => new Reverb3dEffect(),
-                EffectType.BiquadFilter => new BiquadFilterEffect(),
+                EffectType.BiquadFilter when _behaviourInfo.IsBiquadFilterParameterFloatSupported() => new BiquadFilterEffect(2),
+                EffectType.BiquadFilter => new BiquadFilterEffect(1),
                 EffectType.Limiter => new LimiterEffect(),
                 EffectType.CaptureBuffer => new CaptureBufferEffect(),
                 EffectType.Compressor => new CompressorEffect(),
@@ -322,11 +323,6 @@ namespace Ryujinx.Audio.Renderer.Server
 
         public ResultCode UpdateEffects(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
         {
-            if (_behaviourInfo.IsBiquadFilterParameterFloatSupported())
-            {
-                return UpdateEffectsVersion3(context, isAudioRendererActive, mapper);
-            }
-            
             if (_behaviourInfo.IsEffectInfoVersion2Supported())
             {
                 return UpdateEffectsVersion2(context, isAudioRendererActive, mapper);
@@ -334,60 +330,6 @@ namespace Ryujinx.Audio.Renderer.Server
 
             return UpdateEffectsVersion1(context, isAudioRendererActive, mapper);
         }
-
-        public ResultCode UpdateEffectsVersion3(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
-        {
-            if (context.GetCount() * Unsafe.SizeOf<EffectInParameterVersion2>() != _inputHeader.EffectsSize)
-            {
-                return ResultCode.InvalidUpdateInfo;
-            }
-
-            int initialOutputSize = _output.Length;
-
-            long initialInputConsumed = _inputReader.Consumed;
-
-            for (int i = 0; i < context.GetCount(); i++)
-            {
-                ref readonly EffectInParameterVersion3 parameter = ref _inputReader.GetRefOrRefToCopy<EffectInParameterVersion3>(out _);
-
-                ref EffectOutStatusVersion2 outStatus = ref SpanIOHelper.GetWriteRef<EffectOutStatusVersion2>(ref _output)[0];
-
-                ref BaseEffect effect = ref context.GetEffect(i);
-
-                if (!effect.IsTypeValid(in parameter))
-                {
-                    ResetEffect(ref effect, in parameter, mapper);
-                }
-
-                effect.Update(out ErrorInfo updateErrorInfo, in parameter, mapper);
-
-                if (updateErrorInfo.ErrorCode != ResultCode.Success)
-                {
-                    _behaviourInfo.AppendError(ref updateErrorInfo);
-                }
-
-                effect.StoreStatus(ref outStatus, isAudioRendererActive);
-
-                if (parameter.IsNew)
-                {
-                    effect.InitializeResultState(ref context.GetDspState(i));
-                    effect.InitializeResultState(ref context.GetState(i));
-                }
-
-                effect.UpdateResultState(ref outStatus.ResultState, ref context.GetState(i));
-            }
-
-            int currentOutputSize = _output.Length;
-
-            OutputHeader.EffectsSize = (uint)(Unsafe.SizeOf<EffectOutStatusVersion2>() * context.GetCount());
-            OutputHeader.TotalSize += OutputHeader.EffectsSize;
-
-            Debug.Assert((initialOutputSize - currentOutputSize) == OutputHeader.EffectsSize);
-
-            _inputReader.SetConsumed(initialInputConsumed + _inputHeader.EffectsSize);
-
-            return ResultCode.Success;
-        }
         
         public ResultCode UpdateEffectsVersion2(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
         {

src/Ryujinx.Audio/Renderer/Server/Voice/VoiceInfo.cs

@@ -4,13 +4,14 @@ using Ryujinx.Audio.Renderer.Dsp;
 using Ryujinx.Audio.Renderer.Dsp.State;
 using Ryujinx.Audio.Renderer.Parameter;
 using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using Ryujinx.Common;
 using Ryujinx.Common.Memory;
 using Ryujinx.Common.Utilities;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using static Ryujinx.Audio.Renderer.Common.BehaviourParameter;
-using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter1;
 using PlayState = Ryujinx.Audio.Renderer.Server.Types.PlayState;
 
 namespace Ryujinx.Audio.Renderer.Server.Voice
@@ -20,6 +21,8 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
     {
         public const int Alignment = 0x10;
 
+        private static readonly ObjectPool<Memory<VoiceState>[]> voiceStatesPool = new(() => new Memory<VoiceState>[Constants.VoiceChannelCountMax]);
+
         /// <summary>
         /// Set to true if the voice is used.
         /// </summary>
@@ -185,6 +188,8 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// </summary>
         public Span<bool> BiquadFilterNeedInitialization => SpanHelpers.AsSpan<BiquadFilterNeedInitializationArrayStruct, bool>(ref _biquadFilterNeedInitialization);
 
+        private static List<ErrorInfo> _waveBufferUpdaterErrorInfosList;
+
         /// <summary>
         /// Initialize the <see cref="VoiceInfo"/>.
         /// </summary>
@@ -213,6 +218,8 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
             DataSourceStateAddressInfo.Setup(0, 0);
 
             InitializeWaveBuffers();
+
+            _waveBufferUpdaterErrorInfosList ??= [];
         }
 
         /// <summary>
@@ -568,7 +575,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
             PoolMapper mapper,
             ref BehaviourInfo behaviourInfo)
         {
-            errorInfos = new ErrorInfo[Constants.VoiceWaveBufferCount * 2];
+            
 
             if (parameter.IsNew)
             {
@@ -584,11 +591,14 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
             
             Span<WaveBuffer> waveBuffersSpan = WaveBuffers.AsSpan();
             Span<WaveBufferInternal> pWaveBuffersSpan = parameter.WaveBuffers.AsSpan();
+            _waveBufferUpdaterErrorInfosList.Clear();
 
             for (int i = 0; i < Constants.VoiceWaveBufferCount; i++)
             {
-                UpdateWaveBuffer(errorInfos.AsSpan(i * 2, 2), ref waveBuffersSpan[i], ref pWaveBuffersSpan[i], parameter.SampleFormat, voiceState.IsWaveBufferValid[i], mapper, ref behaviourInfo);
+                UpdateWaveBuffer(_waveBufferUpdaterErrorInfosList, ref waveBuffersSpan[i], ref pWaveBuffersSpan[i], parameter.SampleFormat, voiceState.IsWaveBufferValid[i], mapper, ref behaviourInfo);
             }
+            
+            errorInfos = _waveBufferUpdaterErrorInfosList.ToArray();
         }
 
         /// <summary>
@@ -606,7 +616,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
             PoolMapper mapper,
             ref BehaviourInfo behaviourInfo)
         {
-            errorInfos = new ErrorInfo[Constants.VoiceWaveBufferCount * 2];
+            
 
             if (parameter.IsNew)
             {
@@ -622,11 +632,14 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
             
             Span<WaveBuffer> waveBuffersSpan = WaveBuffers.AsSpan();
             Span<WaveBufferInternal> pWaveBuffersSpan = parameter.WaveBuffers.AsSpan();
+            _waveBufferUpdaterErrorInfosList.Clear();
 
             for (int i = 0; i < Constants.VoiceWaveBufferCount; i++)
             {
-                UpdateWaveBuffer(errorInfos.AsSpan(i * 2, 2), ref waveBuffersSpan[i], ref pWaveBuffersSpan[i], parameter.SampleFormat, voiceState.IsWaveBufferValid[i], mapper, ref behaviourInfo);
+                UpdateWaveBuffer(_waveBufferUpdaterErrorInfosList, ref waveBuffersSpan[i], ref pWaveBuffersSpan[i], parameter.SampleFormat, voiceState.IsWaveBufferValid[i], mapper, ref behaviourInfo);
             }
+            
+            errorInfos = _waveBufferUpdaterErrorInfosList.ToArray();
         }
 
         /// <summary>
@@ -640,7 +653,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="mapper">The mapper to use.</param>
         /// <param name="behaviourInfo">The behaviour context.</param>
         private void UpdateWaveBuffer(
-            Span<ErrorInfo> errorInfos,
+            List<ErrorInfo> errorInfos,
             ref WaveBuffer waveBuffer,
             ref WaveBufferInternal inputWaveBuffer,
             SampleFormat sampleFormat,
@@ -671,7 +684,10 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
 
                     BufferInfoUnmapped = !mapper.TryAttachBuffer(out ErrorInfo bufferInfoError, ref waveBuffer.BufferAddressInfo, inputWaveBuffer.Address, inputWaveBuffer.Size);
 
-                    errorInfos[0] = bufferInfoError;
+                    if (bufferInfoError.ErrorCode != ResultCode.Success)
+                    {   
+                        errorInfos.Add(bufferInfoError);
+                    }
 
                     if (sampleFormat == SampleFormat.Adpcm && behaviourInfo.IsAdpcmLoopContextBugFixed() && inputWaveBuffer.ContextAddress != 0)
                     {
@@ -680,7 +696,10 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                                                                              inputWaveBuffer.ContextAddress,
                                                                              inputWaveBuffer.ContextSize);
 
-                        errorInfos[1] = adpcmLoopContextInfoError;
+                        if (adpcmLoopContextInfoError.ErrorCode != ResultCode.Success)
+                        {   
+                            errorInfos.Add(adpcmLoopContextInfoError);
+                        }
 
                         if (!adpcmLoopContextMapped || BufferInfoUnmapped)
                         {
@@ -698,8 +717,11 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 }
                 else
                 {
-                    errorInfos[0].ErrorCode = ResultCode.InvalidAddressInfo;
-                    errorInfos[0].ExtraErrorInfo = inputWaveBuffer.Address;
+                    errorInfos.Add(new ErrorInfo
+                    {
+                        ErrorCode = ResultCode.InvalidAddressInfo, 
+                        ExtraErrorInfo = inputWaveBuffer.Address
+                    });
                 }
             }
         }
@@ -891,7 +913,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 IsNew = false;
             }
 
-            Memory<VoiceState>[] voiceStates = new Memory<VoiceState>[Constants.VoiceChannelCountMax];
+            Memory<VoiceState>[] voiceStates = voiceStatesPool.Allocate();
 
             Span<int> channelResourceIdsSpan = ChannelResourceIds.AsSpan();
             
@@ -900,7 +922,12 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 voiceStates[i] = context.GetUpdateStateForDsp(channelResourceIdsSpan[i]);
             }
 
-            return UpdateParametersForCommandGeneration(voiceStates);
+            bool result = UpdateParametersForCommandGeneration(voiceStates);
+            
+            voiceStatesPool.Release(voiceStates); 
+            //might contain garbage data, but said data will never be accessed
+            
+            return result;
         }
     }
 }

src/Ryujinx.Common/Collections/IntervalTree.cs

@@ -24,7 +24,10 @@ namespace Ryujinx.Common.Collections
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
         public int Get(TKey key, ref TValue[] overlaps)
         {
-            ArgumentNullException.ThrowIfNull(key);
+            if (!typeof(TKey).IsValueType)
+            {
+                ArgumentNullException.ThrowIfNull(key);
+            }
 
             IntervalTreeNode<TKey, TValue> node = GetNode(key);
 
@@ -91,7 +94,10 @@ namespace Ryujinx.Common.Collections
         /// <returns>Number of deleted values</returns>
         public int Remove(TKey key, TValue value)
         {
-            ArgumentNullException.ThrowIfNull(key);
+            if (!typeof(TKey).IsValueType)
+            {
+                ArgumentNullException.ThrowIfNull(key);
+            }
 
             int removed = Delete(key, value);
 
@@ -144,7 +150,10 @@ namespace Ryujinx.Common.Collections
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
         private IntervalTreeNode<TKey, TValue> GetNode(TKey key)
         {
-            ArgumentNullException.ThrowIfNull(key);
+            if (!typeof(TKey).IsValueType)
+            {
+                ArgumentNullException.ThrowIfNull(key);
+            }
 
             IntervalTreeNode<TKey, TValue> node = Root;
             while (node != null)

src/Ryujinx.Common/Logging/LogEventArgsJson.cs

@@ -1,31 +0,0 @@
-using Ryujinx.Common.Logging.Formatters;
-using System;
-using System.Text.Json.Serialization;
-
-namespace Ryujinx.Common.Logging
-{
-    internal class LogEventArgsJson
-    {
-        public LogLevel Level { get; }
-        public TimeSpan Time { get; }
-        public string ThreadName { get; }
-
-        public string Message { get; }
-        public string Data { get; }
-
-        [JsonConstructor]
-        public LogEventArgsJson(LogLevel level, TimeSpan time, string threadName, string message, string data = null)
-        {
-            Level = level;
-            Time = time;
-            ThreadName = threadName;
-            Message = message;
-            Data = data;
-        }
-
-        public static LogEventArgsJson FromLogEventArgs(LogEventArgs args)
-        {
-            return new LogEventArgsJson(args.Level, args.Time, args.ThreadName, args.Message, DynamicObjectFormatter.Format(args.Data));
-        }
-    }
-}

src/Ryujinx.Common/Logging/LogEventJsonSerializerContext.cs

@@ -1,9 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace Ryujinx.Common.Logging
-{
-    [JsonSerializable(typeof(LogEventArgsJson))]
-    internal partial class LogEventJsonSerializerContext : JsonSerializerContext
-    {
-    }
-}

src/Ryujinx.Common/Logging/Logger.cs

@@ -230,14 +230,14 @@ namespace Ryujinx.Common.Logging
             switch (logLevel)
             {
 #pragma warning disable IDE0055 // Disable formatting
-                case LogLevel.Debug     : Debug     = enabled ? new Log(LogLevel.Debug)     : new Log?(); break;
-                case LogLevel.Info      : Info      = enabled ? new Log(LogLevel.Info)      : new Log?(); break;
-                case LogLevel.Warning   : Warning   = enabled ? new Log(LogLevel.Warning)   : new Log?(); break;
-                case LogLevel.Error     : Error     = enabled ? new Log(LogLevel.Error)     : new Log?(); break;
-                case LogLevel.Guest     : Guest     = enabled ? new Log(LogLevel.Guest)     : new Log?(); break;
-                case LogLevel.AccessLog : AccessLog = enabled ? new Log(LogLevel.AccessLog) : new Log?(); break;
-                case LogLevel.Stub      : Stub      = enabled ? new Log(LogLevel.Stub)      : new Log?(); break;
-                case LogLevel.Trace     : Trace     = enabled ? new Log(LogLevel.Trace)     : new Log?(); break;
+                case LogLevel.Debug     : Debug     = enabled ? new Log(LogLevel.Debug)     : null; break;
+                case LogLevel.Info      : Info      = enabled ? new Log(LogLevel.Info)      : null; break;
+                case LogLevel.Warning   : Warning   = enabled ? new Log(LogLevel.Warning)   : null; break;
+                case LogLevel.Error     : Error     = enabled ? new Log(LogLevel.Error)     : null; break;
+                case LogLevel.Guest     : Guest     = enabled ? new Log(LogLevel.Guest)     : null; break;
+                case LogLevel.AccessLog : AccessLog = enabled ? new Log(LogLevel.AccessLog) : null; break;
+                case LogLevel.Stub      : Stub      = enabled ? new Log(LogLevel.Stub)      : null; break;
+                case LogLevel.Trace     : Trace     = enabled ? new Log(LogLevel.Trace)     : null; break;
                 case LogLevel.Notice    : break;
                 default: throw new ArgumentException("Unknown Log Level", nameof(logLevel));
 #pragma warning restore IDE0055

src/Ryujinx.Common/Logging/Targets/JsonLogTarget.cs

@@ -1,42 +0,0 @@
-using Ryujinx.Common.Utilities;
-using System;
-using System.IO;
-
-namespace Ryujinx.Common.Logging.Targets
-{
-    public class JsonLogTarget : ILogTarget
-    {
-        private readonly Stream _stream;
-        private readonly bool _leaveOpen;
-        private readonly string _name;
-
-        string ILogTarget.Name { get => _name; }
-
-        public JsonLogTarget(Stream stream, string name)
-        {
-            _stream = stream;
-            _name = name;
-        }
-
-        public JsonLogTarget(Stream stream, bool leaveOpen)
-        {
-            _stream = stream;
-            _leaveOpen = leaveOpen;
-        }
-
-        public void Log(object sender, LogEventArgs e)
-        {
-            LogEventArgsJson logEventArgsJson = LogEventArgsJson.FromLogEventArgs(e);
-            JsonHelper.SerializeToStream(_stream, logEventArgsJson, LogEventJsonSerializerContext.Default.LogEventArgsJson);
-        }
-
-        public void Dispose()
-        {
-            GC.SuppressFinalize(this);
-            if (!_leaveOpen)
-            {
-                _stream.Dispose();
-            }
-        }
-    }
-}

src/Ryujinx.Common/Pools/ObjectPool.cs

@@ -1,67 +1,34 @@
 using System;
-using System.Threading;
+using System.Collections.Concurrent;
 
 namespace Ryujinx.Common
 {
-    public class ObjectPool<T>(Func<T> factory, int size)
+    public class ObjectPool<T>(Func<T> factory, int size = -1)
         where T : class
     {
-        private T _firstItem;
-        private readonly T[] _items = new T[size - 1];
+        private int _size = size;
+        private readonly ConcurrentBag<T> _items = new();
 
         public T Allocate()
         {
-            T instance = _firstItem;
+            bool success = _items.TryTake(out T instance);
 
-            if (instance == null || instance != Interlocked.CompareExchange(ref _firstItem, null, instance))
+            if (!success)
             {
-                instance = AllocateInternal();
+                instance =  factory();
             }
 
             return instance;
         }
 
-        private T AllocateInternal()
-        {
-            T[] items = _items;
-
-            for (int i = 0; i < items.Length; i++)
-            {
-                T instance = items[i];
-
-                if (instance != null && instance == Interlocked.CompareExchange(ref items[i], null, instance))
-                {
-                    return instance;
-                }
-            }
-
-            return factory();
-        }
-
         public void Release(T obj)
         {
-            if (_firstItem == null)
+            if (_size < 0 || _items.Count < _size)
             {
-                _firstItem = obj;
-            }
-            else
-            {
-                ReleaseInternal(obj);
-            }
-        }
-
-        private void ReleaseInternal(T obj)
-        {
-            T[] items = _items;
-
-            for (int i = 0; i < items.Length; i++)
-            {
-                if (items[i] == null)
-                {
-                    items[i] = obj;
-                    break;
-                }
+                _items.Add(obj);
             }
         }
+        
+        public void Clear() => _items.Clear();
     }
 }

src/Ryujinx.Common/ReferenceEqualityComparer.cs

@@ -1,19 +0,0 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-
-namespace Ryujinx.Common
-{
-    public class ReferenceEqualityComparer<T> : IEqualityComparer<T>
-        where T : class
-    {
-        public bool Equals(T x, T y)
-        {
-            return x == y;
-        }
-
-        public int GetHashCode([DisallowNull] T obj)
-        {
-            return obj.GetHashCode();
-        }
-    }
-}

src/Ryujinx.Common/ReleaseInformation.cs

@@ -1,10 +1,5 @@
-using Ryujinx.Common.Utilities;
 using System;
-using System.Net.Http;
-using System.Net.Http.Json;
 using System.Reflection;
-using System.Text.Json.Serialization;
-using System.Threading.Tasks;
 
 namespace Ryujinx.Common
 {

src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs

@@ -151,6 +151,11 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
+        public override bool TryReadUnsafe(ulong va, int length, out Span<byte> data)
+        {
+            throw new NotImplementedException();
+        }
+
         public override void Write(ulong va, ReadOnlySpan<byte> data)
         {
             try

src/Ryujinx.Cpu/IExecutionContext.cs

@@ -1,6 +1,5 @@
 using ARMeilleure.State;
 using System;
-using System.Threading;
 
 namespace Ryujinx.Cpu
 {

src/Ryujinx.Cpu/Jit/MemoryManager.cs

@@ -174,6 +174,11 @@ namespace Ryujinx.Cpu.Jit
                 }
             }
         }
+        
+        public override bool TryReadUnsafe(ulong va, int length, out Span<byte> data)
+        {
+            throw new NotImplementedException();
+        }
 
         public override void Write(ulong va, ReadOnlySpan<byte> data)
         {

src/Ryujinx.Cpu/Jit/MemoryManagerHostMapped.cs

@@ -151,6 +151,11 @@ namespace Ryujinx.Cpu.Jit
                 return default;
             }
         }
+        
+        public override bool TryReadUnsafe(ulong va, int length, out Span<byte> data)
+        {
+            throw new NotImplementedException();
+        }
 
         public override T ReadTracked<T>(ulong va)
         {

src/Ryujinx.Cpu/Jit/MemoryManagerHostTracked.cs

@@ -227,6 +227,11 @@ namespace Ryujinx.Cpu.Jit
                 }
             }
         }
+        
+        public override bool TryReadUnsafe(ulong va, int length, out Span<byte> data)
+        {
+            throw new NotImplementedException();
+        }
 
         public override bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
         {

src/Ryujinx.Cpu/LightningJit/State/ExecutionContext.cs

@@ -1,4 +1,3 @@
-using ARMeilleure;
 using ARMeilleure.Memory;
 using ARMeilleure.State;
 using System;

src/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetsCommand.cs

@@ -1,11 +1,12 @@
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
-using System.Linq;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
     struct SetRenderTargetsCommand : IGALCommand, IGALCommand<SetRenderTargetsCommand>
     {
+        public static readonly ArrayPool<ITexture> ArrayPool = ArrayPool<ITexture>.Create(512, 50);
         public readonly CommandType CommandType => CommandType.SetRenderTargets;
         private TableRef<ITexture[]> _colors;
         private TableRef<ITexture> _depthStencil;
@@ -18,7 +19,18 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 
         public static void Run(ref SetRenderTargetsCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
-            renderer.Pipeline.SetRenderTargets(command._colors.Get(threaded).Select(color => ((ThreadedTexture)color)?.Base).ToArray(), command._depthStencil.GetAs<ThreadedTexture>(threaded)?.Base);
+            ITexture[] colors = command._colors.Get(threaded);
+            ITexture[] colorsCopy = ArrayPool.Rent(colors.Length);
+
+            for (int i = 0; i < colors.Length; i++)
+            {
+                colorsCopy[i] = ((ThreadedTexture)colors[i])?.Base;
+            }
+            
+            renderer.Pipeline.SetRenderTargets(colorsCopy, command._depthStencil.GetAs<ThreadedTexture>(threaded)?.Base);
+            
+            ArrayPool.Return(colorsCopy);
+            ArrayPool.Return(colors);
         }
     }
 }

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedCounterEvent.cs

@@ -29,9 +29,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            _renderer.New<CounterEventDisposeCommand>().Set(Ref(this));
+            _renderer.New<CounterEventDisposeCommand>()->Set(Ref(this));
             _renderer.QueueCommand();
         }
 

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedImageArray.cs

@@ -21,15 +21,15 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            _renderer.New<ImageArrayDisposeCommand>().Set(Ref(this));
+            _renderer.New<ImageArrayDisposeCommand>()->Set(Ref(this));
             _renderer.QueueCommand();
         }
 
-        public void SetImages(int index, ITexture[] images)
+        public unsafe void SetImages(int index, ITexture[] images)
         {
-            _renderer.New<ImageArraySetImagesCommand>().Set(Ref(this), index, Ref(images));
+            _renderer.New<ImageArraySetImagesCommand>()->Set(Ref(this), index, Ref(images));
             _renderer.QueueCommand();
         }
     }

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedProgram.cs

@@ -21,25 +21,25 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            _renderer.New<ProgramDisposeCommand>().Set(Ref(this));
+            _renderer.New<ProgramDisposeCommand>()->Set(Ref(this));
             _renderer.QueueCommand();
         }
 
-        public byte[] GetBinary()
+        public unsafe byte[] GetBinary()
         {
             ResultBox<byte[]> box = new();
-            _renderer.New<ProgramGetBinaryCommand>().Set(Ref(this), Ref(box));
+            _renderer.New<ProgramGetBinaryCommand>()->Set(Ref(this), Ref(box));
             _renderer.InvokeCommand();
 
             return box.Result;
         }
 
-        public ProgramLinkStatus CheckProgramLink(bool blocking)
+        public unsafe ProgramLinkStatus CheckProgramLink(bool blocking)
         {
             ResultBox<ProgramLinkStatus> box = new();
-            _renderer.New<ProgramCheckLinkCommand>().Set(Ref(this), blocking, Ref(box));
+            _renderer.New<ProgramCheckLinkCommand>()->Set(Ref(this), blocking, Ref(box));
             _renderer.InvokeCommand();
 
             return box.Result;

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedSampler.cs

@@ -13,9 +13,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             _renderer = renderer;
         }
 
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            _renderer.New<SamplerDisposeCommand>().Set(new TableRef<ThreadedSampler>(_renderer, this));
+            _renderer.New<SamplerDisposeCommand>()->Set(new TableRef<ThreadedSampler>(_renderer, this));
             _renderer.QueueCommand();
         }
     }

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedTexture.cs

@@ -28,25 +28,25 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void CopyTo(ITexture destination, int firstLayer, int firstLevel)
+        public unsafe void CopyTo(ITexture destination, int firstLayer, int firstLevel)
         {
-            _renderer.New<TextureCopyToCommand>().Set(Ref(this), Ref((ThreadedTexture)destination), firstLayer, firstLevel);
+            _renderer.New<TextureCopyToCommand>()->Set(Ref(this), Ref((ThreadedTexture)destination), firstLayer, firstLevel);
             _renderer.QueueCommand();
         }
 
-        public void CopyTo(ITexture destination, int srcLayer, int dstLayer, int srcLevel, int dstLevel)
+        public unsafe void CopyTo(ITexture destination, int srcLayer, int dstLayer, int srcLevel, int dstLevel)
         {
-            _renderer.New<TextureCopyToSliceCommand>().Set(Ref(this), Ref((ThreadedTexture)destination), srcLayer, dstLayer, srcLevel, dstLevel);
+            _renderer.New<TextureCopyToSliceCommand>()->Set(Ref(this), Ref((ThreadedTexture)destination), srcLayer, dstLayer, srcLevel, dstLevel);
             _renderer.QueueCommand();
         }
 
-        public void CopyTo(ITexture destination, Extents2D srcRegion, Extents2D dstRegion, bool linearFilter)
+        public unsafe void CopyTo(ITexture destination, Extents2D srcRegion, Extents2D dstRegion, bool linearFilter)
         {
             ThreadedTexture dest = (ThreadedTexture)destination;
 
             if (_renderer.IsGpuThread())
             {
-                _renderer.New<TextureCopyToScaledCommand>().Set(Ref(this), Ref(dest), srcRegion, dstRegion, linearFilter);
+                _renderer.New<TextureCopyToScaledCommand>()->Set(Ref(this), Ref(dest), srcRegion, dstRegion, linearFilter);
                 _renderer.QueueCommand();
             }
             else
@@ -59,21 +59,21 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             }
         }
 
-        public ITexture CreateView(TextureCreateInfo info, int firstLayer, int firstLevel)
+        public unsafe ITexture CreateView(TextureCreateInfo info, int firstLayer, int firstLevel)
         {
             ThreadedTexture newTex = new(_renderer, info);
-            _renderer.New<TextureCreateViewCommand>().Set(Ref(this), Ref(newTex), info, firstLayer, firstLevel);
+            _renderer.New<TextureCreateViewCommand>()->Set(Ref(this), Ref(newTex), info, firstLayer, firstLevel);
             _renderer.QueueCommand();
 
             return newTex;
         }
 
-        public PinnedSpan<byte> GetData()
+        public unsafe PinnedSpan<byte> GetData()
         {
             if (_renderer.IsGpuThread())
             {
                 ResultBox<PinnedSpan<byte>> box = new();
-                _renderer.New<TextureGetDataCommand>().Set(Ref(this), Ref(box));
+                _renderer.New<TextureGetDataCommand>()->Set(Ref(this), Ref(box));
                 _renderer.InvokeCommand();
 
                 return box.Result;
@@ -86,12 +86,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             }
         }
 
-        public PinnedSpan<byte> GetData(int layer, int level)
+        public unsafe PinnedSpan<byte> GetData(int layer, int level)
         {
             if (_renderer.IsGpuThread())
             {
                 ResultBox<PinnedSpan<byte>> box = new();
-                _renderer.New<TextureGetDataSliceCommand>().Set(Ref(this), Ref(box), layer, level);
+                _renderer.New<TextureGetDataSliceCommand>()->Set(Ref(this), Ref(box), layer, level);
                 _renderer.InvokeCommand();
 
                 return box.Result;
@@ -104,42 +104,42 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             }
         }
 
-        public void CopyTo(BufferRange range, int layer, int level, int stride)
+        public unsafe void CopyTo(BufferRange range, int layer, int level, int stride)
         {
-            _renderer.New<TextureCopyToBufferCommand>().Set(Ref(this), range, layer, level, stride);
+            _renderer.New<TextureCopyToBufferCommand>()->Set(Ref(this), range, layer, level, stride);
             _renderer.QueueCommand();
         }
 
         /// <inheritdoc/>
-        public void SetData(MemoryOwner<byte> data)
+        public unsafe void SetData(MemoryOwner<byte> data)
         {
-            _renderer.New<TextureSetDataCommand>().Set(Ref(this), Ref(data));
+            _renderer.New<TextureSetDataCommand>()->Set(Ref(this), Ref(data));
             _renderer.QueueCommand();
         }
 
         /// <inheritdoc/>
-        public void SetData(MemoryOwner<byte> data, int layer, int level)
+        public unsafe void SetData(MemoryOwner<byte> data, int layer, int level)
         {
-            _renderer.New<TextureSetDataSliceCommand>().Set(Ref(this), Ref(data), layer, level);
+            _renderer.New<TextureSetDataSliceCommand>()->Set(Ref(this), Ref(data), layer, level);
             _renderer.QueueCommand();
         }
 
         /// <inheritdoc/>
-        public void SetData(MemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
+        public unsafe void SetData(MemoryOwner<byte> data, int layer, int level, Rectangle<int> region)
         {
-            _renderer.New<TextureSetDataSliceRegionCommand>().Set(Ref(this), Ref(data), layer, level, region);
+            _renderer.New<TextureSetDataSliceRegionCommand>()->Set(Ref(this), Ref(data), layer, level, region);
             _renderer.QueueCommand();
         }
 
-        public void SetStorage(BufferRange buffer)
+        public unsafe void SetStorage(BufferRange buffer)
         {
-            _renderer.New<TextureSetStorageCommand>().Set(Ref(this), buffer);
+            _renderer.New<TextureSetStorageCommand>()->Set(Ref(this), buffer);
             _renderer.QueueCommand();
         }
 
-        public void Release()
+        public unsafe void Release()
         {
-            _renderer.New<TextureReleaseCommand>().Set(Ref(this));
+            _renderer.New<TextureReleaseCommand>()->Set(Ref(this));
             _renderer.QueueCommand();
         }
     }

src/Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedTextureArray.cs

@@ -22,21 +22,21 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void Dispose()
+        public unsafe void Dispose()
         {
-            _renderer.New<TextureArrayDisposeCommand>().Set(Ref(this));
+            _renderer.New<TextureArrayDisposeCommand>()->Set(Ref(this));
             _renderer.QueueCommand();
         }
 
-        public void SetSamplers(int index, ISampler[] samplers)
+        public unsafe void SetSamplers(int index, ISampler[] samplers)
         {
-            _renderer.New<TextureArraySetSamplersCommand>().Set(Ref(this), index, Ref(samplers.ToArray()));
+            _renderer.New<TextureArraySetSamplersCommand>()->Set(Ref(this), index, Ref(samplers.ToArray()));
             _renderer.QueueCommand();
         }
 
-        public void SetTextures(int index, ITexture[] textures)
+        public unsafe void SetTextures(int index, ITexture[] textures)
         {
-            _renderer.New<TextureArraySetTexturesCommand>().Set(Ref(this), index, Ref(textures.ToArray()));
+            _renderer.New<TextureArraySetTexturesCommand>()->Set(Ref(this), index, Ref(textures.ToArray()));
             _renderer.QueueCommand();
         }
     }

src/Ryujinx.Graphics.GAL/Multithreading/ThreadedPipeline.cs

@@ -21,343 +21,346 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return new TableRef<T>(_renderer, reference);
         }
 
-        public void Barrier()
+        public unsafe void Barrier()
         {
             _renderer.New<BarrierCommand>();
             _renderer.QueueCommand();
         }
 
-        public void BeginTransformFeedback(PrimitiveTopology topology)
+        public unsafe void BeginTransformFeedback(PrimitiveTopology topology)
         {
-            _renderer.New<BeginTransformFeedbackCommand>().Set(topology);
+            _renderer.New<BeginTransformFeedbackCommand>()->Set(topology);
             _renderer.QueueCommand();
         }
 
-        public void ClearBuffer(BufferHandle destination, int offset, int size, uint value)
+        public unsafe void ClearBuffer(BufferHandle destination, int offset, int size, uint value)
         {
-            _renderer.New<ClearBufferCommand>().Set(destination, offset, size, value);
+            _renderer.New<ClearBufferCommand>()->Set(destination, offset, size, value);
             _renderer.QueueCommand();
         }
 
-        public void ClearRenderTargetColor(int index, int layer, int layerCount, uint componentMask, ColorF color)
+        public unsafe void ClearRenderTargetColor(int index, int layer, int layerCount, uint componentMask, ColorF color)
         {
-            _renderer.New<ClearRenderTargetColorCommand>().Set(index, layer, layerCount, componentMask, color);
+            _renderer.New<ClearRenderTargetColorCommand>()->Set(index, layer, layerCount, componentMask, color);
             _renderer.QueueCommand();
         }
 
-        public void ClearRenderTargetDepthStencil(int layer, int layerCount, float depthValue, bool depthMask, int stencilValue, int stencilMask)
+        public unsafe void ClearRenderTargetDepthStencil(int layer, int layerCount, float depthValue, bool depthMask, int stencilValue, int stencilMask)
         {
-            _renderer.New<ClearRenderTargetDepthStencilCommand>().Set(layer, layerCount, depthValue, depthMask, stencilValue, stencilMask);
+            _renderer.New<ClearRenderTargetDepthStencilCommand>()->Set(layer, layerCount, depthValue, depthMask, stencilValue, stencilMask);
             _renderer.QueueCommand();
         }
 
-        public void CommandBufferBarrier()
+        public unsafe void CommandBufferBarrier()
         {
             _renderer.New<CommandBufferBarrierCommand>();
             _renderer.QueueCommand();
         }
 
-        public void CopyBuffer(BufferHandle source, BufferHandle destination, int srcOffset, int dstOffset, int size)
+        public unsafe void CopyBuffer(BufferHandle source, BufferHandle destination, int srcOffset, int dstOffset, int size)
         {
-            _renderer.New<CopyBufferCommand>().Set(source, destination, srcOffset, dstOffset, size);
+            _renderer.New<CopyBufferCommand>()->Set(source, destination, srcOffset, dstOffset, size);
             _renderer.QueueCommand();
         }
 
-        public void DispatchCompute(int groupsX, int groupsY, int groupsZ)
+        public unsafe void DispatchCompute(int groupsX, int groupsY, int groupsZ)
         {
-            _renderer.New<DispatchComputeCommand>().Set(groupsX, groupsY, groupsZ);
+            _renderer.New<DispatchComputeCommand>()->Set(groupsX, groupsY, groupsZ);
             _renderer.QueueCommand();
         }
 
-        public void Draw(int vertexCount, int instanceCount, int firstVertex, int firstInstance)
+        public unsafe void Draw(int vertexCount, int instanceCount, int firstVertex, int firstInstance)
         {
-            _renderer.New<DrawCommand>().Set(vertexCount, instanceCount, firstVertex, firstInstance);
+            _renderer.New<DrawCommand>()->Set(vertexCount, instanceCount, firstVertex, firstInstance);
             _renderer.QueueCommand();
         }
 
-        public void DrawIndexed(int indexCount, int instanceCount, int firstIndex, int firstVertex, int firstInstance)
+        public unsafe void DrawIndexed(int indexCount, int instanceCount, int firstIndex, int firstVertex, int firstInstance)
         {
-            _renderer.New<DrawIndexedCommand>().Set(indexCount, instanceCount, firstIndex, firstVertex, firstInstance);
+            _renderer.New<DrawIndexedCommand>()->Set(indexCount, instanceCount, firstIndex, firstVertex, firstInstance);
             _renderer.QueueCommand();
         }
 
-        public void DrawIndexedIndirect(BufferRange indirectBuffer)
+        public unsafe void DrawIndexedIndirect(BufferRange indirectBuffer)
         {
-            _renderer.New<DrawIndexedIndirectCommand>().Set(indirectBuffer);
+            _renderer.New<DrawIndexedIndirectCommand>()->Set(indirectBuffer);
             _renderer.QueueCommand();
         }
 
-        public void DrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
+        public unsafe void DrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
         {
-            _renderer.New<DrawIndexedIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+            _renderer.New<DrawIndexedIndirectCountCommand>()->Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
             _renderer.QueueCommand();
         }
 
-        public void DrawIndirect(BufferRange indirectBuffer)
+        public unsafe void DrawIndirect(BufferRange indirectBuffer)
         {
-            _renderer.New<DrawIndirectCommand>().Set(indirectBuffer);
+            _renderer.New<DrawIndirectCommand>()->Set(indirectBuffer);
             _renderer.QueueCommand();
         }
 
-        public void DrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
+        public unsafe void DrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
         {
-            _renderer.New<DrawIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+            _renderer.New<DrawIndirectCountCommand>()->Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
             _renderer.QueueCommand();
         }
 
-        public void DrawTexture(ITexture texture, ISampler sampler, Extents2DF srcRegion, Extents2DF dstRegion)
+        public unsafe void DrawTexture(ITexture texture, ISampler sampler, Extents2DF srcRegion, Extents2DF dstRegion)
         {
-            _renderer.New<DrawTextureCommand>().Set(Ref(texture), Ref(sampler), srcRegion, dstRegion);
+            _renderer.New<DrawTextureCommand>()->Set(Ref(texture), Ref(sampler), srcRegion, dstRegion);
             _renderer.QueueCommand();
         }
 
-        public void EndHostConditionalRendering()
+        public unsafe void EndHostConditionalRendering()
         {
             _renderer.New<EndHostConditionalRenderingCommand>();
             _renderer.QueueCommand();
         }
 
-        public void EndTransformFeedback()
+        public unsafe void EndTransformFeedback()
         {
             _renderer.New<EndTransformFeedbackCommand>();
             _renderer.QueueCommand();
         }
 
-        public void SetAlphaTest(bool enable, float reference, CompareOp op)
+        public unsafe void SetAlphaTest(bool enable, float reference, CompareOp op)
         {
-            _renderer.New<SetAlphaTestCommand>().Set(enable, reference, op);
+            _renderer.New<SetAlphaTestCommand>()->Set(enable, reference, op);
             _renderer.QueueCommand();
         }
 
-        public void SetBlendState(AdvancedBlendDescriptor blend)
+        public unsafe void SetBlendState(AdvancedBlendDescriptor blend)
         {
-            _renderer.New<SetBlendStateAdvancedCommand>().Set(blend);
+            _renderer.New<SetBlendStateAdvancedCommand>()->Set(blend);
             _renderer.QueueCommand();
         }
 
-        public void SetBlendState(int index, BlendDescriptor blend)
+        public unsafe void SetBlendState(int index, BlendDescriptor blend)
         {
-            _renderer.New<SetBlendStateCommand>().Set(index, blend);
+            _renderer.New<SetBlendStateCommand>()->Set(index, blend);
             _renderer.QueueCommand();
         }
 
-        public void SetDepthBias(PolygonModeMask enables, float factor, float units, float clamp)
+        public unsafe void SetDepthBias(PolygonModeMask enables, float factor, float units, float clamp)
         {
-            _renderer.New<SetDepthBiasCommand>().Set(enables, factor, units, clamp);
+            _renderer.New<SetDepthBiasCommand>()->Set(enables, factor, units, clamp);
             _renderer.QueueCommand();
         }
 
-        public void SetDepthClamp(bool clamp)
+        public unsafe void SetDepthClamp(bool clamp)
         {
-            _renderer.New<SetDepthClampCommand>().Set(clamp);
+            _renderer.New<SetDepthClampCommand>()->Set(clamp);
             _renderer.QueueCommand();
         }
 
-        public void SetDepthMode(DepthMode mode)
+        public unsafe void SetDepthMode(DepthMode mode)
         {
-            _renderer.New<SetDepthModeCommand>().Set(mode);
+            _renderer.New<SetDepthModeCommand>()->Set(mode);
             _renderer.QueueCommand();
         }
 
-        public void SetDepthTest(DepthTestDescriptor depthTest)
+        public unsafe void SetDepthTest(DepthTestDescriptor depthTest)
         {
-            _renderer.New<SetDepthTestCommand>().Set(depthTest);
+            _renderer.New<SetDepthTestCommand>()->Set(depthTest);
             _renderer.QueueCommand();
         }
 
-        public void SetFaceCulling(bool enable, Face face)
+        public unsafe void SetFaceCulling(bool enable, Face face)
         {
-            _renderer.New<SetFaceCullingCommand>().Set(enable, face);
+            _renderer.New<SetFaceCullingCommand>()->Set(enable, face);
             _renderer.QueueCommand();
         }
 
-        public void SetFrontFace(FrontFace frontFace)
+        public unsafe void SetFrontFace(FrontFace frontFace)
         {
-            _renderer.New<SetFrontFaceCommand>().Set(frontFace);
+            _renderer.New<SetFrontFaceCommand>()->Set(frontFace);
             _renderer.QueueCommand();
         }
 
-        public void SetImage(ShaderStage stage, int binding, ITexture texture)
+        public unsafe void SetImage(ShaderStage stage, int binding, ITexture texture)
         {
-            _renderer.New<SetImageCommand>().Set(stage, binding, Ref(texture));
+            _renderer.New<SetImageCommand>()->Set(stage, binding, Ref(texture));
             _renderer.QueueCommand();
         }
 
-        public void SetImageArray(ShaderStage stage, int binding, IImageArray array)
+        public unsafe void SetImageArray(ShaderStage stage, int binding, IImageArray array)
         {
-            _renderer.New<SetImageArrayCommand>().Set(stage, binding, Ref(array));
+            _renderer.New<SetImageArrayCommand>()->Set(stage, binding, Ref(array));
             _renderer.QueueCommand();
         }
 
-        public void SetImageArraySeparate(ShaderStage stage, int setIndex, IImageArray array)
+        public unsafe void SetImageArraySeparate(ShaderStage stage, int setIndex, IImageArray array)
         {
-            _renderer.New<SetImageArraySeparateCommand>().Set(stage, setIndex, Ref(array));
+            _renderer.New<SetImageArraySeparateCommand>()->Set(stage, setIndex, Ref(array));
             _renderer.QueueCommand();
         }
 
-        public void SetIndexBuffer(BufferRange buffer, IndexType type)
+        public unsafe void SetIndexBuffer(BufferRange buffer, IndexType type)
         {
-            _renderer.New<SetIndexBufferCommand>().Set(buffer, type);
+            _renderer.New<SetIndexBufferCommand>()->Set(buffer, type);
             _renderer.QueueCommand();
         }
 
-        public void SetLineParameters(float width, bool smooth)
+        public unsafe void SetLineParameters(float width, bool smooth)
         {
-            _renderer.New<SetLineParametersCommand>().Set(width, smooth);
+            _renderer.New<SetLineParametersCommand>()->Set(width, smooth);
             _renderer.QueueCommand();
         }
 
-        public void SetLogicOpState(bool enable, LogicalOp op)
+        public unsafe void SetLogicOpState(bool enable, LogicalOp op)
         {
-            _renderer.New<SetLogicOpStateCommand>().Set(enable, op);
+            _renderer.New<SetLogicOpStateCommand>()->Set(enable, op);
             _renderer.QueueCommand();
         }
 
-        public void SetMultisampleState(MultisampleDescriptor multisample)
+        public unsafe void SetMultisampleState(MultisampleDescriptor multisample)
         {
-            _renderer.New<SetMultisampleStateCommand>().Set(multisample);
+            _renderer.New<SetMultisampleStateCommand>()->Set(multisample);
             _renderer.QueueCommand();
         }
 
-        public void SetPatchParameters(int vertices, ReadOnlySpan<float> defaultOuterLevel, ReadOnlySpan<float> defaultInnerLevel)
+        public unsafe void SetPatchParameters(int vertices, ReadOnlySpan<float> defaultOuterLevel, ReadOnlySpan<float> defaultInnerLevel)
         {
-            _renderer.New<SetPatchParametersCommand>().Set(vertices, defaultOuterLevel, defaultInnerLevel);
+            _renderer.New<SetPatchParametersCommand>()->Set(vertices, defaultOuterLevel, defaultInnerLevel);
             _renderer.QueueCommand();
         }
 
-        public void SetPointParameters(float size, bool isProgramPointSize, bool enablePointSprite, Origin origin)
+        public unsafe void SetPointParameters(float size, bool isProgramPointSize, bool enablePointSprite, Origin origin)
         {
-            _renderer.New<SetPointParametersCommand>().Set(size, isProgramPointSize, enablePointSprite, origin);
+            _renderer.New<SetPointParametersCommand>()->Set(size, isProgramPointSize, enablePointSprite, origin);
             _renderer.QueueCommand();
         }
 
-        public void SetPolygonMode(PolygonMode frontMode, PolygonMode backMode)
+        public unsafe void SetPolygonMode(PolygonMode frontMode, PolygonMode backMode)
         {
-            _renderer.New<SetPolygonModeCommand>().Set(frontMode, backMode);
+            _renderer.New<SetPolygonModeCommand>()->Set(frontMode, backMode);
             _renderer.QueueCommand();
         }
 
-        public void SetPrimitiveRestart(bool enable, int index)
+        public unsafe void SetPrimitiveRestart(bool enable, int index)
         {
-            _renderer.New<SetPrimitiveRestartCommand>().Set(enable, index);
+            _renderer.New<SetPrimitiveRestartCommand>()->Set(enable, index);
             _renderer.QueueCommand();
         }
 
-        public void SetPrimitiveTopology(PrimitiveTopology topology)
+        public unsafe void SetPrimitiveTopology(PrimitiveTopology topology)
         {
-            _renderer.New<SetPrimitiveTopologyCommand>().Set(topology);
+            _renderer.New<SetPrimitiveTopologyCommand>()->Set(topology);
             _renderer.QueueCommand();
         }
 
-        public void SetProgram(IProgram program)
+        public unsafe void SetProgram(IProgram program)
         {
-            _renderer.New<SetProgramCommand>().Set(Ref(program));
+            _renderer.New<SetProgramCommand>()->Set(Ref(program));
             _renderer.QueueCommand();
         }
 
-        public void SetRasterizerDiscard(bool discard)
+        public unsafe void SetRasterizerDiscard(bool discard)
         {
-            _renderer.New<SetRasterizerDiscardCommand>().Set(discard);
+            _renderer.New<SetRasterizerDiscardCommand>()->Set(discard);
             _renderer.QueueCommand();
         }
 
-        public void SetRenderTargetColorMasks(ReadOnlySpan<uint> componentMask)
+        public unsafe void SetRenderTargetColorMasks(ReadOnlySpan<uint> componentMask)
         {
-            _renderer.New<SetRenderTargetColorMasksCommand>().Set(_renderer.CopySpan(componentMask));
+            _renderer.New<SetRenderTargetColorMasksCommand>()->Set(_renderer.CopySpan(componentMask));
             _renderer.QueueCommand();
         }
 
-        public void SetRenderTargets(ITexture[] colors, ITexture depthStencil)
+        public unsafe void SetRenderTargets(ITexture[] colors, ITexture depthStencil)
         {
-            _renderer.New<SetRenderTargetsCommand>().Set(Ref(colors.ToArray()), Ref(depthStencil));
+            ITexture[] colorsCopy = SetRenderTargetsCommand.ArrayPool.Rent(colors.Length);
+            colors.CopyTo(colorsCopy, 0);
+            
+            _renderer.New<SetRenderTargetsCommand>()->Set(Ref(colorsCopy), Ref(depthStencil));
             _renderer.QueueCommand();
         }
 
-        public void SetScissors(ReadOnlySpan<Rectangle<int>> scissors)
+        public unsafe void SetScissors(ReadOnlySpan<Rectangle<int>> scissors)
         {
-            _renderer.New<SetScissorsCommand>().Set(_renderer.CopySpan(scissors));
+            _renderer.New<SetScissorsCommand>()->Set(_renderer.CopySpan(scissors));
             _renderer.QueueCommand();
         }
 
-        public void SetStencilTest(StencilTestDescriptor stencilTest)
+        public unsafe void SetStencilTest(StencilTestDescriptor stencilTest)
         {
-            _renderer.New<SetStencilTestCommand>().Set(stencilTest);
+            _renderer.New<SetStencilTestCommand>()->Set(stencilTest);
             _renderer.QueueCommand();
         }
 
-        public void SetStorageBuffers(ReadOnlySpan<BufferAssignment> buffers)
+        public unsafe void SetStorageBuffers(ReadOnlySpan<BufferAssignment> buffers)
         {
-            _renderer.New<SetStorageBuffersCommand>().Set(_renderer.CopySpan(buffers));
+            _renderer.New<SetStorageBuffersCommand>()->Set(_renderer.CopySpan(buffers));
             _renderer.QueueCommand();
         }
 
-        public void SetTextureAndSampler(ShaderStage stage, int binding, ITexture texture, ISampler sampler)
+        public unsafe void SetTextureAndSampler(ShaderStage stage, int binding, ITexture texture, ISampler sampler)
         {
-            _renderer.New<SetTextureAndSamplerCommand>().Set(stage, binding, Ref(texture), Ref(sampler));
+            _renderer.New<SetTextureAndSamplerCommand>()->Set(stage, binding, Ref(texture), Ref(sampler));
             _renderer.QueueCommand();
         }
 
-        public void SetTextureArray(ShaderStage stage, int binding, ITextureArray array)
+        public unsafe void SetTextureArray(ShaderStage stage, int binding, ITextureArray array)
         {
-            _renderer.New<SetTextureArrayCommand>().Set(stage, binding, Ref(array));
+            _renderer.New<SetTextureArrayCommand>()->Set(stage, binding, Ref(array));
             _renderer.QueueCommand();
         }
 
-        public void SetTextureArraySeparate(ShaderStage stage, int setIndex, ITextureArray array)
+        public unsafe void SetTextureArraySeparate(ShaderStage stage, int setIndex, ITextureArray array)
         {
-            _renderer.New<SetTextureArraySeparateCommand>().Set(stage, setIndex, Ref(array));
+            _renderer.New<SetTextureArraySeparateCommand>()->Set(stage, setIndex, Ref(array));
             _renderer.QueueCommand();
         }
 
-        public void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers)
+        public unsafe void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers)
         {
-            _renderer.New<SetTransformFeedbackBuffersCommand>().Set(_renderer.CopySpan(buffers));
+            _renderer.New<SetTransformFeedbackBuffersCommand>()->Set(_renderer.CopySpan(buffers));
             _renderer.QueueCommand();
         }
 
-        public void SetUniformBuffers(ReadOnlySpan<BufferAssignment> buffers)
+        public unsafe void SetUniformBuffers(ReadOnlySpan<BufferAssignment> buffers)
         {
-            _renderer.New<SetUniformBuffersCommand>().Set(_renderer.CopySpan(buffers));
+            _renderer.New<SetUniformBuffersCommand>()->Set(_renderer.CopySpan(buffers));
             _renderer.QueueCommand();
         }
 
-        public void SetUserClipDistance(int index, bool enableClip)
+        public unsafe void SetUserClipDistance(int index, bool enableClip)
         {
-            _renderer.New<SetUserClipDistanceCommand>().Set(index, enableClip);
+            _renderer.New<SetUserClipDistanceCommand>()->Set(index, enableClip);
             _renderer.QueueCommand();
         }
 
-        public void SetVertexAttribs(ReadOnlySpan<VertexAttribDescriptor> vertexAttribs)
+        public unsafe void SetVertexAttribs(ReadOnlySpan<VertexAttribDescriptor> vertexAttribs)
         {
-            _renderer.New<SetVertexAttribsCommand>().Set(_renderer.CopySpan(vertexAttribs));
+            _renderer.New<SetVertexAttribsCommand>()->Set(_renderer.CopySpan(vertexAttribs));
             _renderer.QueueCommand();
         }
 
-        public void SetVertexBuffers(ReadOnlySpan<VertexBufferDescriptor> vertexBuffers)
+        public unsafe void SetVertexBuffers(ReadOnlySpan<VertexBufferDescriptor> vertexBuffers)
         {
-            _renderer.New<SetVertexBuffersCommand>().Set(_renderer.CopySpan(vertexBuffers));
+            _renderer.New<SetVertexBuffersCommand>()->Set(_renderer.CopySpan(vertexBuffers));
             _renderer.QueueCommand();
         }
 
-        public void SetViewports(ReadOnlySpan<Viewport> viewports)
+        public unsafe void SetViewports(ReadOnlySpan<Viewport> viewports)
         {
-            _renderer.New<SetViewportsCommand>().Set(_renderer.CopySpan(viewports));
+            _renderer.New<SetViewportsCommand>()->Set(_renderer.CopySpan(viewports));
             _renderer.QueueCommand();
         }
 
-        public void TextureBarrier()
+        public unsafe void TextureBarrier()
         {
             _renderer.New<TextureBarrierCommand>();
             _renderer.QueueCommand();
         }
 
-        public void TextureBarrierTiled()
+        public unsafe void TextureBarrierTiled()
         {
             _renderer.New<TextureBarrierTiledCommand>();
             _renderer.QueueCommand();
         }
 
-        public bool TryHostConditionalRendering(ICounterEvent value, ulong compare, bool isEqual)
+        public unsafe bool TryHostConditionalRendering(ICounterEvent value, ulong compare, bool isEqual)
         {
             ThreadedCounterEvent evt = value as ThreadedCounterEvent;
             if (evt != null)
@@ -369,20 +372,20 @@ namespace Ryujinx.Graphics.GAL.Multithreading
                         return false;
                     }
 
-                    _renderer.New<TryHostConditionalRenderingCommand>().Set(Ref(evt), compare, isEqual);
+                    _renderer.New<TryHostConditionalRenderingCommand>()->Set(Ref(evt), compare, isEqual);
                     _renderer.QueueCommand();
                     return true;
                 }
             }
 
-            _renderer.New<TryHostConditionalRenderingFlushCommand>().Set(Ref(evt), Ref<ThreadedCounterEvent>(null), isEqual);
+            _renderer.New<TryHostConditionalRenderingFlushCommand>()->Set(Ref(evt), Ref<ThreadedCounterEvent>(null), isEqual);
             _renderer.QueueCommand();
             return false;
         }
 
-        public bool TryHostConditionalRendering(ICounterEvent value, ICounterEvent compare, bool isEqual)
+        public unsafe bool TryHostConditionalRendering(ICounterEvent value, ICounterEvent compare, bool isEqual)
         {
-            _renderer.New<TryHostConditionalRenderingFlushCommand>().Set(Ref(value as ThreadedCounterEvent), Ref(compare as ThreadedCounterEvent), isEqual);
+            _renderer.New<TryHostConditionalRenderingFlushCommand>()->Set(Ref(value as ThreadedCounterEvent), Ref(compare as ThreadedCounterEvent), isEqual);
             _renderer.QueueCommand();
             return false;
         }

src/Ryujinx.Graphics.GAL/Multithreading/ThreadedRenderer.cs

@@ -167,7 +167,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return new TableRef<T>(this, reference);
         }
 
-        internal ref T New<T>() where T : struct
+        internal unsafe T* New<T>() where T : unmanaged, IGALCommand
         {
             while (_producerPtr == (Volatile.Read(ref _consumerPtr) + QueueCount - 1) % QueueCount)
             {
@@ -183,11 +183,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _producerPtr = (_producerPtr + 1) % QueueCount;
 
             Span<byte> memory = new(_commandQueue, taken * _elementSize, _elementSize);
-            ref T result = ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(memory));
+            T* result = (T*)Unsafe.AsPointer(ref memory.GetPinnableReference());
+            // ref T result = ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(memory));
 
-            memory[^1] = (byte)((IGALCommand)result).CommandType;
+            memory[^1] = (byte)(result)->CommandType;
 
-            return ref result;
+            return result;
         }
 
         internal int AddTableRef(object obj)
@@ -251,12 +252,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return Thread.CurrentThread == _gpuThread;
         }
 
-        public void BackgroundContextAction(Action action, bool alwaysBackground = false)
+        public unsafe void BackgroundContextAction(Action action, bool alwaysBackground = false)
         {
             if (IsGpuThread() && !alwaysBackground)
             {
                 // The action must be performed on the render thread.
-                New<ActionCommand>().Set(Ref(action));
+                New<ActionCommand>()->Set(Ref(action));
                 InvokeCommand();
             }
             else
@@ -265,43 +266,43 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             }
         }
 
-        public BufferHandle CreateBuffer(int size, BufferAccess access)
+        public unsafe BufferHandle CreateBuffer(int size, BufferAccess access)
         {
             BufferHandle handle = Buffers.CreateBufferHandle();
-            New<CreateBufferAccessCommand>().Set(handle, size, access);
+            New<CreateBufferAccessCommand>()->Set(handle, size, access);
             QueueCommand();
 
             return handle;
         }
 
-        public BufferHandle CreateBuffer(nint pointer, int size)
+        public unsafe BufferHandle CreateBuffer(nint pointer, int size)
         {
             BufferHandle handle = Buffers.CreateBufferHandle();
-            New<CreateHostBufferCommand>().Set(handle, pointer, size);
+            New<CreateHostBufferCommand>()->Set(handle, pointer, size);
             QueueCommand();
 
             return handle;
         }
 
-        public BufferHandle CreateBufferSparse(ReadOnlySpan<BufferRange> storageBuffers)
+        public unsafe BufferHandle CreateBufferSparse(ReadOnlySpan<BufferRange> storageBuffers)
         {
             BufferHandle handle = Buffers.CreateBufferHandle();
-            New<CreateBufferSparseCommand>().Set(handle, CopySpan(storageBuffers));
+            New<CreateBufferSparseCommand>()->Set(handle, CopySpan(storageBuffers));
             QueueCommand();
 
             return handle;
         }
 
-        public IImageArray CreateImageArray(int size, bool isBuffer)
+        public unsafe IImageArray CreateImageArray(int size, bool isBuffer)
         {
             ThreadedImageArray imageArray = new(this);
-            New<CreateImageArrayCommand>().Set(Ref(imageArray), size, isBuffer);
+            New<CreateImageArrayCommand>()->Set(Ref(imageArray), size, isBuffer);
             QueueCommand();
 
             return imageArray;
         }
 
-        public IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)
+        public unsafe IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)
         {
             ThreadedProgram program = new(this);
 
@@ -311,34 +312,34 @@ namespace Ryujinx.Graphics.GAL.Multithreading
 
             ProgramCount++;
 
-            New<CreateProgramCommand>().Set(Ref((IProgramRequest)request));
+            New<CreateProgramCommand>()->Set(Ref((IProgramRequest)request));
             QueueCommand();
 
             return program;
         }
 
-        public ISampler CreateSampler(SamplerCreateInfo info)
+        public unsafe ISampler CreateSampler(SamplerCreateInfo info)
         {
             ThreadedSampler sampler = new(this);
-            New<CreateSamplerCommand>().Set(Ref(sampler), info);
+            New<CreateSamplerCommand>()->Set(Ref(sampler), info);
             QueueCommand();
 
             return sampler;
         }
 
-        public void CreateSync(ulong id, bool strict)
+        public unsafe void CreateSync(ulong id, bool strict)
         {
             Sync.CreateSyncHandle(id);
-            New<CreateSyncCommand>().Set(id, strict);
+            New<CreateSyncCommand>()->Set(id, strict);
             QueueCommand();
         }
 
-        public ITexture CreateTexture(TextureCreateInfo info)
+        public unsafe ITexture CreateTexture(TextureCreateInfo info)
         {
             if (IsGpuThread())
             {
                 ThreadedTexture texture = new(this, info);
-                New<CreateTextureCommand>().Set(Ref(texture), info);
+                New<CreateTextureCommand>()->Set(Ref(texture), info);
                 QueueCommand();
 
                 return texture;
@@ -353,27 +354,27 @@ namespace Ryujinx.Graphics.GAL.Multithreading
                 return texture;
             }
         }
-        public ITextureArray CreateTextureArray(int size, bool isBuffer)
+        public unsafe ITextureArray CreateTextureArray(int size, bool isBuffer)
         {
             ThreadedTextureArray textureArray = new(this);
-            New<CreateTextureArrayCommand>().Set(Ref(textureArray), size, isBuffer);
+            New<CreateTextureArrayCommand>()->Set(Ref(textureArray), size, isBuffer);
             QueueCommand();
 
             return textureArray;
         }
 
-        public void DeleteBuffer(BufferHandle buffer)
+        public unsafe void DeleteBuffer(BufferHandle buffer)
         {
-            New<BufferDisposeCommand>().Set(buffer);
+            New<BufferDisposeCommand>()->Set(buffer);
             QueueCommand();
         }
 
-        public PinnedSpan<byte> GetBufferData(BufferHandle buffer, int offset, int size)
+        public unsafe PinnedSpan<byte> GetBufferData(BufferHandle buffer, int offset, int size)
         {
             if (IsGpuThread())
             {
                 ResultBox<PinnedSpan<byte>> box = new();
-                New<BufferGetDataCommand>().Set(buffer, offset, size, Ref(box));
+                New<BufferGetDataCommand>()->Set(buffer, offset, size, Ref(box));
                 InvokeCommand();
 
                 return box.Result;
@@ -384,10 +385,10 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             }
         }
 
-        public Capabilities GetCapabilities()
+        public unsafe Capabilities GetCapabilities()
         {
             ResultBox<Capabilities> box = new();
-            New<GetCapabilitiesCommand>().Set(Ref(box));
+            New<GetCapabilitiesCommand>()->Set(Ref(box));
             InvokeCommand();
 
             return box.Result;
@@ -412,29 +413,29 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _baseRenderer.Initialize(logLevel);
         }
 
-        public IProgram LoadProgramBinary(byte[] programBinary, bool hasFragmentShader, ShaderInfo info)
+        public unsafe IProgram LoadProgramBinary(byte[] programBinary, bool hasFragmentShader, ShaderInfo info)
         {
             ThreadedProgram program = new(this);
 
             BinaryProgramRequest request = new(program, programBinary, hasFragmentShader, info);
             Programs.Add(request);
 
-            New<CreateProgramCommand>().Set(Ref((IProgramRequest)request));
+            New<CreateProgramCommand>()->Set(Ref((IProgramRequest)request));
             QueueCommand();
 
             return program;
         }
 
-        public void PreFrame()
+        public unsafe void PreFrame()
         {
             New<PreFrameCommand>();
             QueueCommand();
         }
 
-        public ICounterEvent ReportCounter(CounterType type, EventHandler<ulong> resultHandler, float divisor, bool hostReserved)
+        public unsafe ICounterEvent ReportCounter(CounterType type, EventHandler<ulong> resultHandler, float divisor, bool hostReserved)
         {
             ThreadedCounterEvent evt = new(this, type, _lastSampleCounterClear);
-            New<ReportCounterCommand>().Set(Ref(evt), type, Ref(resultHandler), divisor, hostReserved);
+            New<ReportCounterCommand>()->Set(Ref(evt), type, Ref(resultHandler), divisor, hostReserved);
             QueueCommand();
 
             if (type == CounterType.SamplesPassed)
@@ -445,9 +446,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return evt;
         }
 
-        public void ResetCounter(CounterType type)
+        public unsafe void ResetCounter(CounterType type)
         {
-            New<ResetCounterCommand>().Set(type);
+            New<ResetCounterCommand>()->Set(type);
             QueueCommand();
             _lastSampleCounterClear = true;
         }
@@ -457,13 +458,13 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _baseRenderer.Screenshot();
         }
 
-        public void SetBufferData(BufferHandle buffer, int offset, ReadOnlySpan<byte> data)
+        public unsafe void SetBufferData(BufferHandle buffer, int offset, ReadOnlySpan<byte> data)
         {
-            New<BufferSetDataCommand>().Set(buffer, offset, CopySpan(data));
+            New<BufferSetDataCommand>()->Set(buffer, offset, CopySpan(data));
             QueueCommand();
         }
 
-        public void UpdateCounters()
+        public unsafe void UpdateCounters()
         {
             New<UpdateCountersCommand>();
             QueueCommand();

src/Ryujinx.Graphics.GAL/Multithreading/ThreadedWindow.cs

@@ -17,13 +17,13 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _impl = impl;
         }
 
-        public void Present(ITexture texture, ImageCrop crop, Action swapBuffersCallback)
+        public unsafe void Present(ITexture texture, ImageCrop crop, Action swapBuffersCallback)
         {
             // If there's already a frame in the pipeline, wait for it to be presented first.
             // This is a multithread rate limit - we can't be more than one frame behind the command queue.
 
             _renderer.WaitForFrame();
-            _renderer.New<WindowPresentCommand>().Set(new TableRef<ThreadedTexture>(_renderer, texture as ThreadedTexture), crop, new TableRef<Action>(_renderer, swapBuffersCallback));
+            _renderer.New<WindowPresentCommand>()->Set(new TableRef<ThreadedTexture>(_renderer, texture as ThreadedTexture), crop, new TableRef<Action>(_renderer, swapBuffersCallback));
             _renderer.QueueCommand();
         }
 

src/Ryujinx.Graphics.GAL/ViewportSwizzle.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.Graphics.GAL
 {
     public enum ViewportSwizzle

src/Ryujinx.Graphics.Gpu/Engine/Threed/DrawManager.cs

@@ -451,7 +451,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             // TODO: Confirm behaviour on hardware.
             // When this is active, the origin appears to be on the bottom.
-            if (_state.State.YControl.HasFlag(YControl.NegateY))
+            if ((_state.State.YControl & YControl.NegateY) != 0)
             {
                 dstY0 -= dstHeight;
             }

src/Ryujinx.Graphics.Gpu/Engine/Threed/IndirectDrawType.cs

@@ -1,5 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
-
 namespace Ryujinx.Graphics.Gpu.Engine.Threed
 {
     /// <summary>

src/Ryujinx.Graphics.Gpu/Engine/Threed/SpecializationStateUpdater.cs

@@ -1,4 +1,3 @@
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Types;
 using Ryujinx.Graphics.Gpu.Shader;

src/Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs

@@ -646,7 +646,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     int width = scissor.X2 - x;
                     int height = scissor.Y2 - y;
 
-                    if (_state.State.YControl.HasFlag(YControl.NegateY))
+                    if ((_state.State.YControl & YControl.NegateY) != 0)
                     {
                         ref ScreenScissorState screenScissor = ref _state.State.ScreenScissorState;
                         y = screenScissor.Height - height - y;
@@ -730,7 +730,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             FaceState face = _state.State.FaceState;
 
             bool disableTransform = _state.State.ViewportTransformEnable == 0;
-            bool yNegate = yControl.HasFlag(YControl.NegateY);
+            bool yNegate = (yControl & YControl.NegateY) != 0;
 
             UpdateFrontFace(yControl, face.FrontFace);
             UpdateDepthMode();
@@ -1230,7 +1230,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// <param name="frontFace">Front face</param>
         private void UpdateFrontFace(YControl yControl, FrontFace frontFace)
         {
-            bool isUpperLeftOrigin = !yControl.HasFlag(YControl.TriangleRastFlip);
+            bool isUpperLeftOrigin = (yControl & YControl.TriangleRastFlip) == 0;
 
             if (isUpperLeftOrigin)
             {
@@ -1521,7 +1521,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             {
                 // Make sure we update the viewport size on the support buffer if it will be consumed on the new shader.
 
-                if (!_fsReadsFragCoord && _state.State.YControl.HasFlag(YControl.NegateY))
+                if (!_fsReadsFragCoord && (_state.State.YControl & YControl.NegateY) != 0)
                 {
                     UpdateSupportBufferViewportSize();
                 }

src/Ryujinx.Graphics.Gpu/Engine/Threed/ThreedClass.cs

@@ -1,4 +1,3 @@
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.GPFifo;

src/Ryujinx.Graphics.Gpu/GpuContext.cs

@@ -381,9 +381,9 @@ namespace Ryujinx.Graphics.Gpu
         /// <param name="flags">Modifiers for how host sync should be created</param>
         internal void CreateHostSyncIfNeeded(HostSyncFlags flags)
         {
-            bool syncpoint = flags.HasFlag(HostSyncFlags.Syncpoint);
-            bool strict = flags.HasFlag(HostSyncFlags.Strict);
-            bool force = flags.HasFlag(HostSyncFlags.Force);
+            bool syncPoint = (flags & HostSyncFlags.Syncpoint) == HostSyncFlags.Syncpoint;
+            bool strict = (flags & HostSyncFlags.Strict) == HostSyncFlags.Strict;
+            bool force = (flags & HostSyncFlags.Force) == HostSyncFlags.Force;
 
             if (BufferMigrations.Count > 0)
             {
@@ -402,24 +402,37 @@ namespace Ryujinx.Graphics.Gpu
                 }
             }
 
-            if (force || _pendingSync || (syncpoint && SyncpointActions.Count > 0))
+            if (force || _pendingSync || (syncPoint && SyncpointActions.Count > 0))
             {
                 foreach (ISyncActionHandler action in SyncActions)
                 {
-                    action.SyncPreAction(syncpoint);
+                    action.SyncPreAction(syncPoint);
                 }
 
                 foreach (ISyncActionHandler action in SyncpointActions)
                 {
-                    action.SyncPreAction(syncpoint);
+                    action.SyncPreAction(syncPoint);
                 }
 
                 Renderer.CreateSync(SyncNumber, strict);
 
                 SyncNumber++;
 
-                SyncActions.RemoveAll(action => action.SyncAction(syncpoint));
-                SyncpointActions.RemoveAll(action => action.SyncAction(syncpoint));
+                for (int i = 0; i < SyncActions.Count; i++)
+                {
+                    if (SyncActions[i].SyncAction(syncPoint))
+                    {
+                        SyncActions.RemoveAt(i--);
+                    }
+                }
+                
+                for (int i = 0; i < SyncpointActions.Count; i++)
+                {
+                    if (SyncpointActions[i].SyncAction(syncPoint))
+                    {
+                        SyncpointActions.RemoveAt(i--);
+                    }
+                }
             }
 
             _pendingSync = false;

src/Ryujinx.Graphics.Gpu/Image/FormatTable.cs

@@ -1,6 +1,5 @@
 using Ryujinx.Graphics.GAL;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Ryujinx.Graphics.Gpu.Image
 {

src/Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -1628,7 +1628,15 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             lock (_poolOwners)
             {
-                int references = _poolOwners.RemoveAll(entry => entry.Pool == pool && entry.ID == id || id == -1);
+                int references = 0;
+                for (int i = 0; i < _poolOwners.Count; i++)
+                {
+                    if (_poolOwners[i].Pool == pool && _poolOwners[i].ID == id || id == -1)
+                    {
+                        _poolOwners.RemoveAt(i--);
+                        references++;
+                    }
+                }
 
                 if (references == 0)
                 {

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -45,7 +45,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         private const int GranularLayerThreshold = 8;
 
-        private delegate void HandlesCallbackDelegate(int baseHandle, int regionCount, bool split = false);
+        private delegate bool HandlesCallbackDelegate(int baseHandle, int regionCount, bool split = false, bool specialData = false);
+
+        private readonly HandlesCallbackDelegate _signalModifyingCallback;
+        private readonly HandlesCallbackDelegate _discardDataCallback;
+        private readonly HandlesCallbackDelegate _checkDirtyCallback;
 
         /// <summary>
         /// The storage texture associated with this group.
@@ -126,6 +130,10 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             _incompatibleOverlaps = incompatibleOverlaps;
             _flushIncompatibleOverlaps = TextureCompatibility.IsFormatHostIncompatible(storage.Info, context.Capabilities);
+
+            _signalModifyingCallback = SignalModifyingCallback;
+            _discardDataCallback = DiscardDataCallback;
+            _checkDirtyCallback = CheckDirtyCallback;
         }
 
         /// <summary>
@@ -253,29 +261,33 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="consume">True to consume the dirty flags and reprotect, false to leave them as is</param>
         /// <returns>True if a flag was dirty, false otherwise</returns>
         public bool CheckDirty(Texture texture, bool consume)
+        {
+            EvaluateRelevantHandles(texture, _checkDirtyCallback, out bool dirty, consume);
+
+            return dirty;
+        }
+        
+        bool CheckDirtyCallback(int baseHandle, int regionCount, bool split, bool consume)
         {
             bool dirty = false;
-
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            
+            for (int i = 0; i < regionCount; i++)
             {
-                for (int i = 0; i < regionCount; i++)
+                TextureGroupHandle group = _handles[baseHandle + i];
+
+                foreach (RegionHandle handle in group.Handles)
                 {
-                    TextureGroupHandle group = _handles[baseHandle + i];
-
-                    foreach (RegionHandle handle in group.Handles)
+                    if (handle.Dirty)
                     {
-                        if (handle.Dirty)
+                        if (consume)
                         {
-                            if (consume)
-                            {
-                                handle.Reprotect();
-                            }
-
-                            dirty = true;
+                            handle.Reprotect();
                         }
+
+                        dirty = true;
                     }
                 }
-            });
+            }
 
             return dirty;
         }
@@ -287,15 +299,19 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="texture">The texture being discarded</param>
         public void DiscardData(Texture texture)
         {
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            EvaluateRelevantHandles(texture, _discardDataCallback, out _);
+        }
+        
+        bool DiscardDataCallback(int baseHandle, int regionCount, bool split, bool bound)
+        {
+            for (int i = 0; i < regionCount; i++)
             {
-                for (int i = 0; i < regionCount; i++)
-                {
-                    TextureGroupHandle group = _handles[baseHandle + i];
+                TextureGroupHandle group = _handles[baseHandle + i];
 
-                    group.DiscardData();
-                }
-            });
+                group.DiscardData();
+            }
+
+            return true;
         }
 
         /// <summary>
@@ -307,7 +323,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             FlushIncompatibleOverlapsIfNeeded();
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 bool dirty = false;
                 bool anyModified = false;
@@ -383,7 +399,9 @@ namespace Ryujinx.Graphics.Gpu.Image
                         texture.SynchronizeFull();
                     }
                 }
-            });
+
+                return true;
+            }, out _);
         }
 
         /// <summary>
@@ -460,7 +478,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="texture">The texture to synchronize dependents of</param>
         public void SynchronizeDependents(Texture texture)
         {
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 for (int i = 0; i < regionCount; i++)
                 {
@@ -468,7 +486,9 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     group.SynchronizeDependents();
                 }
-            });
+
+                return true;
+            }, out _);
         }
 
         /// <summary>
@@ -550,7 +570,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             tracked = tracked || ShouldFlushTriggerTracking();
             bool flushed = false;
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 int startSlice = 0;
                 int endSlice = 0;
@@ -604,7 +624,9 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     flushed = true;
                 }
-            });
+
+                return true;
+            }, out _);
 
             Storage.SignalModifiedDirty();
 
@@ -693,7 +715,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             ClearIncompatibleOverlaps(texture);
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 for (int i = 0; i < regionCount; i++)
                 {
@@ -701,7 +723,9 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     group.SignalModified(_context);
                 }
-            });
+                
+                return true;
+            }, out _);
         }
 
         /// <summary>
@@ -714,16 +738,20 @@ namespace Ryujinx.Graphics.Gpu.Image
             ModifiedSequence = _context.GetModifiedSequence();
 
             ClearIncompatibleOverlaps(texture);
-
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            
+            EvaluateRelevantHandles(texture, _signalModifyingCallback, out _, bound);
+        }
+        
+        bool SignalModifyingCallback(int baseHandle, int regionCount, bool split, bool bound)
+        {
+            for (int i = 0; i < regionCount; i++)
             {
-                for (int i = 0; i < regionCount; i++)
-                {
-                    TextureGroupHandle group = _handles[baseHandle + i];
+                TextureGroupHandle group = _handles[baseHandle + i];
 
-                    group.SignalModifying(bound, _context);
-                }
-            });
+                group.SignalModifying(bound, _context);
+            }
+            
+            return true;
         }
 
         /// <summary>
@@ -767,16 +795,16 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// A function to be called with the base index of the range of handles for the given texture, and the number of handles it covers.
         /// This can be called for multiple disjoint ranges, if required.
         /// </param>
-        private void EvaluateRelevantHandles(Texture texture, HandlesCallbackDelegate callback)
+        private void EvaluateRelevantHandles(Texture texture, HandlesCallbackDelegate callback, out bool result, bool specialData = false)
         {
             if (texture == Storage || !(_hasMipViews || _hasLayerViews))
             {
-                callback(0, _handles.Length);
+                result = callback(0, _handles.Length, specialData: specialData);
 
                 return;
             }
 
-            EvaluateRelevantHandles(texture.FirstLayer, texture.FirstLevel, texture.Info.GetSlices(), texture.Info.Levels, callback);
+            EvaluateRelevantHandles(texture.FirstLayer, texture.FirstLevel, texture.Info.GetSlices(), texture.Info.Levels, callback, out result, specialData);
         }
 
         /// <summary>
@@ -791,11 +819,13 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// A function to be called with the base index of the range of handles for the given texture, and the number of handles it covers.
         /// This can be called for multiple disjoint ranges, if required.
         /// </param>
-        private void EvaluateRelevantHandles(int firstLayer, int firstLevel, int slices, int levels, HandlesCallbackDelegate callback)
+        private void EvaluateRelevantHandles(int firstLayer, int firstLevel, int slices, int levels, HandlesCallbackDelegate callback, out bool result, bool specialData = false)
         {
             int targetLayerHandles = _hasLayerViews ? slices : 1;
             int targetLevelHandles = _hasMipViews ? levels : 1;
 
+            result = false;
+            
             if (_isBuffer)
             {
                 return;
@@ -808,7 +838,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     // When there are no layer views, the mips are at a consistent offset.
 
-                    callback(firstLevel, targetLevelHandles);
+                    result = callback(firstLevel, targetLevelHandles, specialData: specialData);
                 }
                 else
                 {
@@ -822,7 +852,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                         while (levels-- > 1)
                         {
-                            callback(firstLayer + levelIndex, slices);
+                            result = callback(firstLayer + levelIndex, slices, specialData: specialData);
 
                             levelIndex += layerCount;
                             layerCount = Math.Max(layerCount >> 1, 1);
@@ -839,7 +869,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                             totalSize += layerCount;
                         }
 
-                        callback(firstLayer + levelIndex, totalSize);
+                        result = callback(firstLayer + levelIndex, totalSize, specialData: specialData);
                     }
                 }
             }
@@ -856,12 +886,12 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                     for (int i = 0; i < slices; i++)
                     {
-                        callback(firstLevel + (firstLayer + i) * levelHandles, targetLevelHandles, true);
+                        result = callback(firstLevel + (firstLayer + i) * levelHandles, targetLevelHandles, true, specialData: specialData);
                     }
                 }
                 else
                 {
-                    callback(firstLevel + firstLayer * levelHandles, targetLevelHandles + (targetLayerHandles - 1) * levelHandles);
+                    result = callback(firstLevel + firstLayer * levelHandles, targetLevelHandles + (targetLayerHandles - 1) * levelHandles, specialData: specialData);
                 }
             }
         }
@@ -1439,8 +1469,16 @@ namespace Ryujinx.Graphics.Gpu.Image
             List<(int BaseHandle, int RegionCount)> targetRange = [];
             List<(int BaseHandle, int RegionCount)> otherRange = [];
 
-            EvaluateRelevantHandles(firstLayer, firstLevel, other.Info.GetSlices(), other.Info.Levels, (baseHandle, regionCount, split) => targetRange.Add((baseHandle, regionCount)));
-            otherGroup.EvaluateRelevantHandles(other, (baseHandle, regionCount, split) => otherRange.Add((baseHandle, regionCount)));
+            EvaluateRelevantHandles(firstLayer, firstLevel, other.Info.GetSlices(), other.Info.Levels, (baseHandle, regionCount, split, specialData) =>
+            {
+                targetRange.Add((baseHandle, regionCount));
+                return true;
+            }, out _);
+            otherGroup.EvaluateRelevantHandles(other, (baseHandle, regionCount, split, specialData) =>
+            {
+                otherRange.Add((baseHandle, regionCount));
+                return true;
+            }, out _);
 
             int targetIndex = 0;
             int otherIndex = 0;

src/Ryujinx.Graphics.Gpu/Memory/Buffer.cs

@@ -93,6 +93,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
         private ulong _dirtyStart = ulong.MaxValue;
         private ulong _dirtyEnd = ulong.MaxValue;
 
+        private readonly Action<ulong, ulong> _syncPreRangeAction;
+        private readonly Action<ulong, ulong> _syncRangeAction;
+
         /// <summary>
         /// Creates a new instance of the buffer.
         /// </summary>
@@ -177,6 +180,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _modifiedDelegate = RegionModified;
 
             _virtualDependenciesLock = new ReaderWriterLockSlim();
+
+            _syncPreRangeAction = SyncPreRangeAction;
+            _syncRangeAction = SyncRangeAction;
         }
 
         /// <summary>
@@ -401,13 +407,15 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
                 if (_preFlush.ShouldCopy)
                 {
-                    _modifiedRanges?.GetRangesAtSync(Address, Size, _context.SyncNumber, (address, size) =>
-                    {
-                        _preFlush.CopyModified(address, size);
-                    });
+                    _modifiedRanges?.GetRangesAtSync(Address, Size, _context.SyncNumber, _syncPreRangeAction);
                 }
             }
         }
+        
+        void SyncPreRangeAction(ulong address, ulong size)
+        {
+            _preFlush.CopyModified(address, size);
+        }
 
         /// <summary>
         /// Action to be performed when a syncpoint is reached after modification.
@@ -420,11 +428,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             if (_useGranular)
             {
-                _modifiedRanges?.GetRanges(Address, Size, (address, size) =>
-                {
-                    _memoryTrackingGranular.RegisterAction(address, size, _externalFlushDelegate);
-                    SynchronizeMemory(address, size);
-                });
+                
+
+                _modifiedRanges?.GetRanges(Address, Size, _syncRangeAction);
             }
             else
             {
@@ -434,6 +440,12 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             return true;
         }
+        
+        void SyncRangeAction(ulong address, ulong size)
+        {
+            _memoryTrackingGranular.RegisterAction(address, size, _externalFlushDelegate);
+            SynchronizeMemory(address, size);
+        }
 
         /// <summary>
         /// Inherit modified and dirty ranges from another buffer.

src/Ryujinx.Graphics.Gpu/Memory/BufferBackingState.cs

@@ -1,7 +1,6 @@
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Memory.Range;
 using System;
-using System.Collections.Generic;
 
 namespace Ryujinx.Graphics.Gpu.Memory
 {

src/Ryujinx.Graphics.Gpu/Memory/BufferModifiedRangeList.cs

@@ -1,6 +1,6 @@
 using Ryujinx.Memory.Range;
 using System;
-using System.Collections.Generic;
+using System.Buffers;
 using System.Linq;
 
 namespace Ryujinx.Graphics.Gpu.Memory
@@ -277,13 +277,18 @@ namespace Ryujinx.Graphics.Gpu.Memory
         {
             // We use the non-span method here because keeping the lock will cause a deadlock.
             Lock.EnterReadLock();
-            RangeItem<BufferModifiedRange>[] overlaps = FindOverlapsAsArray(address, size);
+            RangeItem<BufferModifiedRange>[] overlaps = FindOverlapsAsArray(address, size, out int length);
             Lock.ExitReadLock();
 
-            for (int i = 0; i < overlaps.Length; i++)
+            if (length != 0)
             {
-                BufferModifiedRange overlap = overlaps[i].Value;
-                rangeAction(overlap.Address, overlap.Size);
+                for (int i = 0; i < length; i++)
+                {
+                    BufferModifiedRange overlap = overlaps[i].Value;
+                    rangeAction(overlap.Address, overlap.Size);
+                }
+                
+                ArrayPool<RangeItem<BufferModifiedRange>>.Shared.Return(overlaps);
             }
         }
 
@@ -393,9 +398,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
             
             Lock.EnterWriteLock();
             // We use the non-span method here because the array is partially modified by the code, which would invalidate a span.
-            RangeItem<BufferModifiedRange>[] overlaps = FindOverlapsAsArray(address, size);
-                
-            int rangeCount = overlaps.Length;
+            RangeItem<BufferModifiedRange>[] overlaps = FindOverlapsAsArray(address, size, out int rangeCount);
 
             if (rangeCount == 0)
             {
@@ -411,7 +414,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             for (int i = 0; i < rangeCount; i++)
             {
-                BufferModifiedRange overlap = overlaps[i].Value;
+                BufferModifiedRange overlap = overlaps![i].Value;
 
                 long diff = (long)(overlap.SyncNumber - currentSync);
 
@@ -431,7 +434,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
             // Wait for the syncpoint.
             _context.Renderer.WaitSync(currentSync + (ulong)highestDiff);
 
-            RemoveRangesAndFlush(overlaps.ToArray(), rangeCount, highestDiff, currentSync, address, endAddress);
+            RemoveRangesAndFlush(overlaps, rangeCount, highestDiff, currentSync, address, endAddress);
+            
+            ArrayPool<RangeItem<BufferModifiedRange>>.Shared.Return(overlaps!);
             
             Lock.ExitWriteLock();
         }

src/Ryujinx.Graphics.Gpu/Memory/MemoryManager.cs

@@ -49,6 +49,12 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// Cache of GPU counters.
         /// </summary>
         internal CounterCache CounterCache { get; }
+        
+        private delegate void WriteCallback(ulong address, ReadOnlySpan<byte> data);
+
+        private WriteCallback _write;
+        private WriteCallback _writeTrackedResource;
+        private WriteCallback _writeUntracked;
 
         /// <summary>
         /// Creates a new instance of the GPU memory manager.
@@ -58,6 +64,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
         internal MemoryManager(PhysicalMemory physicalMemory, ulong cpuMemorySize)
         {
             Physical = physicalMemory;
+            _write = physicalMemory.Write;
+            _writeTrackedResource = physicalMemory.WriteTrackedResource;
+            _writeUntracked = physicalMemory.WriteUntracked;
             VirtualRangeCache = new VirtualRangeCache(this);
             CounterCache = new CounterCache();
             _pageTable = new ulong[PtLvl0Size][];
@@ -269,7 +278,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="data">The data to be written</param>
         public void Write(ulong va, ReadOnlySpan<byte> data)
         {
-            WriteImpl(va, data, Physical.Write);
+            WriteImpl(va, data, _write);
         }
 
         /// <summary>
@@ -279,7 +288,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="data">The data to be written</param>
         public void WriteTrackedResource(ulong va, ReadOnlySpan<byte> data)
         {
-            WriteImpl(va, data, Physical.WriteTrackedResource);
+            WriteImpl(va, data, _writeTrackedResource);
         }
 
         /// <summary>
@@ -289,11 +298,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="data">The data to be written</param>
         public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
         {
-            WriteImpl(va, data, Physical.WriteUntracked);
+            WriteImpl(va, data, _writeUntracked);
         }
 
-        private delegate void WriteCallback(ulong address, ReadOnlySpan<byte> data);
-
         /// <summary>
         /// Writes data to possibly non-contiguous GPU mapped memory.
         /// </summary>

src/Ryujinx.Graphics.Gpu/Shader/ShaderSpecializationState.cs

@@ -397,7 +397,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <returns>True if queried, false otherwise</returns>
         public bool IsPrimitiveTopologyQueried()
         {
-            return _queriedState.HasFlag(QueriedStateFlags.PrimitiveTopology);
+            return (_queriedState & QueriedStateFlags.PrimitiveTopology) == QueriedStateFlags.PrimitiveTopology;
         }
 
         /// <summary>
@@ -904,7 +904,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 specState.PipelineState = pipelineState;
             }
 
-            if (specState._queriedState.HasFlag(QueriedStateFlags.TransformFeedback))
+            if ((specState._queriedState & QueriedStateFlags.TransformFeedback) == QueriedStateFlags.TransformFeedback)
             {
                 ushort tfCount = 0;
                 dataReader.Read(ref tfCount);
@@ -930,7 +930,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 specState._textureSpecialization[textureKey] = textureState;
             }
 
-            if (specState._queriedState.HasFlag(QueriedStateFlags.TextureArrayFromBuffer))
+            if ((specState._queriedState & QueriedStateFlags.TextureArrayFromBuffer) == QueriedStateFlags.TextureArrayFromBuffer)
             {
                 dataReader.Read(ref count);
 
@@ -946,7 +946,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 }
             }
 
-            if (specState._queriedState.HasFlag(QueriedStateFlags.TextureArrayFromPool))
+            if ((specState._queriedState & QueriedStateFlags.TextureArrayFromPool) == QueriedStateFlags.TextureArrayFromPool)
             {
                 dataReader.Read(ref count);
 
@@ -1006,7 +1006,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 dataWriter.WriteWithMagicAndSize(ref pipelineState, PgpsMagic);
             }
 
-            if (_queriedState.HasFlag(QueriedStateFlags.TransformFeedback))
+            if ((_queriedState & QueriedStateFlags.TransformFeedback) == QueriedStateFlags.TransformFeedback)
             {
                 ushort tfCount = (ushort)TransformFeedbackDescriptors.Length;
                 dataWriter.Write(ref tfCount);
@@ -1029,7 +1029,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 dataWriter.WriteWithMagicAndSize(ref textureState.Value, TexsMagic);
             }
 
-            if (_queriedState.HasFlag(QueriedStateFlags.TextureArrayFromBuffer))
+            if ((_queriedState & QueriedStateFlags.TextureArrayFromBuffer) == QueriedStateFlags.TextureArrayFromBuffer)
             {
                 count = (ushort)_textureArrayFromBufferSpecialization.Count;
                 dataWriter.Write(ref count);
@@ -1044,7 +1044,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 }
             }
 
-            if (_queriedState.HasFlag(QueriedStateFlags.TextureArrayFromPool))
+            if ((_queriedState & QueriedStateFlags.TextureArrayFromPool) == QueriedStateFlags.TextureArrayFromPool)
             {
                 count = (ushort)_textureArrayFromPoolSpecialization.Count;
                 dataWriter.Write(ref count);

src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstType.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
 {

src/Ryujinx.Graphics.Shader/IntermediateRepresentation/TextureFlags.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
 {

src/Ryujinx.Graphics.Shader/Translation/AggregateType.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Ryujinx.Graphics.Shader.Translation
 {

src/Ryujinx.Graphics.Vic/Image/SurfaceReader.cs

@@ -1,5 +1,4 @@
 using Ryujinx.Common.Logging;
-using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Texture;
 using Ryujinx.Graphics.Vic.Types;
 using System;

src/Ryujinx.Graphics.Vulkan/BufferHolder.cs

@@ -58,6 +58,8 @@ namespace Ryujinx.Graphics.Vulkan
         private Dictionary<ulong, StagingBufferReserved> _mirrors;
         private bool _useMirrors;
 
+        private Action _decrementReferenceCount;
+
         public BufferHolder(VulkanRenderer gd, Device device, VkBuffer buffer, MemoryAllocation allocation, int size, BufferAllocationType type, BufferAllocationType currentType)
         {
             _gd = gd;
@@ -75,6 +77,8 @@ namespace Ryujinx.Graphics.Vulkan
 
             _flushLock = new ReaderWriterLockSlim();
             _useMirrors = gd.IsTBDR;
+            
+            _decrementReferenceCount = _buffer.DecrementReferenceCount;
         }
 
         public BufferHolder(VulkanRenderer gd, Device device, VkBuffer buffer, Auto<MemoryAllocation> allocation, int size, BufferAllocationType type, BufferAllocationType currentType, int offset)
@@ -444,7 +448,7 @@ namespace Ryujinx.Graphics.Vulkan
 
                 _flushLock.ExitReadLock();
 
-                return PinnedSpan<byte>.UnsafeFromSpan(result, _buffer.DecrementReferenceCount);
+                return PinnedSpan<byte>.UnsafeFromSpan(result, _decrementReferenceCount);
             }
 
             BackgroundResource resource = _gd.BackgroundResources.Get();

src/Ryujinx.Graphics.Vulkan/FramebufferParams.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Format = Ryujinx.Graphics.GAL.Format;
 using VkFormat = Silk.NET.Vulkan.Format;
@@ -10,26 +11,27 @@ namespace Ryujinx.Graphics.Vulkan
     class FramebufferParams
     {
         private readonly Device _device;
-        private readonly Auto<DisposableImageView>[] _attachments;
-        private readonly TextureView[] _colors;
-        private readonly TextureView _depthStencil;
-        private readonly TextureView[] _colorsCanonical;
-        private readonly TextureView _baseAttachment;
-        private readonly uint _validColorAttachments;
+        private Auto<DisposableImageView>[] _attachments;
+        private TextureView[] _colors;
+        private TextureView _depthStencil;
+        private TextureView[] _colorsCanonical;
+        private TextureView _baseAttachment;
+        private uint _validColorAttachments;
+        private int _totalCount;
 
-        public uint Width { get; }
-        public uint Height { get; }
-        public uint Layers { get; }
+        public uint Width { get; private set; }
+        public uint Height { get; private set; }
+        public uint Layers { get; private set; }
 
-        public uint[] AttachmentSamples { get; }
-        public VkFormat[] AttachmentFormats { get; }
-        public int[] AttachmentIndices { get; }
-        public uint AttachmentIntegerFormatMask { get; }
-        public bool LogicOpsAllowed { get; }
+        public uint[] AttachmentSamples { get; private set; }
+        public VkFormat[] AttachmentFormats { get; private set; }
+        public int[] AttachmentIndices { get; private set; }
+        public uint AttachmentIntegerFormatMask { get; private set; }
+        public bool LogicOpsAllowed { get; private set; }
 
-        public int AttachmentsCount { get; }
-        public int MaxColorAttachmentIndex => AttachmentIndices.Length > 0 ? AttachmentIndices[^1] : -1;
-        public bool HasDepthStencil { get; }
+        public int AttachmentsCount { get; private set; }
+        public int MaxColorAttachmentIndex => ColorAttachmentsCount > 0 ? AttachmentIndices[ColorAttachmentsCount - 1] : -1;
+        public bool HasDepthStencil { get; private set; }
         public int ColorAttachmentsCount => AttachmentsCount - (HasDepthStencil ? 1 : 0);
 
         public FramebufferParams(Device device, TextureView view, uint width, uint height)
@@ -50,7 +52,7 @@ namespace Ryujinx.Graphics.Vulkan
             else
             {
                 _colors = [view];
-                _colorsCanonical = _colors;
+                _colorsCanonical = [view];
             }
 
             Width = width;
@@ -64,6 +66,7 @@ namespace Ryujinx.Graphics.Vulkan
             LogicOpsAllowed = !format.IsFloatOrSrgb();
 
             AttachmentsCount = 1;
+            _totalCount = 1;
 
             HasDepthStencil = isDepthStencil;
         }
@@ -133,7 +136,7 @@ namespace Ryujinx.Graphics.Vulkan
             AttachmentIntegerFormatMask = attachmentIntegerFormatMask;
             LogicOpsAllowed = !allFormatsFloatOrSrgb;
 
-            if (depthStencil is TextureView dsTexture && dsTexture.Valid)
+            if (depthStencil is TextureView { Valid: true } dsTexture)
             {
                 _attachments[count - 1] = dsTexture.GetImageViewForAttachment();
                 _depthStencil = dsTexture;
@@ -159,11 +162,151 @@ namespace Ryujinx.Graphics.Vulkan
             Layers = layers;
 
             AttachmentsCount = count;
+            _totalCount = colors.Length;
+        }
+        
+        public FramebufferParams Update(ITexture[] colors, ITexture depthStencil)
+        {
+            int colorsCount = colors.Count(IsValidTextureView);
+
+            int count = colorsCount + (IsValidTextureView(depthStencil) ? 1 : 0);
+            
+            Array.Clear(_attachments);
+            Array.Clear(_colors);
+
+            if (_attachments.Length < count)
+            {
+                Array.Resize(ref _attachments, count);
+            }
+            if (_colors.Length < colorsCount)
+            {
+                Array.Resize(ref _colors, colorsCount);
+            }
+            if (_colorsCanonical.Length < colors.Length)
+            {
+                Array.Resize(ref _colorsCanonical, colors.Length);
+            }
+
+            for (int i = 0; i < colors.Length; i++)
+            {
+                ITexture color = colors[i];
+                if (color is TextureView { Valid: true } view)
+                {
+                    _colorsCanonical[i] = view;
+                }
+                else
+                {
+                    _colorsCanonical[i] = null;
+                }
+            }
+
+            Array.Clear(AttachmentSamples);
+            Array.Clear(AttachmentFormats);
+            Array.Clear(AttachmentIndices);
+            
+            if (AttachmentSamples.Length < count)
+            {
+                uint[] attachmentSamples = AttachmentSamples;
+                Array.Resize(ref attachmentSamples, count);
+                AttachmentSamples = attachmentSamples;
+            }
+            if (AttachmentFormats.Length < count)
+            {
+                VkFormat[] attachmentFormats = AttachmentFormats;
+                Array.Resize(ref attachmentFormats, count);
+                AttachmentFormats = attachmentFormats;
+            }
+            if (AttachmentIndices.Length < colorsCount)
+            {
+                int[] attachmentIndices = AttachmentIndices;
+                Array.Resize(ref attachmentIndices, colorsCount);
+                AttachmentIndices = attachmentIndices;
+            }
+            
+            uint width = uint.MaxValue;
+            uint height = uint.MaxValue;
+            uint layers = uint.MaxValue;
+
+            int index = 0;
+            uint attachmentIntegerFormatMask = 0;
+            bool allFormatsFloatOrSrgb = colorsCount != 0;
+
+            _validColorAttachments = 0;
+            _baseAttachment = null;
+
+            for (int bindIndex = 0; bindIndex < colors.Length; bindIndex++)
+            {
+                TextureView texture = _colorsCanonical[bindIndex];
+                if (texture is not null)
+                {
+                    _attachments[index] = texture.GetImageViewForAttachment();
+                    _colors[index] = texture;
+                    _validColorAttachments |= 1u << bindIndex;
+                    _baseAttachment = texture;
+
+                    AttachmentSamples[index] = (uint)texture.Info.Samples;
+                    AttachmentFormats[index] = texture.VkFormat;
+                    AttachmentIndices[index] = bindIndex;
+
+                    Format format = texture.Info.Format;
+
+                    if (format.IsInteger())
+                    {
+                        attachmentIntegerFormatMask |= 1u << bindIndex;
+                    }
+
+                    allFormatsFloatOrSrgb &= format.IsFloatOrSrgb();
+
+                    width = Math.Min(width, (uint)texture.Width);
+                    height = Math.Min(height, (uint)texture.Height);
+                    layers = Math.Min(layers, (uint)texture.Layers);
+
+                    if (++index >= colorsCount)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            AttachmentIntegerFormatMask = attachmentIntegerFormatMask;
+            LogicOpsAllowed = !allFormatsFloatOrSrgb;
+            _depthStencil = null;
+            HasDepthStencil = false;
+
+            if (depthStencil is TextureView { Valid: true } dsTexture)
+            {
+                _attachments[count - 1] = dsTexture.GetImageViewForAttachment();
+                _depthStencil = dsTexture;
+                _baseAttachment ??= dsTexture;
+
+                AttachmentSamples[count - 1] = (uint)dsTexture.Info.Samples;
+                AttachmentFormats[count - 1] = dsTexture.VkFormat;
+
+                width = Math.Min(width, (uint)dsTexture.Width);
+                height = Math.Min(height, (uint)dsTexture.Height);
+                layers = Math.Min(layers, (uint)dsTexture.Layers);
+
+                HasDepthStencil = true;
+            }
+
+            if (count == 0)
+            {
+                width = height = layers = 1;
+            }
+
+            Width = width;
+            Height = height;
+            Layers = layers;
+
+            AttachmentsCount = count;
+            _totalCount = colors.Length;
+
+            return this;
         }
 
         public Auto<DisposableImageView> GetAttachment(int index)
         {
-            if ((uint)index >= _attachments.Length)
+            if ((uint)index >= AttachmentsCount)
             {
                 return null;
             }
@@ -183,7 +326,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public ComponentType GetAttachmentComponentType(int index)
         {
-            if (_colors != null && (uint)index < _colors.Length)
+            if (_colors != null && (uint)index < ColorAttachmentsCount)
             {
                 Format format = _colors[index].Info.Format;
 
@@ -218,7 +361,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         private static bool IsValidTextureView(ITexture texture)
         {
-            return texture is TextureView view && view.Valid;
+            return texture is TextureView { Valid: true };
         }
 
         public ClearRect GetClearRect(Rectangle<int> scissor, int layer, int layerCount)
@@ -233,9 +376,9 @@ namespace Ryujinx.Graphics.Vulkan
 
         public unsafe Auto<DisposableFramebuffer> Create(Vk api, CommandBufferScoped cbs, Auto<DisposableRenderPass> renderPass)
         {
-            ImageView* attachments = stackalloc ImageView[_attachments.Length];
+            ImageView* attachments = stackalloc ImageView[AttachmentsCount];
 
-            for (int i = 0; i < _attachments.Length; i++)
+            for (int i = 0; i < AttachmentsCount; i++)
             {
                 attachments[i] = _attachments[i].Get(cbs).Value;
             }
@@ -244,7 +387,7 @@ namespace Ryujinx.Graphics.Vulkan
             {
                 SType = StructureType.FramebufferCreateInfo,
                 RenderPass = renderPass.Get(cbs).Value,
-                AttachmentCount = (uint)_attachments.Length,
+                AttachmentCount = (uint)AttachmentsCount,
                 PAttachments = attachments,
                 Width = Width,
                 Height = Height,
@@ -252,14 +395,13 @@ namespace Ryujinx.Graphics.Vulkan
             };
 
             api.CreateFramebuffer(_device, in framebufferCreateInfo, null, out Framebuffer framebuffer).ThrowOnError();
-            return new Auto<DisposableFramebuffer>(new DisposableFramebuffer(api, _device, framebuffer), null, _attachments);
+            return new Auto<DisposableFramebuffer>(new DisposableFramebuffer(api, _device, framebuffer), null, _attachments[..AttachmentsCount]);
         }
 
         public TextureView[] GetAttachmentViews()
         {
-            TextureView[] result = new TextureView[_attachments.Length];
-
-            _colors?.CopyTo(result, 0);
+            TextureView[] result = new TextureView[AttachmentsCount];
+            _colors?.AsSpan(..ColorAttachmentsCount).CopyTo(result.AsSpan());
 
             if (_depthStencil != null)
             {
@@ -278,8 +420,11 @@ namespace Ryujinx.Graphics.Vulkan
         {
             if (_colors != null)
             {
-                foreach (TextureView color in _colors)
+                int count = ColorAttachmentsCount;
+                
+                for (int i = 0; i < count; i++)
                 {
+                    TextureView color = _colors[i];
                     // If Clear or DontCare were used, this would need to be write bit.
                     color.Storage?.QueueLoadOpBarrier(cbs, false);
                 }
@@ -294,8 +439,11 @@ namespace Ryujinx.Graphics.Vulkan
         {
             if (_colors != null)
             {
-                foreach (TextureView color in _colors)
+                int count = ColorAttachmentsCount;
+                
+                for (int i = 0; i < count; i++)
                 {
+                    TextureView color = _colors[i];
                     color.Storage?.AddStoreOpUsage(false);
                 }
             }
@@ -307,7 +455,7 @@ namespace Ryujinx.Graphics.Vulkan
         {
             _depthStencil?.Storage.ClearBindings();
 
-            for (int i = 0; i < _colorsCanonical.Length; i++)
+            for (int i = 0; i < _totalCount; i++)
             {
                 _colorsCanonical[i]?.Storage.ClearBindings();
             }
@@ -317,7 +465,7 @@ namespace Ryujinx.Graphics.Vulkan
         {
             _depthStencil?.Storage.AddBinding(_depthStencil);
 
-            for (int i = 0; i < _colorsCanonical.Length; i++)
+            for (int i = 0; i < _totalCount; i++)
             {
                 TextureView color = _colorsCanonical[i];
                 color?.Storage.AddBinding(color);

src/Ryujinx.Graphics.Vulkan/HelperShader.cs

@@ -4,7 +4,6 @@ using Ryujinx.Graphics.Shader;
 using Ryujinx.Graphics.Shader.Translation;
 using Silk.NET.Vulkan;
 using System;
-using System.Collections.Generic;
 using System.Numerics;
 using Buffer = Silk.NET.Vulkan.Buffer;
 using CompareOp = Ryujinx.Graphics.GAL.CompareOp;

src/Ryujinx.Graphics.Vulkan/IndexBufferPattern.cs

@@ -1,6 +1,5 @@
 using Ryujinx.Graphics.GAL;
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.Graphics.Vulkan

src/Ryujinx.Graphics.Vulkan/MultiFenceHolder.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Common.Memory;
 using Silk.NET.Vulkan;
 using System;
+using System.Buffers;
 
 namespace Ryujinx.Graphics.Vulkan
 {
@@ -11,7 +12,7 @@ namespace Ryujinx.Graphics.Vulkan
     {
         private const int BufferUsageTrackingGranularity = 4096;
 
-        private readonly FenceHolder[] _fences;
+        public FenceHolder[] Fences { get; }
         private readonly BufferUsageBitmap _bufferUsageBitmap;
 
         /// <summary>
@@ -19,7 +20,7 @@ namespace Ryujinx.Graphics.Vulkan
         /// </summary>
         public MultiFenceHolder()
         {
-            _fences = new FenceHolder[CommandBufferPool.MaxCommandBuffers];
+            Fences = ArrayPool<FenceHolder>.Shared.Rent(CommandBufferPool.MaxCommandBuffers);
         }
 
         /// <summary>
@@ -28,7 +29,7 @@ namespace Ryujinx.Graphics.Vulkan
         /// <param name="size">Size of the buffer</param>
         public MultiFenceHolder(int size)
         {
-            _fences = new FenceHolder[CommandBufferPool.MaxCommandBuffers];
+            Fences = ArrayPool<FenceHolder>.Shared.Rent(CommandBufferPool.MaxCommandBuffers);
             _bufferUsageBitmap = new BufferUsageBitmap(size, BufferUsageTrackingGranularity);
         }
 
@@ -90,7 +91,7 @@ namespace Ryujinx.Graphics.Vulkan
         /// <returns>True if the command buffer's previous fence value was null</returns>
         public bool AddFence(int cbIndex, FenceHolder fence)
         {
-            ref FenceHolder fenceRef = ref _fences[cbIndex];
+            ref FenceHolder fenceRef = ref Fences[cbIndex];
 
             if (fenceRef == null)
             {
@@ -107,7 +108,7 @@ namespace Ryujinx.Graphics.Vulkan
         /// <param name="cbIndex">Command buffer index of the command buffer that owns the fence</param>
         public void RemoveFence(int cbIndex)
         {
-            _fences[cbIndex] = null;
+            Fences[cbIndex] = null;
         }
 
         /// <summary>
@@ -117,7 +118,7 @@ namespace Ryujinx.Graphics.Vulkan
         /// <returns>True if referenced, false otherwise</returns>
         public bool HasFence(int cbIndex)
         {
-            return _fences[cbIndex] != null;
+            return Fences[cbIndex] != null;
         }
 
         /// <summary>
@@ -227,9 +228,9 @@ namespace Ryujinx.Graphics.Vulkan
         {
             int count = 0;
 
-            for (int i = 0; i < _fences.Length; i++)
+            for (int i = 0; i < Fences.Length; i++)
             {
-                FenceHolder fence = _fences[i];
+                FenceHolder fence = Fences[i];
 
                 if (fence != null)
                 {
@@ -251,9 +252,9 @@ namespace Ryujinx.Graphics.Vulkan
         {
             int count = 0;
 
-            for (int i = 0; i < _fences.Length; i++)
+            for (int i = 0; i < Fences.Length; i++)
             {
-                FenceHolder fence = _fences[i];
+                FenceHolder fence = Fences[i];
 
                 if (fence != null && _bufferUsageBitmap.OverlapsWith(i, offset, size))
                 {