Update audio renderer to REV13: Add support for compressor statistics and volume reset (#7372)

* Update audio renderer to REV13: Add support for compressor statistics and volume reset

* XML docs

* Disable stats reset

* Wrong comment

* Fix more XML docs

* PR feedback

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -23,7 +23,7 @@ body:
     attributes:
       label: Log file
       description: A log file will help our developers to better diagnose and fix the issue.
-      placeholder: Logs files can be found under "Logs" folder in Ryujinx program folder. You can drag and drop the log on to the text area
+      placeholder: Logs files can be found under "Logs" folder in Ryujinx program folder. They can also be accessed by opening Ryujinx, then going to File > Open Logs Folder. You can drag and drop the log on to the text area (do not copy paste).
     validations:
       required: true
   - type: input
@@ -83,4 +83,4 @@ body:
         - Additional info about your environment:
         - Any other information relevant to your issue.
     validations:
-      required: false
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,6 +1,7 @@
 name: Feature Request
 description: Suggest a new feature for Ryujinx.
 title: "[Feature Request]"
+labels: enhancement
 body:
   - type: textarea
     id: overview

.github/workflows/build.yml

@@ -20,7 +20,7 @@ jobs:
           - { name: win-x64,     os: windows-latest, zip_os_name: win_x64     }
           - { name: linux-x64,   os: ubuntu-latest,  zip_os_name: linux_x64   }
           - { name: linux-arm64, os: ubuntu-latest,  zip_os_name: linux_arm64 }
-          - { name: osx-x64,     os: macOS-latest,   zip_os_name: osx_x64     }
+          - { name: osx-x64,     os: macos-13,       zip_os_name: osx_x64     }
 
       fail-fast: false
     steps:
@@ -41,12 +41,12 @@ jobs:
       - name: Change config filename
         run: sed -r --in-place 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/PRConfig\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
         shell: bash
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Change config filename for macOS
         run: sed -r -i '' 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/PRConfig\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
         shell: bash
-        if: github.event_name == 'pull_request' && matrix.platform.os == 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os == 'macos-13'
 
       - name: Build
         run: dotnet build -c "${{ matrix.configuration }}" -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER
@@ -61,15 +61,15 @@ jobs:
 
       - name: Publish Ryujinx
         run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.platform.name }}" -o ./publish -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx --self-contained true
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Publish Ryujinx.Headless.SDL2
         run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.platform.name }}" -o ./publish_sdl2_headless -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Headless.SDL2 --self-contained true
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Publish Ryujinx.Gtk3
         run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.platform.name }}" -o ./publish_gtk -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Gtk3 --self-contained true
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Set executable bit
         run: |
@@ -83,21 +83,21 @@ jobs:
         with:
           name: ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.platform.zip_os_name }}
           path: publish
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Upload Ryujinx.Headless.SDL2 artifact
         uses: actions/upload-artifact@v4
         with:
           name: sdl2-ryujinx-headless-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.platform.zip_os_name }}
           path: publish_sdl2_headless
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
       - name: Upload Ryujinx.Gtk3 artifact
         uses: actions/upload-artifact@v4
         with:
           name: gtk-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.platform.zip_os_name }}
           path: publish_gtk
-        if: github.event_name == 'pull_request' && matrix.platform.os != 'macOS-latest'
+        if: github.event_name == 'pull_request' && matrix.platform.os != 'macos-13'
 
   build_macos:
     name: macOS Universal (${{ matrix.configuration }})

Directory.Packages.props

@@ -8,21 +8,21 @@
     <PackageVersion Include="Avalonia.Desktop" Version="11.0.10" />
     <PackageVersion Include="Avalonia.Diagnostics" Version="11.0.10" />
     <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="11.0.10" />
-    <PackageVersion Include="Avalonia.Svg" Version="11.0.0.16" />
-    <PackageVersion Include="Avalonia.Svg.Skia" Version="11.0.0.16" />
+    <PackageVersion Include="Avalonia.Svg" Version="11.0.0.18" />
+    <PackageVersion Include="Avalonia.Svg.Skia" Version="11.0.0.18" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
-    <PackageVersion Include="Concentus" Version="1.1.7" />
+    <PackageVersion Include="Concentus" Version="2.2.0" />
     <PackageVersion Include="DiscordRichPresence" Version="1.2.1.24" />
-    <PackageVersion Include="DynamicData" Version="8.3.27" />
+    <PackageVersion Include="DynamicData" Version="9.0.4" />
     <PackageVersion Include="FluentAvaloniaUI" Version="2.0.5" />
     <PackageVersion Include="GtkSharp.Dependencies" Version="1.1.1" />
     <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
     <PackageVersion Include="LibHac" Version="0.19.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
-    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="7.4.0" />
+    <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="8.0.1" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
-    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.0" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
     <PackageVersion Include="NetCoreServer" Version="8.0.7" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
@@ -39,14 +39,14 @@
     <PackageVersion Include="securifybv.ShellLink" Version="0.1.0" />
     <PackageVersion Include="shaderc.net" Version="0.1.0" />
     <PackageVersion Include="SharpZipLib" Version="1.4.2" />
-    <PackageVersion Include="Silk.NET.Vulkan" Version="2.16.0" />
-    <PackageVersion Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
-    <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.16.0" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="2.1.7" />
-    <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0" />
+    <PackageVersion Include="Silk.NET.Vulkan" Version="2.21.0" />
+    <PackageVersion Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.21.0" />
+    <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.21.0" />
+    <PackageVersion Include="SkiaSharp" Version="2.88.7" />
+    <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="2.88.7" />
     <PackageVersion Include="SPB" Version="0.0.4-build32" />
     <PackageVersion Include="System.IO.Hashing" Version="8.0.0" />
     <PackageVersion Include="System.Management" Version="8.0.0" />
     <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
   </ItemGroup>
-</Project>
+</Project>

README.md

@@ -36,8 +36,8 @@
 
 ## Compatibility
 
-As of October 2023, Ryujinx has been tested on approximately 4,200 titles;
-over 4,150 boot past menus and into gameplay, with roughly 3,500 of those being considered playable.
+As of May 2024, Ryujinx has been tested on approximately 4,300 titles;
+over 4,100 boot past menus and into gameplay, with roughly 3,550 of those being considered playable.
 
 You can check out the compatibility list [here](https://github.com/Ryujinx/Ryujinx-Games-List/issues).
 

Ryujinx.sln

@@ -87,6 +87,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon", "src\Ryuj
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Kernel.Generators", "src\Ryujinx.Horizon.Kernel.Generators\Ryujinx.Horizon.Kernel.Generators.csproj", "{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.HLE.Generators", "src\Ryujinx.HLE.Generators\Ryujinx.HLE.Generators.csproj", "{B575BCDE-2FD8-4A5D-8756-31CDD7FE81F0}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -249,6 +251,10 @@ Global
 		{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B575BCDE-2FD8-4A5D-8756-31CDD7FE81F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B575BCDE-2FD8-4A5D-8756-31CDD7FE81F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B575BCDE-2FD8-4A5D-8756-31CDD7FE81F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B575BCDE-2FD8-4A5D-8756-31CDD7FE81F0}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Ryujinx.sln.DotSettings

@@ -4,6 +4,8 @@
 	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseExplicitType</s:String>
 	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseExplicitType</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=TypesAndNamespaces/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="I" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=a0b4bc4d_002Dd13b_002D4a37_002Db37e_002Dc9c6864e4302/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Any" AccessRightKinds="Any" Description="Types and namespaces"&gt;&lt;ElementKinds&gt;&lt;Kind Name="NAMESPACE" /&gt;&lt;Kind Name="CLASS" /&gt;&lt;Kind Name="STRUCT" /&gt;&lt;Kind Name="ENUM" /&gt;&lt;Kind Name="DELEGATE" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"&gt;&lt;ExtraRule Prefix="I" Suffix="" Style="AaBb" /&gt;&lt;/Policy&gt;&lt;/Policy&gt;</s:String>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EPredefinedNamingRulesToUserRulesUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=ASET/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Astc/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Luma/@EntryIndexedValue">True</s:Boolean>

docs/README.md

@@ -33,8 +33,3 @@ Project Docs
 =================
 
 To be added. Many project files will contain basic XML docs for key functions and classes in the meantime.
-
-Other Information
-=================
-
-- N/A

src/ARMeilleure/CodeGen/Arm64/CodeGenContext.cs

@@ -237,7 +237,7 @@ namespace ARMeilleure.CodeGen.Arm64
             long originalPosition = _stream.Position;
 
             _stream.Seek(0, SeekOrigin.Begin);
-            _stream.Read(code, 0, code.Length);
+            _stream.ReadExactly(code, 0, code.Length);
             _stream.Seek(originalPosition, SeekOrigin.Begin);
 
             RelocInfo relocInfo;

src/ARMeilleure/CodeGen/RegisterAllocators/LinearScanAllocator.cs

@@ -251,7 +251,20 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
                 }
             }
 
-            int selectedReg = GetHighestValueIndex(freePositions);
+            // If this is a copy destination variable, we prefer the register used for the copy source.
+            // If the register is available, then the copy can be eliminated later as both source
+            // and destination will use the same register.
+            int selectedReg;
+
+            if (current.TryGetCopySourceRegister(out int preferredReg) && freePositions[preferredReg] >= current.GetEnd())
+            {
+                selectedReg = preferredReg;
+            }
+            else
+            {
+                selectedReg = GetHighestValueIndex(freePositions);
+            }
+
             int selectedNextUse = freePositions[selectedReg];
 
             // Intervals starts and ends at odd positions, unless they span an entire
@@ -431,7 +444,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
             }
         }
 
-        private static int GetHighestValueIndex(Span<int> span)
+        private static int GetHighestValueIndex(ReadOnlySpan<int> span)
         {
             int highest = int.MinValue;
 
@@ -798,12 +811,12 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
             // The "visited" state is stored in the MSB of the local's value.
             const ulong VisitedMask = 1ul << 63;
 
-            bool IsVisited(Operand local)
+            static bool IsVisited(Operand local)
             {
                 return (local.GetValueUnsafe() & VisitedMask) != 0;
             }
 
-            void SetVisited(Operand local)
+            static void SetVisited(Operand local)
             {
                 local.GetValueUnsafe() |= VisitedMask;
             }
@@ -826,9 +839,25 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
                         {
                             dest.NumberLocal(_intervals.Count);
 
-                            _intervals.Add(new LiveInterval(dest));
+                            LiveInterval interval = new LiveInterval(dest);
+                            _intervals.Add(interval);
 
                             SetVisited(dest);
+
+                            // If this is a copy (or copy-like operation), set the copy source interval as well.
+                            // This is used for register preferencing later on, which allows the copy to be eliminated
+                            // in some cases.
+                            if (node.Instruction == Instruction.Copy || node.Instruction == Instruction.ZeroExtend32)
+                            {
+                                Operand source = node.GetSource(0);
+
+                                if (source.Kind == OperandKind.LocalVariable &&
+                                    source.GetLocalNumber() > 0 &&
+                                    (node.Instruction == Instruction.Copy || source.Type == OperandType.I32))
+                                {
+                                    interval.SetCopySource(_intervals[source.GetLocalNumber()]);
+                                }
+                            }
                         }
                     }
                 }

src/ARMeilleure/CodeGen/RegisterAllocators/LiveInterval.cs

@@ -19,6 +19,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
             public LiveRange CurrRange;
 
             public LiveInterval Parent;
+            public LiveInterval CopySource;
 
             public UseList Uses;
             public LiveIntervalList Children;
@@ -37,6 +38,7 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
         private ref LiveRange CurrRange => ref _data->CurrRange;
         private ref LiveRange PrevRange => ref _data->PrevRange;
         private ref LiveInterval Parent => ref _data->Parent;
+        private ref LiveInterval CopySource => ref _data->CopySource;
         private ref UseList Uses => ref _data->Uses;
         private ref LiveIntervalList Children => ref _data->Children;
 
@@ -78,6 +80,25 @@ namespace ARMeilleure.CodeGen.RegisterAllocators
             Register = register;
         }
 
+        public void SetCopySource(LiveInterval copySource)
+        {
+            CopySource = copySource;
+        }
+
+        public bool TryGetCopySourceRegister(out int copySourceRegIndex)
+        {
+            if (CopySource._data != null)
+            {
+                copySourceRegIndex = CopySource.Register.Index;
+
+                return true;
+            }
+
+            copySourceRegIndex = 0;
+
+            return false;
+        }
+
         public void Reset()
         {
             PrevRange = default;

src/ARMeilleure/CodeGen/X86/Assembler.cs

@@ -1444,7 +1444,7 @@ namespace ARMeilleure.CodeGen.X86
 
                 Span<byte> buffer = new byte[jump.JumpPosition - _stream.Position];
 
-                _stream.Read(buffer);
+                _stream.ReadExactly(buffer);
                 _stream.Seek(ReservedBytesForJump, SeekOrigin.Current);
 
                 codeStream.Write(buffer);

src/ARMeilleure/Decoders/OpCodeTable.cs

@@ -746,6 +746,7 @@ namespace ARMeilleure.Decoders
             SetA32("<<<<01101000xxxxxxxxxxxxxx01xxxx", InstName.Pkh,     InstEmit32.Pkh,     OpCode32AluRsImm.Create);
             SetA32("11110101xx01xxxx1111xxxxxxxxxxxx", InstName.Pld,     InstEmit32.Nop,     OpCode32.Create);
             SetA32("11110111xx01xxxx1111xxxxxxx0xxxx", InstName.Pld,     InstEmit32.Nop,     OpCode32.Create);
+            SetA32("<<<<01100010xxxxxxxx11110001xxxx", InstName.Qadd16,  InstEmit32.Qadd16,  OpCode32AluReg.Create);
             SetA32("<<<<011011111111xxxx11110011xxxx", InstName.Rbit,    InstEmit32.Rbit,    OpCode32AluReg.Create);
             SetA32("<<<<011010111111xxxx11110011xxxx", InstName.Rev,     InstEmit32.Rev,     OpCode32AluReg.Create);
             SetA32("<<<<011010111111xxxx11111011xxxx", InstName.Rev16,   InstEmit32.Rev16,   OpCode32AluReg.Create);
@@ -822,6 +823,10 @@ namespace ARMeilleure.Decoders
             SetA32("<<<<00000100xxxxxxxxxxxx1001xxxx", InstName.Umaal,   InstEmit32.Umaal,   OpCode32AluUmull.Create);
             SetA32("<<<<0000101xxxxxxxxxxxxx1001xxxx", InstName.Umlal,   InstEmit32.Umlal,   OpCode32AluUmull.Create);
             SetA32("<<<<0000100xxxxxxxxxxxxx1001xxxx", InstName.Umull,   InstEmit32.Umull,   OpCode32AluUmull.Create);
+            SetA32("<<<<01100110xxxxxxxx11110001xxxx", InstName.Uqadd16, InstEmit32.Uqadd16, OpCode32AluReg.Create);
+            SetA32("<<<<01100110xxxxxxxx11111001xxxx", InstName.Uqadd8,  InstEmit32.Uqadd8,  OpCode32AluReg.Create);
+            SetA32("<<<<01100110xxxxxxxx11110111xxxx", InstName.Uqsub16, InstEmit32.Uqsub16, OpCode32AluReg.Create);
+            SetA32("<<<<01100110xxxxxxxx11111111xxxx", InstName.Uqsub8,  InstEmit32.Uqsub8,  OpCode32AluReg.Create);
             SetA32("<<<<0110111xxxxxxxxxxxxxxx01xxxx", InstName.Usat,    InstEmit32.Usat,    OpCode32Sat.Create);
             SetA32("<<<<01101110xxxxxxxx11110011xxxx", InstName.Usat16,  InstEmit32.Usat16,  OpCode32Sat16.Create);
             SetA32("<<<<01100101xxxxxxxx11111111xxxx", InstName.Usub8,   InstEmit32.Usub8,   OpCode32AluReg.Create);
@@ -1007,6 +1012,8 @@ namespace ARMeilleure.Decoders
             SetAsimd("111100100x10xxxxxxxx1011xxx0xxxx", InstName.Vqdmulh,     InstEmit32.Vqdmulh,      OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);
             SetAsimd("111100111x11<<10xxxx00101xx0xxx0", InstName.Vqmovn,      InstEmit32.Vqmovn,       OpCode32SimdMovn.Create,        OpCode32SimdMovn.CreateT32);
             SetAsimd("111100111x11<<10xxxx001001x0xxx0", InstName.Vqmovun,     InstEmit32.Vqmovun,      OpCode32SimdMovn.Create,        OpCode32SimdMovn.CreateT32);
+            SetAsimd("111100110x01xxxxxxxx1011xxx0xxxx", InstName.Vqrdmulh,    InstEmit32.Vqrdmulh,     OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);
+            SetAsimd("111100110x10xxxxxxxx1011xxx0xxxx", InstName.Vqrdmulh,    InstEmit32.Vqrdmulh,     OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);
             SetAsimd("1111001x1x>>>xxxxxxx100101x1xxx0", InstName.Vqrshrn,     InstEmit32.Vqrshrn,      OpCode32SimdShImmNarrow.Create, OpCode32SimdShImmNarrow.CreateT32);
             SetAsimd("111100111x>>>xxxxxxx100001x1xxx0", InstName.Vqrshrun,    InstEmit32.Vqrshrun,     OpCode32SimdShImmNarrow.Create, OpCode32SimdShImmNarrow.CreateT32);
             SetAsimd("1111001x1x>>>xxxxxxx100100x1xxx0", InstName.Vqshrn,      InstEmit32.Vqshrn,       OpCode32SimdShImmNarrow.Create, OpCode32SimdShImmNarrow.CreateT32);
@@ -1028,8 +1035,10 @@ namespace ARMeilleure.Decoders
             SetAsimd("111100101x>>>xxxxxxx0101>xx1xxxx", InstName.Vshl,        InstEmit32.Vshl,         OpCode32SimdShImm.Create,       OpCode32SimdShImm.CreateT32);
             SetAsimd("1111001x0xxxxxxxxxxx0100xxx0xxxx", InstName.Vshl,        InstEmit32.Vshl_I,       OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);
             SetAsimd("1111001x1x>>>xxxxxxx101000x1xxxx", InstName.Vshll,       InstEmit32.Vshll,        OpCode32SimdShImmLong.Create,   OpCode32SimdShImmLong.CreateT32); // A1 encoding.
+            SetAsimd("111100111x11<<10xxxx001100x0xxxx", InstName.Vshll,       InstEmit32.Vshll2,       OpCode32SimdMovn.Create,        OpCode32SimdMovn.CreateT32); // A2 encoding.
             SetAsimd("1111001x1x>>>xxxxxxx0000>xx1xxxx", InstName.Vshr,        InstEmit32.Vshr,         OpCode32SimdShImm.Create,       OpCode32SimdShImm.CreateT32);
             SetAsimd("111100101x>>>xxxxxxx100000x1xxx0", InstName.Vshrn,       InstEmit32.Vshrn,        OpCode32SimdShImmNarrow.Create, OpCode32SimdShImmNarrow.CreateT32);
+            SetAsimd("111100111x>>>xxxxxxx0101>xx1xxxx", InstName.Vsli,        InstEmit32.Vsli_I,       OpCode32SimdShImm.Create,       OpCode32SimdShImm.CreateT32);
             SetAsimd("1111001x1x>>>xxxxxxx0001>xx1xxxx", InstName.Vsra,        InstEmit32.Vsra,         OpCode32SimdShImm.Create,       OpCode32SimdShImm.CreateT32);
             SetAsimd("111101001x00xxxxxxxx0000xxx0xxxx", InstName.Vst1,        InstEmit32.Vst1,         OpCode32SimdMemSingle.Create,   OpCode32SimdMemSingle.CreateT32);
             SetAsimd("111101001x00xxxxxxxx0100xx0xxxxx", InstName.Vst1,        InstEmit32.Vst1,         OpCode32SimdMemSingle.Create,   OpCode32SimdMemSingle.CreateT32);
@@ -1054,6 +1063,7 @@ namespace ARMeilleure.Decoders
             SetAsimd("111100100x10xxxxxxxx1101xxx0xxxx", InstName.Vsub,        InstEmit32.Vsub_V,       OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);
             SetAsimd("1111001x1x<<xxxxxxx00010x0x0xxxx", InstName.Vsubl,       InstEmit32.Vsubl_I,      OpCode32SimdRegLong.Create,     OpCode32SimdRegLong.CreateT32);
             SetAsimd("1111001x1x<<xxxxxxx00011x0x0xxxx", InstName.Vsubw,       InstEmit32.Vsubw_I,      OpCode32SimdRegWide.Create,     OpCode32SimdRegWide.CreateT32);
+            SetAsimd("111100111x110010xxxx00000xx0xxxx", InstName.Vswp,        InstEmit32.Vswp,         OpCode32Simd.Create,            OpCode32Simd.CreateT32);
             SetAsimd("111100111x11xxxxxxxx10xxxxx0xxxx", InstName.Vtbl,        InstEmit32.Vtbl,         OpCode32SimdTbl.Create,         OpCode32SimdTbl.CreateT32);
             SetAsimd("111100111x11<<10xxxx00001xx0xxxx", InstName.Vtrn,        InstEmit32.Vtrn,         OpCode32SimdCmpZ.Create,        OpCode32SimdCmpZ.CreateT32);
             SetAsimd("111100100x<<xxxxxxxx1000xxx1xxxx", InstName.Vtst,        InstEmit32.Vtst,         OpCode32SimdReg.Create,         OpCode32SimdReg.CreateT32);

src/ARMeilleure/Instructions/InstEmitAlu32.cs

@@ -2,6 +2,8 @@ using ARMeilleure.Decoders;
 using ARMeilleure.IntermediateRepresentation;
 using ARMeilleure.State;
 using ARMeilleure.Translation;
+using System;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using static ARMeilleure.Instructions.InstEmitAluHelper;
 using static ARMeilleure.Instructions.InstEmitHelper;
@@ -19,6 +21,12 @@ namespace ARMeilleure.Instructions
             Operand n = GetAluN(context);
             Operand m = GetAluM(context, setCarry: false);
 
+            if (op.Rn == RegisterAlias.Aarch32Pc && op is OpCodeT32AluImm12)
+            {
+                // For ADR, PC is always 4 bytes aligned, even in Thumb mode.
+                n = context.BitwiseAnd(n, Const(~3u));
+            }
+
             Operand res = context.Add(n, m);
 
             if (ShouldSetFlags(context))
@@ -284,6 +292,16 @@ namespace ARMeilleure.Instructions
             EmitAluStore(context, res);
         }
 
+        public static void Qadd16(ArmEmitterContext context)
+        {
+            OpCode32AluReg op = (OpCode32AluReg)context.CurrOp;
+
+            SetIntA32(context, op.Rd, EmitSigned16BitPair(context, GetIntA32(context, op.Rn), GetIntA32(context, op.Rm), (d, n, m) =>
+            {
+                EmitSaturateRange(context, d, context.Add(n, m), 16, unsigned: false, setQ: false);
+            }));
+        }
+
         public static void Rbit(ArmEmitterContext context)
         {
             Operand m = GetAluM(context);
@@ -467,6 +485,12 @@ namespace ARMeilleure.Instructions
             Operand n = GetAluN(context);
             Operand m = GetAluM(context, setCarry: false);
 
+            if (op.Rn == RegisterAlias.Aarch32Pc && op is OpCodeT32AluImm12)
+            {
+                // For ADR, PC is always 4 bytes aligned, even in Thumb mode.
+                n = context.BitwiseAnd(n, Const(~3u));
+            }
+
             Operand res = context.Subtract(n, m);
 
             if (ShouldSetFlags(context))
@@ -546,6 +570,46 @@ namespace ARMeilleure.Instructions
             EmitHsub8(context, unsigned: true);
         }
 
+        public static void Uqadd16(ArmEmitterContext context)
+        {
+            OpCode32AluReg op = (OpCode32AluReg)context.CurrOp;
+
+            SetIntA32(context, op.Rd, EmitUnsigned16BitPair(context, GetIntA32(context, op.Rn), GetIntA32(context, op.Rm), (d, n, m) =>
+            {
+                EmitSaturateUqadd(context, d, context.Add(n, m), 16);
+            }));
+        }
+
+        public static void Uqadd8(ArmEmitterContext context)
+        {
+            OpCode32AluReg op = (OpCode32AluReg)context.CurrOp;
+
+            SetIntA32(context, op.Rd, EmitUnsigned8BitPair(context, GetIntA32(context, op.Rn), GetIntA32(context, op.Rm), (d, n, m) =>
+            {
+                EmitSaturateUqadd(context, d, context.Add(n, m), 8);
+            }));
+        }
+
+        public static void Uqsub16(ArmEmitterContext context)
+        {
+            OpCode32AluReg op = (OpCode32AluReg)context.CurrOp;
+
+            SetIntA32(context, op.Rd, EmitUnsigned16BitPair(context, GetIntA32(context, op.Rn), GetIntA32(context, op.Rm), (d, n, m) =>
+            {
+                EmitSaturateUqsub(context, d, context.Subtract(n, m), 16);
+            }));
+        }
+
+        public static void Uqsub8(ArmEmitterContext context)
+        {
+            OpCode32AluReg op = (OpCode32AluReg)context.CurrOp;
+
+            SetIntA32(context, op.Rd, EmitUnsigned8BitPair(context, GetIntA32(context, op.Rn), GetIntA32(context, op.Rm), (d, n, m) =>
+            {
+                EmitSaturateUqsub(context, d, context.Subtract(n, m), 8);
+            }));
+        }
+
         public static void Usat(ArmEmitterContext context)
         {
             OpCode32Sat op = (OpCode32Sat)context.CurrOp;
@@ -922,6 +986,251 @@ namespace ARMeilleure.Instructions
             }
         }
 
+        private static void EmitSaturateRange(ArmEmitterContext context, Operand result, Operand value, uint saturateTo, bool unsigned, bool setQ = true)
+        {
+            Debug.Assert(saturateTo <= 32);
+            Debug.Assert(!unsigned || saturateTo < 32);
+
+            if (!unsigned && saturateTo == 32)
+            {
+                // No saturation possible for this case.
+
+                context.Copy(result, value);
+
+                return;
+            }
+            else if (saturateTo == 0)
+            {
+                // Result is always zero if we saturate 0 bits.
+
+                context.Copy(result, Const(0));
+
+                return;
+            }
+
+            Operand satValue;
+
+            if (unsigned)
+            {
+                // Negative values always saturate (to zero).
+                // So we must always ignore the sign bit when masking, so that the truncated value will differ from the original one.
+
+                satValue = context.BitwiseAnd(value, Const((int)(uint.MaxValue >> (32 - (int)saturateTo))));
+            }
+            else
+            {
+                satValue = context.ShiftLeft(value, Const(32 - (int)saturateTo));
+                satValue = context.ShiftRightSI(satValue, Const(32 - (int)saturateTo));
+            }
+
+            // If the result is 0, the values are equal and we don't need saturation.
+            Operand lblNoSat = Label();
+            context.BranchIfFalse(lblNoSat, context.Subtract(value, satValue));
+
+            // Saturate and set Q flag.
+            if (unsigned)
+            {
+                if (saturateTo == 31)
+                {
+                    // Only saturation case possible when going from 32 bits signed to 32 or 31 bits unsigned
+                    // is when the signed input is negative, as all positive values are representable on a 31 bits range.
+
+                    satValue = Const(0);
+                }
+                else
+                {
+                    satValue = context.ShiftRightSI(value, Const(31));
+                    satValue = context.BitwiseNot(satValue);
+                    satValue = context.ShiftRightUI(satValue, Const(32 - (int)saturateTo));
+                }
+            }
+            else
+            {
+                if (saturateTo == 1)
+                {
+                    satValue = context.ShiftRightSI(value, Const(31));
+                }
+                else
+                {
+                    satValue = Const(uint.MaxValue >> (33 - (int)saturateTo));
+                    satValue = context.BitwiseExclusiveOr(satValue, context.ShiftRightSI(value, Const(31)));
+                }
+            }
+
+            if (setQ)
+            {
+                SetFlag(context, PState.QFlag, Const(1));
+            }
+
+            context.Copy(result, satValue);
+
+            Operand lblExit = Label();
+            context.Branch(lblExit);
+
+            context.MarkLabel(lblNoSat);
+
+            context.Copy(result, value);
+
+            context.MarkLabel(lblExit);
+        }
+
+        private static void EmitSaturateUqadd(ArmEmitterContext context, Operand result, Operand value, uint saturateTo)
+        {
+            Debug.Assert(saturateTo <= 32);
+
+            if (saturateTo == 32)
+            {
+                // No saturation possible for this case.
+
+                context.Copy(result, value);
+
+                return;
+            }
+            else if (saturateTo == 0)
+            {
+                // Result is always zero if we saturate 0 bits.
+
+                context.Copy(result, Const(0));
+
+                return;
+            }
+
+            // If the result is 0, the values are equal and we don't need saturation.
+            Operand lblNoSat = Label();
+            context.BranchIfFalse(lblNoSat, context.ShiftRightUI(value, Const((int)saturateTo)));
+
+            // Saturate.
+            context.Copy(result, Const(uint.MaxValue >> (32 - (int)saturateTo)));
+
+            Operand lblExit = Label();
+            context.Branch(lblExit);
+
+            context.MarkLabel(lblNoSat);
+
+            context.Copy(result, value);
+
+            context.MarkLabel(lblExit);
+        }
+
+        private static void EmitSaturateUqsub(ArmEmitterContext context, Operand result, Operand value, uint saturateTo)
+        {
+            Debug.Assert(saturateTo <= 32);
+
+            if (saturateTo == 32)
+            {
+                // No saturation possible for this case.
+
+                context.Copy(result, value);
+
+                return;
+            }
+            else if (saturateTo == 0)
+            {
+                // Result is always zero if we saturate 0 bits.
+
+                context.Copy(result, Const(0));
+
+                return;
+            }
+
+            // If the result is 0, the values are equal and we don't need saturation.
+            Operand lblNoSat = Label();
+            context.BranchIf(lblNoSat, value, Const(0), Comparison.GreaterOrEqual);
+
+            // Saturate.
+            // Assumes that the value can only underflow, since this is only used for unsigned subtraction.
+            context.Copy(result, Const(0));
+
+            Operand lblExit = Label();
+            context.Branch(lblExit);
+
+            context.MarkLabel(lblNoSat);
+
+            context.Copy(result, value);
+
+            context.MarkLabel(lblExit);
+        }
+
+        private static Operand EmitSigned16BitPair(ArmEmitterContext context, Operand rn, Operand rm, Action<Operand, Operand, Operand> elementAction)
+        {
+            Operand tempD = context.AllocateLocal(OperandType.I32);
+
+            Operand tempN = context.SignExtend16(OperandType.I32, rn);
+            Operand tempM = context.SignExtend16(OperandType.I32, rm);
+            elementAction(tempD, tempN, tempM);
+            Operand tempD2 = context.ZeroExtend16(OperandType.I32, tempD);
+
+            tempN = context.ShiftRightSI(rn, Const(16));
+            tempM = context.ShiftRightSI(rm, Const(16));
+            elementAction(tempD, tempN, tempM);
+            return context.BitwiseOr(tempD2, context.ShiftLeft(tempD, Const(16)));
+        }
+
+        private static Operand EmitUnsigned16BitPair(ArmEmitterContext context, Operand rn, Operand rm, Action<Operand, Operand, Operand> elementAction)
+        {
+            Operand tempD = context.AllocateLocal(OperandType.I32);
+
+            Operand tempN = context.ZeroExtend16(OperandType.I32, rn);
+            Operand tempM = context.ZeroExtend16(OperandType.I32, rm);
+            elementAction(tempD, tempN, tempM);
+            Operand tempD2 = context.ZeroExtend16(OperandType.I32, tempD);
+
+            tempN = context.ShiftRightUI(rn, Const(16));
+            tempM = context.ShiftRightUI(rm, Const(16));
+            elementAction(tempD, tempN, tempM);
+            return context.BitwiseOr(tempD2, context.ShiftLeft(tempD, Const(16)));
+        }
+
+        private static Operand EmitSigned8BitPair(ArmEmitterContext context, Operand rn, Operand rm, Action<Operand, Operand, Operand> elementAction)
+        {
+            return Emit8BitPair(context, rn, rm, elementAction, unsigned: false);
+        }
+
+        private static Operand EmitUnsigned8BitPair(ArmEmitterContext context, Operand rn, Operand rm, Action<Operand, Operand, Operand> elementAction)
+        {
+            return Emit8BitPair(context, rn, rm, elementAction, unsigned: true);
+        }
+
+        private static Operand Emit8BitPair(ArmEmitterContext context, Operand rn, Operand rm, Action<Operand, Operand, Operand> elementAction, bool unsigned)
+        {
+            Operand tempD = context.AllocateLocal(OperandType.I32);
+            Operand result = default;
+
+            for (int b = 0; b < 4; b++)
+            {
+                Operand nByte = b != 0 ? context.ShiftRightUI(rn, Const(b * 8)) : rn;
+                Operand mByte = b != 0 ? context.ShiftRightUI(rm, Const(b * 8)) : rm;
+
+                if (unsigned)
+                {
+                    nByte = context.ZeroExtend8(OperandType.I32, nByte);
+                    mByte = context.ZeroExtend8(OperandType.I32, mByte);
+                }
+                else
+                {
+                    nByte = context.SignExtend8(OperandType.I32, nByte);
+                    mByte = context.SignExtend8(OperandType.I32, mByte);
+                }
+
+                elementAction(tempD, nByte, mByte);
+
+                if (b == 0)
+                {
+                    result = context.ZeroExtend8(OperandType.I32, tempD);
+                }
+                else if (b < 3)
+                {
+                    result = context.BitwiseOr(result, context.ShiftLeft(context.ZeroExtend8(OperandType.I32, tempD), Const(b * 8)));
+                }
+                else
+                {
+                    result = context.BitwiseOr(result, context.ShiftLeft(tempD, Const(24)));
+                }
+            }
+
+            return result;
+        }
+
         private static void EmitAluStore(ArmEmitterContext context, Operand value)
         {
             IOpCode32Alu op = (IOpCode32Alu)context.CurrOp;

src/ARMeilleure/Instructions/InstEmitSimdArithmetic.cs

@@ -2426,7 +2426,11 @@ namespace ARMeilleure.Instructions
             }
             else if (Optimizations.FastFP && Optimizations.UseSse41 && sizeF == 0)
             {
-                Operand res = EmitSse41Round32Exp8OpF(context, context.AddIntrinsic(Intrinsic.X86Rsqrtss, GetVec(op.Rn)), scalar: true);
+                // RSQRTSS handles subnormals as zero, which differs from Arm, so we can't use it here.
+
+                Operand res = context.AddIntrinsic(Intrinsic.X86Sqrtss, GetVec(op.Rn));
+                res = context.AddIntrinsic(Intrinsic.X86Rcpss, res);
+                res = EmitSse41Round32Exp8OpF(context, res, scalar: true);
 
                 context.Copy(GetVec(op.Rd), context.VectorZeroUpper96(res));
             }
@@ -2451,7 +2455,11 @@ namespace ARMeilleure.Instructions
             }
             else if (Optimizations.FastFP && Optimizations.UseSse41 && sizeF == 0)
             {
-                Operand res = EmitSse41Round32Exp8OpF(context, context.AddIntrinsic(Intrinsic.X86Rsqrtps, GetVec(op.Rn)), scalar: false);
+                // RSQRTPS handles subnormals as zero, which differs from Arm, so we can't use it here.
+
+                Operand res = context.AddIntrinsic(Intrinsic.X86Sqrtps, GetVec(op.Rn));
+                res = context.AddIntrinsic(Intrinsic.X86Rcpps, res);
+                res = EmitSse41Round32Exp8OpF(context, res, scalar: false);
 
                 if (op.RegisterSize == RegisterSize.Simd64)
                 {

src/ARMeilleure/Instructions/InstEmitSimdArithmetic32.cs

@@ -1246,6 +1246,33 @@ namespace ARMeilleure.Instructions
             EmitVectorUnaryNarrowOp32(context, (op1) => EmitSatQ(context, op1, 8 << op.Size, signedSrc: true, signedDst: false), signed: true);
         }
 
+        public static void Vqrdmulh(ArmEmitterContext context)
+        {
+            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
+            int eSize = 8 << op.Size;
+
+            EmitVectorBinaryOpI32(context, (op1, op2) =>
+            {
+                if (op.Size == 2)
+                {
+                    op1 = context.SignExtend32(OperandType.I64, op1);
+                    op2 = context.SignExtend32(OperandType.I64, op2);
+                }
+
+                Operand res = context.Multiply(op1, op2);
+                res = context.Add(res, Const(res.Type, 1L << (eSize - 2)));
+                res = context.ShiftRightSI(res, Const(eSize - 1));
+                res = EmitSatQ(context, res, eSize, signedSrc: true, signedDst: true);
+
+                if (op.Size == 2)
+                {
+                    res = context.ConvertI64ToI32(res);
+                }
+
+                return res;
+            }, signed: true);
+        }
+
         public static void Vqsub(ArmEmitterContext context)
         {
             OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;

src/ARMeilleure/Instructions/InstEmitSimdMove32.cs

@@ -191,6 +191,26 @@ namespace ARMeilleure.Instructions
             context.Copy(GetVecA32(op.Qd), res);
         }
 
+        public static void Vswp(ArmEmitterContext context)
+        {
+            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
+
+            if (op.Q)
+            {
+                Operand temp = context.Copy(GetVecA32(op.Qd));
+
+                context.Copy(GetVecA32(op.Qd), GetVecA32(op.Qm));
+                context.Copy(GetVecA32(op.Qm), temp);
+            }
+            else
+            {
+                Operand temp = ExtractScalar(context, OperandType.I64, op.Vd);
+
+                InsertScalar(context, op.Vd, ExtractScalar(context, OperandType.I64, op.Vm));
+                InsertScalar(context, op.Vm, temp);
+            }
+        }
+
         public static void Vtbl(ArmEmitterContext context)
         {
             OpCode32SimdTbl op = (OpCode32SimdTbl)context.CurrOp;

src/ARMeilleure/Instructions/InstEmitSimdShift32.cs

@@ -106,6 +106,38 @@ namespace ARMeilleure.Instructions
             context.Copy(GetVecA32(op.Qd), res);
         }
 
+        public static void Vshll2(ArmEmitterContext context)
+        {
+            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
+
+            Operand res = context.VectorZero();
+
+            int elems = op.GetBytesCount() >> op.Size;
+
+            for (int index = 0; index < elems; index++)
+            {
+                Operand me = EmitVectorExtract32(context, op.Qm, op.Im + index, op.Size, !op.U);
+
+                if (op.Size == 2)
+                {
+                    if (op.U)
+                    {
+                        me = context.ZeroExtend32(OperandType.I64, me);
+                    }
+                    else
+                    {
+                        me = context.SignExtend32(OperandType.I64, me);
+                    }
+                }
+
+                me = context.ShiftLeft(me, Const(8 << op.Size));
+
+                res = EmitVectorInsert(context, res, me, index, op.Size + 1);
+            }
+
+            context.Copy(GetVecA32(op.Qd), res);
+        }
+
         public static void Vshr(ArmEmitterContext context)
         {
             OpCode32SimdShImm op = (OpCode32SimdShImm)context.CurrOp;
@@ -130,6 +162,36 @@ namespace ARMeilleure.Instructions
             EmitVectorUnaryNarrowOp32(context, (op1) => context.ShiftRightUI(op1, Const(shift)));
         }
 
+        public static void Vsli_I(ArmEmitterContext context)
+        {
+            OpCode32SimdShImm op = (OpCode32SimdShImm)context.CurrOp;
+            int shift = op.Shift;
+            int eSize = 8 << op.Size;
+
+            ulong mask = shift != 0 ? ulong.MaxValue >> (64 - shift) : 0UL;
+
+            Operand res = GetVec(op.Qd);
+
+            int elems = op.GetBytesCount() >> op.Size;
+
+            for (int index = 0; index < elems; index++)
+            {
+                Operand me = EmitVectorExtractZx(context, op.Qm, op.Im + index, op.Size);
+
+                Operand neShifted = context.ShiftLeft(me, Const(shift));
+
+                Operand de = EmitVectorExtractZx(context, op.Qd, op.Id + index, op.Size);
+
+                Operand deMasked = context.BitwiseAnd(de, Const(mask));
+
+                Operand e = context.BitwiseOr(neShifted, deMasked);
+
+                res = EmitVectorInsert(context, res, e, op.Id + index, op.Size);
+            }
+
+            context.Copy(GetVec(op.Qd), res);
+        }
+
         public static void Vsra(ArmEmitterContext context)
         {
             OpCode32SimdShImm op = (OpCode32SimdShImm)context.CurrOp;

src/ARMeilleure/Instructions/InstName.cs

@@ -527,6 +527,7 @@ namespace ARMeilleure.Instructions
         Pld,
         Pop,
         Push,
+        Qadd16,
         Rev,
         Revsh,
         Rsb,
@@ -571,6 +572,10 @@ namespace ARMeilleure.Instructions
         Umaal,
         Umlal,
         Umull,
+        Uqadd16,
+        Uqadd8,
+        Uqsub16,
+        Uqsub8,
         Usat,
         Usat16,
         Usub8,
@@ -645,6 +650,7 @@ namespace ARMeilleure.Instructions
         Vqdmulh,
         Vqmovn,
         Vqmovun,
+        Vqrdmulh,
         Vqrshrn,
         Vqrshrun,
         Vqshrn,
@@ -666,6 +672,7 @@ namespace ARMeilleure.Instructions
         Vshll,
         Vshr,
         Vshrn,
+        Vsli,
         Vst1,
         Vst2,
         Vst3,
@@ -682,6 +689,7 @@ namespace ARMeilleure.Instructions
         Vsub,
         Vsubl,
         Vsubw,
+        Vswp,
         Vtbl,
         Vtrn,
         Vtst,

src/ARMeilleure/Translation/ControlFlowGraph.cs

@@ -11,7 +11,7 @@ namespace ARMeilleure.Translation
         private int[] _postOrderMap;
 
         public int LocalsCount { get; private set; }
-        public BasicBlock Entry { get; }
+        public BasicBlock Entry { get; private set; }
         public IntrusiveList<BasicBlock> Blocks { get; }
         public BasicBlock[] PostOrderBlocks => _postOrderBlocks;
         public int[] PostOrderMap => _postOrderMap;
@@ -34,6 +34,15 @@ namespace ARMeilleure.Translation
             return result;
         }
 
+        public void UpdateEntry(BasicBlock newEntry)
+        {
+            newEntry.AddSuccessor(Entry);
+
+            Entry = newEntry;
+            Blocks.AddFirst(newEntry);
+            Update();
+        }
+
         public void Update()
         {
             RemoveUnreachableBlocks(Blocks);

src/ARMeilleure/Translation/DelegateInfo.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Translation
 {
@@ -11,11 +10,10 @@ namespace ARMeilleure.Translation
 
         public IntPtr FuncPtr { get; }
 
-        public DelegateInfo(Delegate dlg)
+        public DelegateInfo(Delegate dlg, IntPtr funcPtr)
         {
             _dlg = dlg;
-
-            FuncPtr = Marshal.GetFunctionPointerForDelegate<Delegate>(dlg);
+            FuncPtr = funcPtr;
         }
     }
 }

src/ARMeilleure/Translation/Delegates.cs

@@ -3,6 +3,7 @@ using ARMeilleure.State;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Translation
 {
@@ -64,11 +65,11 @@ namespace ARMeilleure.Translation
             return index;
         }
 
-        private static void SetDelegateInfo(Delegate dlg)
+        private static void SetDelegateInfo(Delegate dlg, IntPtr funcPtr)
         {
             string key = GetKey(dlg.Method);
 
-            _delegates.Add(key, new DelegateInfo(dlg)); // ArgumentException (key).
+            _delegates.Add(key, new DelegateInfo(dlg, funcPtr)); // ArgumentException (key).
         }
 
         private static string GetKey(MethodInfo info)
@@ -82,179 +83,353 @@ namespace ARMeilleure.Translation
         {
             _delegates = new SortedList<string, DelegateInfo>();
 
-            SetDelegateInfo(new MathAbs(Math.Abs));
-            SetDelegateInfo(new MathCeiling(Math.Ceiling));
-            SetDelegateInfo(new MathFloor(Math.Floor));
-            SetDelegateInfo(new MathRound(Math.Round));
-            SetDelegateInfo(new MathTruncate(Math.Truncate));
+            var dlgMathAbs = new MathAbs(Math.Abs);
+            var dlgMathCeiling = new MathCeiling(Math.Ceiling);
+            var dlgMathFloor = new MathFloor(Math.Floor);
+            var dlgMathRound = new MathRound(Math.Round);
+            var dlgMathTruncate = new MathTruncate(Math.Truncate);
 
-            SetDelegateInfo(new MathFAbs(MathF.Abs));
-            SetDelegateInfo(new MathFCeiling(MathF.Ceiling));
-            SetDelegateInfo(new MathFFloor(MathF.Floor));
-            SetDelegateInfo(new MathFRound(MathF.Round));
-            SetDelegateInfo(new MathFTruncate(MathF.Truncate));
+            var dlgMathFAbs = new MathFAbs(MathF.Abs);
+            var dlgMathFCeiling = new MathFCeiling(MathF.Ceiling);
+            var dlgMathFFloor = new MathFFloor(MathF.Floor);
+            var dlgMathFRound = new MathFRound(MathF.Round);
+            var dlgMathFTruncate = new MathFTruncate(MathF.Truncate);
 
-            SetDelegateInfo(new NativeInterfaceBreak(NativeInterface.Break));
-            SetDelegateInfo(new NativeInterfaceCheckSynchronization(NativeInterface.CheckSynchronization));
-            SetDelegateInfo(new NativeInterfaceEnqueueForRejit(NativeInterface.EnqueueForRejit));
-            SetDelegateInfo(new NativeInterfaceGetCntfrqEl0(NativeInterface.GetCntfrqEl0));
-            SetDelegateInfo(new NativeInterfaceGetCntpctEl0(NativeInterface.GetCntpctEl0));
-            SetDelegateInfo(new NativeInterfaceGetCntvctEl0(NativeInterface.GetCntvctEl0));
-            SetDelegateInfo(new NativeInterfaceGetCtrEl0(NativeInterface.GetCtrEl0));
-            SetDelegateInfo(new NativeInterfaceGetDczidEl0(NativeInterface.GetDczidEl0));
-            SetDelegateInfo(new NativeInterfaceGetFunctionAddress(NativeInterface.GetFunctionAddress));
-            SetDelegateInfo(new NativeInterfaceInvalidateCacheLine(NativeInterface.InvalidateCacheLine));
-            SetDelegateInfo(new NativeInterfaceReadByte(NativeInterface.ReadByte));
-            SetDelegateInfo(new NativeInterfaceReadUInt16(NativeInterface.ReadUInt16));
-            SetDelegateInfo(new NativeInterfaceReadUInt32(NativeInterface.ReadUInt32));
-            SetDelegateInfo(new NativeInterfaceReadUInt64(NativeInterface.ReadUInt64));
-            SetDelegateInfo(new NativeInterfaceReadVector128(NativeInterface.ReadVector128));
-            SetDelegateInfo(new NativeInterfaceSignalMemoryTracking(NativeInterface.SignalMemoryTracking));
-            SetDelegateInfo(new NativeInterfaceSupervisorCall(NativeInterface.SupervisorCall));
-            SetDelegateInfo(new NativeInterfaceThrowInvalidMemoryAccess(NativeInterface.ThrowInvalidMemoryAccess));
-            SetDelegateInfo(new NativeInterfaceUndefined(NativeInterface.Undefined));
-            SetDelegateInfo(new NativeInterfaceWriteByte(NativeInterface.WriteByte));
-            SetDelegateInfo(new NativeInterfaceWriteUInt16(NativeInterface.WriteUInt16));
-            SetDelegateInfo(new NativeInterfaceWriteUInt32(NativeInterface.WriteUInt32));
-            SetDelegateInfo(new NativeInterfaceWriteUInt64(NativeInterface.WriteUInt64));
-            SetDelegateInfo(new NativeInterfaceWriteVector128(NativeInterface.WriteVector128));
+            var dlgNativeInterfaceBreak = new NativeInterfaceBreak(NativeInterface.Break);
+            var dlgNativeInterfaceCheckSynchronization = new NativeInterfaceCheckSynchronization(NativeInterface.CheckSynchronization);
+            var dlgNativeInterfaceEnqueueForRejit = new NativeInterfaceEnqueueForRejit(NativeInterface.EnqueueForRejit);
+            var dlgNativeInterfaceGetCntfrqEl0 = new NativeInterfaceGetCntfrqEl0(NativeInterface.GetCntfrqEl0);
+            var dlgNativeInterfaceGetCntpctEl0 = new NativeInterfaceGetCntpctEl0(NativeInterface.GetCntpctEl0);
+            var dlgNativeInterfaceGetCntvctEl0 = new NativeInterfaceGetCntvctEl0(NativeInterface.GetCntvctEl0);
+            var dlgNativeInterfaceGetCtrEl0 = new NativeInterfaceGetCtrEl0(NativeInterface.GetCtrEl0);
+            var dlgNativeInterfaceGetDczidEl0 = new NativeInterfaceGetDczidEl0(NativeInterface.GetDczidEl0);
+            var dlgNativeInterfaceGetFunctionAddress = new NativeInterfaceGetFunctionAddress(NativeInterface.GetFunctionAddress);
+            var dlgNativeInterfaceInvalidateCacheLine = new NativeInterfaceInvalidateCacheLine(NativeInterface.InvalidateCacheLine);
+            var dlgNativeInterfaceReadByte = new NativeInterfaceReadByte(NativeInterface.ReadByte);
+            var dlgNativeInterfaceReadUInt16 = new NativeInterfaceReadUInt16(NativeInterface.ReadUInt16);
+            var dlgNativeInterfaceReadUInt32 = new NativeInterfaceReadUInt32(NativeInterface.ReadUInt32);
+            var dlgNativeInterfaceReadUInt64 = new NativeInterfaceReadUInt64(NativeInterface.ReadUInt64);
+            var dlgNativeInterfaceReadVector128 = new NativeInterfaceReadVector128(NativeInterface.ReadVector128);
+            var dlgNativeInterfaceSignalMemoryTracking = new NativeInterfaceSignalMemoryTracking(NativeInterface.SignalMemoryTracking);
+            var dlgNativeInterfaceSupervisorCall = new NativeInterfaceSupervisorCall(NativeInterface.SupervisorCall);
+            var dlgNativeInterfaceThrowInvalidMemoryAccess = new NativeInterfaceThrowInvalidMemoryAccess(NativeInterface.ThrowInvalidMemoryAccess);
+            var dlgNativeInterfaceUndefined = new NativeInterfaceUndefined(NativeInterface.Undefined);
+            var dlgNativeInterfaceWriteByte = new NativeInterfaceWriteByte(NativeInterface.WriteByte);
+            var dlgNativeInterfaceWriteUInt16 = new NativeInterfaceWriteUInt16(NativeInterface.WriteUInt16);
+            var dlgNativeInterfaceWriteUInt32 = new NativeInterfaceWriteUInt32(NativeInterface.WriteUInt32);
+            var dlgNativeInterfaceWriteUInt64 = new NativeInterfaceWriteUInt64(NativeInterface.WriteUInt64);
+            var dlgNativeInterfaceWriteVector128 = new NativeInterfaceWriteVector128(NativeInterface.WriteVector128);
 
-            SetDelegateInfo(new SoftFallbackCountLeadingSigns(SoftFallback.CountLeadingSigns));
-            SetDelegateInfo(new SoftFallbackCountLeadingZeros(SoftFallback.CountLeadingZeros));
-            SetDelegateInfo(new SoftFallbackCrc32b(SoftFallback.Crc32b));
-            SetDelegateInfo(new SoftFallbackCrc32cb(SoftFallback.Crc32cb));
-            SetDelegateInfo(new SoftFallbackCrc32ch(SoftFallback.Crc32ch));
-            SetDelegateInfo(new SoftFallbackCrc32cw(SoftFallback.Crc32cw));
-            SetDelegateInfo(new SoftFallbackCrc32cx(SoftFallback.Crc32cx));
-            SetDelegateInfo(new SoftFallbackCrc32h(SoftFallback.Crc32h));
-            SetDelegateInfo(new SoftFallbackCrc32w(SoftFallback.Crc32w));
-            SetDelegateInfo(new SoftFallbackCrc32x(SoftFallback.Crc32x));
-            SetDelegateInfo(new SoftFallbackDecrypt(SoftFallback.Decrypt));
-            SetDelegateInfo(new SoftFallbackEncrypt(SoftFallback.Encrypt));
-            SetDelegateInfo(new SoftFallbackFixedRotate(SoftFallback.FixedRotate));
-            SetDelegateInfo(new SoftFallbackHashChoose(SoftFallback.HashChoose));
-            SetDelegateInfo(new SoftFallbackHashLower(SoftFallback.HashLower));
-            SetDelegateInfo(new SoftFallbackHashMajority(SoftFallback.HashMajority));
-            SetDelegateInfo(new SoftFallbackHashParity(SoftFallback.HashParity));
-            SetDelegateInfo(new SoftFallbackHashUpper(SoftFallback.HashUpper));
-            SetDelegateInfo(new SoftFallbackInverseMixColumns(SoftFallback.InverseMixColumns));
-            SetDelegateInfo(new SoftFallbackMixColumns(SoftFallback.MixColumns));
-            SetDelegateInfo(new SoftFallbackPolynomialMult64_128(SoftFallback.PolynomialMult64_128));
-            SetDelegateInfo(new SoftFallbackSatF32ToS32(SoftFallback.SatF32ToS32));
-            SetDelegateInfo(new SoftFallbackSatF32ToS64(SoftFallback.SatF32ToS64));
-            SetDelegateInfo(new SoftFallbackSatF32ToU32(SoftFallback.SatF32ToU32));
-            SetDelegateInfo(new SoftFallbackSatF32ToU64(SoftFallback.SatF32ToU64));
-            SetDelegateInfo(new SoftFallbackSatF64ToS32(SoftFallback.SatF64ToS32));
-            SetDelegateInfo(new SoftFallbackSatF64ToS64(SoftFallback.SatF64ToS64));
-            SetDelegateInfo(new SoftFallbackSatF64ToU32(SoftFallback.SatF64ToU32));
-            SetDelegateInfo(new SoftFallbackSatF64ToU64(SoftFallback.SatF64ToU64));
-            SetDelegateInfo(new SoftFallbackSha1SchedulePart1(SoftFallback.Sha1SchedulePart1));
-            SetDelegateInfo(new SoftFallbackSha1SchedulePart2(SoftFallback.Sha1SchedulePart2));
-            SetDelegateInfo(new SoftFallbackSha256SchedulePart1(SoftFallback.Sha256SchedulePart1));
-            SetDelegateInfo(new SoftFallbackSha256SchedulePart2(SoftFallback.Sha256SchedulePart2));
-            SetDelegateInfo(new SoftFallbackSignedShrImm64(SoftFallback.SignedShrImm64));
-            SetDelegateInfo(new SoftFallbackTbl1(SoftFallback.Tbl1));
-            SetDelegateInfo(new SoftFallbackTbl2(SoftFallback.Tbl2));
-            SetDelegateInfo(new SoftFallbackTbl3(SoftFallback.Tbl3));
-            SetDelegateInfo(new SoftFallbackTbl4(SoftFallback.Tbl4));
-            SetDelegateInfo(new SoftFallbackTbx1(SoftFallback.Tbx1));
-            SetDelegateInfo(new SoftFallbackTbx2(SoftFallback.Tbx2));
-            SetDelegateInfo(new SoftFallbackTbx3(SoftFallback.Tbx3));
-            SetDelegateInfo(new SoftFallbackTbx4(SoftFallback.Tbx4));
-            SetDelegateInfo(new SoftFallbackUnsignedShrImm64(SoftFallback.UnsignedShrImm64));
+            var dlgSoftFallbackCountLeadingSigns = new SoftFallbackCountLeadingSigns(SoftFallback.CountLeadingSigns);
+            var dlgSoftFallbackCountLeadingZeros = new SoftFallbackCountLeadingZeros(SoftFallback.CountLeadingZeros);
+            var dlgSoftFallbackCrc32b = new SoftFallbackCrc32b(SoftFallback.Crc32b);
+            var dlgSoftFallbackCrc32cb = new SoftFallbackCrc32cb(SoftFallback.Crc32cb);
+            var dlgSoftFallbackCrc32ch = new SoftFallbackCrc32ch(SoftFallback.Crc32ch);
+            var dlgSoftFallbackCrc32cw = new SoftFallbackCrc32cw(SoftFallback.Crc32cw);
+            var dlgSoftFallbackCrc32cx = new SoftFallbackCrc32cx(SoftFallback.Crc32cx);
+            var dlgSoftFallbackCrc32h = new SoftFallbackCrc32h(SoftFallback.Crc32h);
+            var dlgSoftFallbackCrc32w = new SoftFallbackCrc32w(SoftFallback.Crc32w);
+            var dlgSoftFallbackCrc32x = new SoftFallbackCrc32x(SoftFallback.Crc32x);
+            var dlgSoftFallbackDecrypt = new SoftFallbackDecrypt(SoftFallback.Decrypt);
+            var dlgSoftFallbackEncrypt = new SoftFallbackEncrypt(SoftFallback.Encrypt);
+            var dlgSoftFallbackFixedRotate = new SoftFallbackFixedRotate(SoftFallback.FixedRotate);
+            var dlgSoftFallbackHashChoose = new SoftFallbackHashChoose(SoftFallback.HashChoose);
+            var dlgSoftFallbackHashLower = new SoftFallbackHashLower(SoftFallback.HashLower);
+            var dlgSoftFallbackHashMajority = new SoftFallbackHashMajority(SoftFallback.HashMajority);
+            var dlgSoftFallbackHashParity = new SoftFallbackHashParity(SoftFallback.HashParity);
+            var dlgSoftFallbackHashUpper = new SoftFallbackHashUpper(SoftFallback.HashUpper);
+            var dlgSoftFallbackInverseMixColumns = new SoftFallbackInverseMixColumns(SoftFallback.InverseMixColumns);
+            var dlgSoftFallbackMixColumns = new SoftFallbackMixColumns(SoftFallback.MixColumns);
+            var dlgSoftFallbackPolynomialMult64_128 = new SoftFallbackPolynomialMult64_128(SoftFallback.PolynomialMult64_128);
+            var dlgSoftFallbackSatF32ToS32 = new SoftFallbackSatF32ToS32(SoftFallback.SatF32ToS32);
+            var dlgSoftFallbackSatF32ToS64 = new SoftFallbackSatF32ToS64(SoftFallback.SatF32ToS64);
+            var dlgSoftFallbackSatF32ToU32 = new SoftFallbackSatF32ToU32(SoftFallback.SatF32ToU32);
+            var dlgSoftFallbackSatF32ToU64 = new SoftFallbackSatF32ToU64(SoftFallback.SatF32ToU64);
+            var dlgSoftFallbackSatF64ToS32 = new SoftFallbackSatF64ToS32(SoftFallback.SatF64ToS32);
+            var dlgSoftFallbackSatF64ToS64 = new SoftFallbackSatF64ToS64(SoftFallback.SatF64ToS64);
+            var dlgSoftFallbackSatF64ToU32 = new SoftFallbackSatF64ToU32(SoftFallback.SatF64ToU32);
+            var dlgSoftFallbackSatF64ToU64 = new SoftFallbackSatF64ToU64(SoftFallback.SatF64ToU64);
+            var dlgSoftFallbackSha1SchedulePart1 = new SoftFallbackSha1SchedulePart1(SoftFallback.Sha1SchedulePart1);
+            var dlgSoftFallbackSha1SchedulePart2 = new SoftFallbackSha1SchedulePart2(SoftFallback.Sha1SchedulePart2);
+            var dlgSoftFallbackSha256SchedulePart1 = new SoftFallbackSha256SchedulePart1(SoftFallback.Sha256SchedulePart1);
+            var dlgSoftFallbackSha256SchedulePart2 = new SoftFallbackSha256SchedulePart2(SoftFallback.Sha256SchedulePart2);
+            var dlgSoftFallbackSignedShrImm64 = new SoftFallbackSignedShrImm64(SoftFallback.SignedShrImm64);
+            var dlgSoftFallbackTbl1 = new SoftFallbackTbl1(SoftFallback.Tbl1);
+            var dlgSoftFallbackTbl2 = new SoftFallbackTbl2(SoftFallback.Tbl2);
+            var dlgSoftFallbackTbl3 = new SoftFallbackTbl3(SoftFallback.Tbl3);
+            var dlgSoftFallbackTbl4 = new SoftFallbackTbl4(SoftFallback.Tbl4);
+            var dlgSoftFallbackTbx1 = new SoftFallbackTbx1(SoftFallback.Tbx1);
+            var dlgSoftFallbackTbx2 = new SoftFallbackTbx2(SoftFallback.Tbx2);
+            var dlgSoftFallbackTbx3 = new SoftFallbackTbx3(SoftFallback.Tbx3);
+            var dlgSoftFallbackTbx4 = new SoftFallbackTbx4(SoftFallback.Tbx4);
+            var dlgSoftFallbackUnsignedShrImm64 = new SoftFallbackUnsignedShrImm64(SoftFallback.UnsignedShrImm64);
 
-            SetDelegateInfo(new SoftFloat16_32FPConvert(SoftFloat16_32.FPConvert));
-            SetDelegateInfo(new SoftFloat16_64FPConvert(SoftFloat16_64.FPConvert));
+            var dlgSoftFloat16_32FPConvert = new SoftFloat16_32FPConvert(SoftFloat16_32.FPConvert);
+            var dlgSoftFloat16_64FPConvert = new SoftFloat16_64FPConvert(SoftFloat16_64.FPConvert);
 
-            SetDelegateInfo(new SoftFloat32FPAdd(SoftFloat32.FPAdd));
-            SetDelegateInfo(new SoftFloat32FPAddFpscr(SoftFloat32.FPAddFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPCompare(SoftFloat32.FPCompare));
-            SetDelegateInfo(new SoftFloat32FPCompareEQ(SoftFloat32.FPCompareEQ));
-            SetDelegateInfo(new SoftFloat32FPCompareEQFpscr(SoftFloat32.FPCompareEQFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPCompareGE(SoftFloat32.FPCompareGE));
-            SetDelegateInfo(new SoftFloat32FPCompareGEFpscr(SoftFloat32.FPCompareGEFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPCompareGT(SoftFloat32.FPCompareGT));
-            SetDelegateInfo(new SoftFloat32FPCompareGTFpscr(SoftFloat32.FPCompareGTFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPCompareLE(SoftFloat32.FPCompareLE));
-            SetDelegateInfo(new SoftFloat32FPCompareLEFpscr(SoftFloat32.FPCompareLEFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPCompareLT(SoftFloat32.FPCompareLT));
-            SetDelegateInfo(new SoftFloat32FPCompareLTFpscr(SoftFloat32.FPCompareLTFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPDiv(SoftFloat32.FPDiv));
-            SetDelegateInfo(new SoftFloat32FPMax(SoftFloat32.FPMax));
-            SetDelegateInfo(new SoftFloat32FPMaxFpscr(SoftFloat32.FPMaxFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMaxNum(SoftFloat32.FPMaxNum));
-            SetDelegateInfo(new SoftFloat32FPMaxNumFpscr(SoftFloat32.FPMaxNumFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMin(SoftFloat32.FPMin));
-            SetDelegateInfo(new SoftFloat32FPMinFpscr(SoftFloat32.FPMinFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMinNum(SoftFloat32.FPMinNum));
-            SetDelegateInfo(new SoftFloat32FPMinNumFpscr(SoftFloat32.FPMinNumFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMul(SoftFloat32.FPMul));
-            SetDelegateInfo(new SoftFloat32FPMulFpscr(SoftFloat32.FPMulFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMulAdd(SoftFloat32.FPMulAdd));
-            SetDelegateInfo(new SoftFloat32FPMulAddFpscr(SoftFloat32.FPMulAddFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMulSub(SoftFloat32.FPMulSub));
-            SetDelegateInfo(new SoftFloat32FPMulSubFpscr(SoftFloat32.FPMulSubFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPMulX(SoftFloat32.FPMulX));
-            SetDelegateInfo(new SoftFloat32FPNegMulAdd(SoftFloat32.FPNegMulAdd));
-            SetDelegateInfo(new SoftFloat32FPNegMulSub(SoftFloat32.FPNegMulSub));
-            SetDelegateInfo(new SoftFloat32FPRecipEstimate(SoftFloat32.FPRecipEstimate));
-            SetDelegateInfo(new SoftFloat32FPRecipEstimateFpscr(SoftFloat32.FPRecipEstimateFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPRecipStep(SoftFloat32.FPRecipStep)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPRecipStepFused(SoftFloat32.FPRecipStepFused));
-            SetDelegateInfo(new SoftFloat32FPRecpX(SoftFloat32.FPRecpX));
-            SetDelegateInfo(new SoftFloat32FPRSqrtEstimate(SoftFloat32.FPRSqrtEstimate));
-            SetDelegateInfo(new SoftFloat32FPRSqrtEstimateFpscr(SoftFloat32.FPRSqrtEstimateFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPRSqrtStep(SoftFloat32.FPRSqrtStep)); // A32 only.
-            SetDelegateInfo(new SoftFloat32FPRSqrtStepFused(SoftFloat32.FPRSqrtStepFused));
-            SetDelegateInfo(new SoftFloat32FPSqrt(SoftFloat32.FPSqrt));
-            SetDelegateInfo(new SoftFloat32FPSub(SoftFloat32.FPSub));
+            var dlgSoftFloat32FPAdd = new SoftFloat32FPAdd(SoftFloat32.FPAdd);
+            var dlgSoftFloat32FPAddFpscr = new SoftFloat32FPAddFpscr(SoftFloat32.FPAddFpscr); // A32 only.
+            var dlgSoftFloat32FPCompare = new SoftFloat32FPCompare(SoftFloat32.FPCompare);
+            var dlgSoftFloat32FPCompareEQ = new SoftFloat32FPCompareEQ(SoftFloat32.FPCompareEQ);
+            var dlgSoftFloat32FPCompareEQFpscr = new SoftFloat32FPCompareEQFpscr(SoftFloat32.FPCompareEQFpscr); // A32 only.
+            var dlgSoftFloat32FPCompareGE = new SoftFloat32FPCompareGE(SoftFloat32.FPCompareGE);
+            var dlgSoftFloat32FPCompareGEFpscr = new SoftFloat32FPCompareGEFpscr(SoftFloat32.FPCompareGEFpscr); // A32 only.
+            var dlgSoftFloat32FPCompareGT = new SoftFloat32FPCompareGT(SoftFloat32.FPCompareGT);
+            var dlgSoftFloat32FPCompareGTFpscr = new SoftFloat32FPCompareGTFpscr(SoftFloat32.FPCompareGTFpscr); // A32 only.
+            var dlgSoftFloat32FPCompareLE = new SoftFloat32FPCompareLE(SoftFloat32.FPCompareLE);
+            var dlgSoftFloat32FPCompareLEFpscr = new SoftFloat32FPCompareLEFpscr(SoftFloat32.FPCompareLEFpscr); // A32 only.
+            var dlgSoftFloat32FPCompareLT = new SoftFloat32FPCompareLT(SoftFloat32.FPCompareLT);
+            var dlgSoftFloat32FPCompareLTFpscr = new SoftFloat32FPCompareLTFpscr(SoftFloat32.FPCompareLTFpscr); // A32 only.
+            var dlgSoftFloat32FPDiv = new SoftFloat32FPDiv(SoftFloat32.FPDiv);
+            var dlgSoftFloat32FPMax = new SoftFloat32FPMax(SoftFloat32.FPMax);
+            var dlgSoftFloat32FPMaxFpscr = new SoftFloat32FPMaxFpscr(SoftFloat32.FPMaxFpscr); // A32 only.
+            var dlgSoftFloat32FPMaxNum = new SoftFloat32FPMaxNum(SoftFloat32.FPMaxNum);
+            var dlgSoftFloat32FPMaxNumFpscr = new SoftFloat32FPMaxNumFpscr(SoftFloat32.FPMaxNumFpscr); // A32 only.
+            var dlgSoftFloat32FPMin = new SoftFloat32FPMin(SoftFloat32.FPMin);
+            var dlgSoftFloat32FPMinFpscr = new SoftFloat32FPMinFpscr(SoftFloat32.FPMinFpscr); // A32 only.
+            var dlgSoftFloat32FPMinNum = new SoftFloat32FPMinNum(SoftFloat32.FPMinNum);
+            var dlgSoftFloat32FPMinNumFpscr = new SoftFloat32FPMinNumFpscr(SoftFloat32.FPMinNumFpscr); // A32 only.
+            var dlgSoftFloat32FPMul = new SoftFloat32FPMul(SoftFloat32.FPMul);
+            var dlgSoftFloat32FPMulFpscr = new SoftFloat32FPMulFpscr(SoftFloat32.FPMulFpscr); // A32 only.
+            var dlgSoftFloat32FPMulAdd = new SoftFloat32FPMulAdd(SoftFloat32.FPMulAdd);
+            var dlgSoftFloat32FPMulAddFpscr = new SoftFloat32FPMulAddFpscr(SoftFloat32.FPMulAddFpscr); // A32 only.
+            var dlgSoftFloat32FPMulSub = new SoftFloat32FPMulSub(SoftFloat32.FPMulSub);
+            var dlgSoftFloat32FPMulSubFpscr = new SoftFloat32FPMulSubFpscr(SoftFloat32.FPMulSubFpscr); // A32 only.
+            var dlgSoftFloat32FPMulX = new SoftFloat32FPMulX(SoftFloat32.FPMulX);
+            var dlgSoftFloat32FPNegMulAdd = new SoftFloat32FPNegMulAdd(SoftFloat32.FPNegMulAdd);
+            var dlgSoftFloat32FPNegMulSub = new SoftFloat32FPNegMulSub(SoftFloat32.FPNegMulSub);
+            var dlgSoftFloat32FPRecipEstimate = new SoftFloat32FPRecipEstimate(SoftFloat32.FPRecipEstimate);
+            var dlgSoftFloat32FPRecipEstimateFpscr = new SoftFloat32FPRecipEstimateFpscr(SoftFloat32.FPRecipEstimateFpscr); // A32 only.
+            var dlgSoftFloat32FPRecipStep = new SoftFloat32FPRecipStep(SoftFloat32.FPRecipStep); // A32 only.
+            var dlgSoftFloat32FPRecipStepFused = new SoftFloat32FPRecipStepFused(SoftFloat32.FPRecipStepFused);
+            var dlgSoftFloat32FPRecpX = new SoftFloat32FPRecpX(SoftFloat32.FPRecpX);
+            var dlgSoftFloat32FPRSqrtEstimate = new SoftFloat32FPRSqrtEstimate(SoftFloat32.FPRSqrtEstimate);
+            var dlgSoftFloat32FPRSqrtEstimateFpscr = new SoftFloat32FPRSqrtEstimateFpscr(SoftFloat32.FPRSqrtEstimateFpscr); // A32 only.
+            var dlgSoftFloat32FPRSqrtStep = new SoftFloat32FPRSqrtStep(SoftFloat32.FPRSqrtStep); // A32 only.
+            var dlgSoftFloat32FPRSqrtStepFused = new SoftFloat32FPRSqrtStepFused(SoftFloat32.FPRSqrtStepFused);
+            var dlgSoftFloat32FPSqrt = new SoftFloat32FPSqrt(SoftFloat32.FPSqrt);
+            var dlgSoftFloat32FPSub = new SoftFloat32FPSub(SoftFloat32.FPSub);
 
-            SetDelegateInfo(new SoftFloat32_16FPConvert(SoftFloat32_16.FPConvert));
+            var dlgSoftFloat32_16FPConvert = new SoftFloat32_16FPConvert(SoftFloat32_16.FPConvert);
 
-            SetDelegateInfo(new SoftFloat64FPAdd(SoftFloat64.FPAdd));
-            SetDelegateInfo(new SoftFloat64FPAddFpscr(SoftFloat64.FPAddFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPCompare(SoftFloat64.FPCompare));
-            SetDelegateInfo(new SoftFloat64FPCompareEQ(SoftFloat64.FPCompareEQ));
-            SetDelegateInfo(new SoftFloat64FPCompareEQFpscr(SoftFloat64.FPCompareEQFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPCompareGE(SoftFloat64.FPCompareGE));
-            SetDelegateInfo(new SoftFloat64FPCompareGEFpscr(SoftFloat64.FPCompareGEFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPCompareGT(SoftFloat64.FPCompareGT));
-            SetDelegateInfo(new SoftFloat64FPCompareGTFpscr(SoftFloat64.FPCompareGTFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPCompareLE(SoftFloat64.FPCompareLE));
-            SetDelegateInfo(new SoftFloat64FPCompareLEFpscr(SoftFloat64.FPCompareLEFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPCompareLT(SoftFloat64.FPCompareLT));
-            SetDelegateInfo(new SoftFloat64FPCompareLTFpscr(SoftFloat64.FPCompareLTFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPDiv(SoftFloat64.FPDiv));
-            SetDelegateInfo(new SoftFloat64FPMax(SoftFloat64.FPMax));
-            SetDelegateInfo(new SoftFloat64FPMaxFpscr(SoftFloat64.FPMaxFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMaxNum(SoftFloat64.FPMaxNum));
-            SetDelegateInfo(new SoftFloat64FPMaxNumFpscr(SoftFloat64.FPMaxNumFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMin(SoftFloat64.FPMin));
-            SetDelegateInfo(new SoftFloat64FPMinFpscr(SoftFloat64.FPMinFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMinNum(SoftFloat64.FPMinNum));
-            SetDelegateInfo(new SoftFloat64FPMinNumFpscr(SoftFloat64.FPMinNumFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMul(SoftFloat64.FPMul));
-            SetDelegateInfo(new SoftFloat64FPMulFpscr(SoftFloat64.FPMulFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMulAdd(SoftFloat64.FPMulAdd));
-            SetDelegateInfo(new SoftFloat64FPMulAddFpscr(SoftFloat64.FPMulAddFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMulSub(SoftFloat64.FPMulSub));
-            SetDelegateInfo(new SoftFloat64FPMulSubFpscr(SoftFloat64.FPMulSubFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPMulX(SoftFloat64.FPMulX));
-            SetDelegateInfo(new SoftFloat64FPNegMulAdd(SoftFloat64.FPNegMulAdd));
-            SetDelegateInfo(new SoftFloat64FPNegMulSub(SoftFloat64.FPNegMulSub));
-            SetDelegateInfo(new SoftFloat64FPRecipEstimate(SoftFloat64.FPRecipEstimate));
-            SetDelegateInfo(new SoftFloat64FPRecipEstimateFpscr(SoftFloat64.FPRecipEstimateFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPRecipStep(SoftFloat64.FPRecipStep)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPRecipStepFused(SoftFloat64.FPRecipStepFused));
-            SetDelegateInfo(new SoftFloat64FPRecpX(SoftFloat64.FPRecpX));
-            SetDelegateInfo(new SoftFloat64FPRSqrtEstimate(SoftFloat64.FPRSqrtEstimate));
-            SetDelegateInfo(new SoftFloat64FPRSqrtEstimateFpscr(SoftFloat64.FPRSqrtEstimateFpscr)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPRSqrtStep(SoftFloat64.FPRSqrtStep)); // A32 only.
-            SetDelegateInfo(new SoftFloat64FPRSqrtStepFused(SoftFloat64.FPRSqrtStepFused));
-            SetDelegateInfo(new SoftFloat64FPSqrt(SoftFloat64.FPSqrt));
-            SetDelegateInfo(new SoftFloat64FPSub(SoftFloat64.FPSub));
+            var dlgSoftFloat64FPAdd = new SoftFloat64FPAdd(SoftFloat64.FPAdd);
+            var dlgSoftFloat64FPAddFpscr = new SoftFloat64FPAddFpscr(SoftFloat64.FPAddFpscr); // A32 only.
+            var dlgSoftFloat64FPCompare = new SoftFloat64FPCompare(SoftFloat64.FPCompare);
+            var dlgSoftFloat64FPCompareEQ = new SoftFloat64FPCompareEQ(SoftFloat64.FPCompareEQ);
+            var dlgSoftFloat64FPCompareEQFpscr = new SoftFloat64FPCompareEQFpscr(SoftFloat64.FPCompareEQFpscr); // A32 only.
+            var dlgSoftFloat64FPCompareGE = new SoftFloat64FPCompareGE(SoftFloat64.FPCompareGE);
+            var dlgSoftFloat64FPCompareGEFpscr = new SoftFloat64FPCompareGEFpscr(SoftFloat64.FPCompareGEFpscr); // A32 only.
+            var dlgSoftFloat64FPCompareGT = new SoftFloat64FPCompareGT(SoftFloat64.FPCompareGT);
+            var dlgSoftFloat64FPCompareGTFpscr = new SoftFloat64FPCompareGTFpscr(SoftFloat64.FPCompareGTFpscr); // A32 only.
+            var dlgSoftFloat64FPCompareLE = new SoftFloat64FPCompareLE(SoftFloat64.FPCompareLE);
+            var dlgSoftFloat64FPCompareLEFpscr = new SoftFloat64FPCompareLEFpscr(SoftFloat64.FPCompareLEFpscr); // A32 only.
+            var dlgSoftFloat64FPCompareLT = new SoftFloat64FPCompareLT(SoftFloat64.FPCompareLT);
+            var dlgSoftFloat64FPCompareLTFpscr = new SoftFloat64FPCompareLTFpscr(SoftFloat64.FPCompareLTFpscr); // A32 only.
+            var dlgSoftFloat64FPDiv = new SoftFloat64FPDiv(SoftFloat64.FPDiv);
+            var dlgSoftFloat64FPMax = new SoftFloat64FPMax(SoftFloat64.FPMax);
+            var dlgSoftFloat64FPMaxFpscr = new SoftFloat64FPMaxFpscr(SoftFloat64.FPMaxFpscr); // A32 only.
+            var dlgSoftFloat64FPMaxNum = new SoftFloat64FPMaxNum(SoftFloat64.FPMaxNum);
+            var dlgSoftFloat64FPMaxNumFpscr = new SoftFloat64FPMaxNumFpscr(SoftFloat64.FPMaxNumFpscr); // A32 only.
+            var dlgSoftFloat64FPMin = new SoftFloat64FPMin(SoftFloat64.FPMin);
+            var dlgSoftFloat64FPMinFpscr = new SoftFloat64FPMinFpscr(SoftFloat64.FPMinFpscr); // A32 only.
+            var dlgSoftFloat64FPMinNum = new SoftFloat64FPMinNum(SoftFloat64.FPMinNum);
+            var dlgSoftFloat64FPMinNumFpscr = new SoftFloat64FPMinNumFpscr(SoftFloat64.FPMinNumFpscr); // A32 only.
+            var dlgSoftFloat64FPMul = new SoftFloat64FPMul(SoftFloat64.FPMul);
+            var dlgSoftFloat64FPMulFpscr = new SoftFloat64FPMulFpscr(SoftFloat64.FPMulFpscr); // A32 only.
+            var dlgSoftFloat64FPMulAdd = new SoftFloat64FPMulAdd(SoftFloat64.FPMulAdd);
+            var dlgSoftFloat64FPMulAddFpscr = new SoftFloat64FPMulAddFpscr(SoftFloat64.FPMulAddFpscr); // A32 only.
+            var dlgSoftFloat64FPMulSub = new SoftFloat64FPMulSub(SoftFloat64.FPMulSub);
+            var dlgSoftFloat64FPMulSubFpscr = new SoftFloat64FPMulSubFpscr(SoftFloat64.FPMulSubFpscr); // A32 only.
+            var dlgSoftFloat64FPMulX = new SoftFloat64FPMulX(SoftFloat64.FPMulX);
+            var dlgSoftFloat64FPNegMulAdd = new SoftFloat64FPNegMulAdd(SoftFloat64.FPNegMulAdd);
+            var dlgSoftFloat64FPNegMulSub = new SoftFloat64FPNegMulSub(SoftFloat64.FPNegMulSub);
+            var dlgSoftFloat64FPRecipEstimate = new SoftFloat64FPRecipEstimate(SoftFloat64.FPRecipEstimate);
+            var dlgSoftFloat64FPRecipEstimateFpscr = new SoftFloat64FPRecipEstimateFpscr(SoftFloat64.FPRecipEstimateFpscr); // A32 only.
+            var dlgSoftFloat64FPRecipStep = new SoftFloat64FPRecipStep(SoftFloat64.FPRecipStep); // A32 only.
+            var dlgSoftFloat64FPRecipStepFused = new SoftFloat64FPRecipStepFused(SoftFloat64.FPRecipStepFused);
+            var dlgSoftFloat64FPRecpX = new SoftFloat64FPRecpX(SoftFloat64.FPRecpX);
+            var dlgSoftFloat64FPRSqrtEstimate = new SoftFloat64FPRSqrtEstimate(SoftFloat64.FPRSqrtEstimate);
+            var dlgSoftFloat64FPRSqrtEstimateFpscr = new SoftFloat64FPRSqrtEstimateFpscr(SoftFloat64.FPRSqrtEstimateFpscr); // A32 only.
+            var dlgSoftFloat64FPRSqrtStep = new SoftFloat64FPRSqrtStep(SoftFloat64.FPRSqrtStep); // A32 only.
+            var dlgSoftFloat64FPRSqrtStepFused = new SoftFloat64FPRSqrtStepFused(SoftFloat64.FPRSqrtStepFused);
+            var dlgSoftFloat64FPSqrt = new SoftFloat64FPSqrt(SoftFloat64.FPSqrt);
+            var dlgSoftFloat64FPSub = new SoftFloat64FPSub(SoftFloat64.FPSub);
 
-            SetDelegateInfo(new SoftFloat64_16FPConvert(SoftFloat64_16.FPConvert));
+            var dlgSoftFloat64_16FPConvert = new SoftFloat64_16FPConvert(SoftFloat64_16.FPConvert);
+
+            SetDelegateInfo(dlgMathAbs, Marshal.GetFunctionPointerForDelegate<MathAbs>(dlgMathAbs));
+            SetDelegateInfo(dlgMathCeiling, Marshal.GetFunctionPointerForDelegate<MathCeiling>(dlgMathCeiling));
+            SetDelegateInfo(dlgMathFloor, Marshal.GetFunctionPointerForDelegate<MathFloor>(dlgMathFloor));
+            SetDelegateInfo(dlgMathRound, Marshal.GetFunctionPointerForDelegate<MathRound>(dlgMathRound));
+            SetDelegateInfo(dlgMathTruncate, Marshal.GetFunctionPointerForDelegate<MathTruncate>(dlgMathTruncate));
+
+            SetDelegateInfo(dlgMathFAbs, Marshal.GetFunctionPointerForDelegate<MathFAbs>(dlgMathFAbs));
+            SetDelegateInfo(dlgMathFCeiling, Marshal.GetFunctionPointerForDelegate<MathFCeiling>(dlgMathFCeiling));
+            SetDelegateInfo(dlgMathFFloor, Marshal.GetFunctionPointerForDelegate<MathFFloor>(dlgMathFFloor));
+            SetDelegateInfo(dlgMathFRound, Marshal.GetFunctionPointerForDelegate<MathFRound>(dlgMathFRound));
+            SetDelegateInfo(dlgMathFTruncate, Marshal.GetFunctionPointerForDelegate<MathFTruncate>(dlgMathFTruncate));
+
+            SetDelegateInfo(dlgNativeInterfaceBreak, Marshal.GetFunctionPointerForDelegate<NativeInterfaceBreak>(dlgNativeInterfaceBreak));
+            SetDelegateInfo(dlgNativeInterfaceCheckSynchronization, Marshal.GetFunctionPointerForDelegate<NativeInterfaceCheckSynchronization>(dlgNativeInterfaceCheckSynchronization));
+            SetDelegateInfo(dlgNativeInterfaceEnqueueForRejit, Marshal.GetFunctionPointerForDelegate<NativeInterfaceEnqueueForRejit>(dlgNativeInterfaceEnqueueForRejit));
+            SetDelegateInfo(dlgNativeInterfaceGetCntfrqEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntfrqEl0>(dlgNativeInterfaceGetCntfrqEl0));
+            SetDelegateInfo(dlgNativeInterfaceGetCntpctEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntpctEl0>(dlgNativeInterfaceGetCntpctEl0));
+            SetDelegateInfo(dlgNativeInterfaceGetCntvctEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCntvctEl0>(dlgNativeInterfaceGetCntvctEl0));
+            SetDelegateInfo(dlgNativeInterfaceGetCtrEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetCtrEl0>(dlgNativeInterfaceGetCtrEl0));
+            SetDelegateInfo(dlgNativeInterfaceGetDczidEl0, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetDczidEl0>(dlgNativeInterfaceGetDczidEl0));
+            SetDelegateInfo(dlgNativeInterfaceGetFunctionAddress, Marshal.GetFunctionPointerForDelegate<NativeInterfaceGetFunctionAddress>(dlgNativeInterfaceGetFunctionAddress));
+            SetDelegateInfo(dlgNativeInterfaceInvalidateCacheLine, Marshal.GetFunctionPointerForDelegate<NativeInterfaceInvalidateCacheLine>(dlgNativeInterfaceInvalidateCacheLine));
+            SetDelegateInfo(dlgNativeInterfaceReadByte, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadByte>(dlgNativeInterfaceReadByte));
+            SetDelegateInfo(dlgNativeInterfaceReadUInt16, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt16>(dlgNativeInterfaceReadUInt16));
+            SetDelegateInfo(dlgNativeInterfaceReadUInt32, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt32>(dlgNativeInterfaceReadUInt32));
+            SetDelegateInfo(dlgNativeInterfaceReadUInt64, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadUInt64>(dlgNativeInterfaceReadUInt64));
+            SetDelegateInfo(dlgNativeInterfaceReadVector128, Marshal.GetFunctionPointerForDelegate<NativeInterfaceReadVector128>(dlgNativeInterfaceReadVector128));
+            SetDelegateInfo(dlgNativeInterfaceSignalMemoryTracking, Marshal.GetFunctionPointerForDelegate<NativeInterfaceSignalMemoryTracking>(dlgNativeInterfaceSignalMemoryTracking));
+            SetDelegateInfo(dlgNativeInterfaceSupervisorCall, Marshal.GetFunctionPointerForDelegate<NativeInterfaceSupervisorCall>(dlgNativeInterfaceSupervisorCall));
+            SetDelegateInfo(dlgNativeInterfaceThrowInvalidMemoryAccess, Marshal.GetFunctionPointerForDelegate<NativeInterfaceThrowInvalidMemoryAccess>(dlgNativeInterfaceThrowInvalidMemoryAccess));
+            SetDelegateInfo(dlgNativeInterfaceUndefined, Marshal.GetFunctionPointerForDelegate<NativeInterfaceUndefined>(dlgNativeInterfaceUndefined));
+            SetDelegateInfo(dlgNativeInterfaceWriteByte, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteByte>(dlgNativeInterfaceWriteByte));
+            SetDelegateInfo(dlgNativeInterfaceWriteUInt16, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt16>(dlgNativeInterfaceWriteUInt16));
+            SetDelegateInfo(dlgNativeInterfaceWriteUInt32, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt32>(dlgNativeInterfaceWriteUInt32));
+            SetDelegateInfo(dlgNativeInterfaceWriteUInt64, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteUInt64>(dlgNativeInterfaceWriteUInt64));
+            SetDelegateInfo(dlgNativeInterfaceWriteVector128, Marshal.GetFunctionPointerForDelegate<NativeInterfaceWriteVector128>(dlgNativeInterfaceWriteVector128));
+
+            SetDelegateInfo(dlgSoftFallbackCountLeadingSigns, Marshal.GetFunctionPointerForDelegate<SoftFallbackCountLeadingSigns>(dlgSoftFallbackCountLeadingSigns));
+            SetDelegateInfo(dlgSoftFallbackCountLeadingZeros, Marshal.GetFunctionPointerForDelegate<SoftFallbackCountLeadingZeros>(dlgSoftFallbackCountLeadingZeros));
+            SetDelegateInfo(dlgSoftFallbackCrc32b, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32b>(dlgSoftFallbackCrc32b));
+            SetDelegateInfo(dlgSoftFallbackCrc32cb, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cb>(dlgSoftFallbackCrc32cb));
+            SetDelegateInfo(dlgSoftFallbackCrc32ch, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32ch>(dlgSoftFallbackCrc32ch));
+            SetDelegateInfo(dlgSoftFallbackCrc32cw, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cw>(dlgSoftFallbackCrc32cw));
+            SetDelegateInfo(dlgSoftFallbackCrc32cx, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32cx>(dlgSoftFallbackCrc32cx));
+            SetDelegateInfo(dlgSoftFallbackCrc32h, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32h>(dlgSoftFallbackCrc32h));
+            SetDelegateInfo(dlgSoftFallbackCrc32w, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32w>(dlgSoftFallbackCrc32w));
+            SetDelegateInfo(dlgSoftFallbackCrc32x, Marshal.GetFunctionPointerForDelegate<SoftFallbackCrc32x>(dlgSoftFallbackCrc32x));
+            SetDelegateInfo(dlgSoftFallbackDecrypt, Marshal.GetFunctionPointerForDelegate<SoftFallbackDecrypt>(dlgSoftFallbackDecrypt));
+            SetDelegateInfo(dlgSoftFallbackEncrypt, Marshal.GetFunctionPointerForDelegate<SoftFallbackEncrypt>(dlgSoftFallbackEncrypt));
+            SetDelegateInfo(dlgSoftFallbackFixedRotate, Marshal.GetFunctionPointerForDelegate<SoftFallbackFixedRotate>(dlgSoftFallbackFixedRotate));
+            SetDelegateInfo(dlgSoftFallbackHashChoose, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashChoose>(dlgSoftFallbackHashChoose));
+            SetDelegateInfo(dlgSoftFallbackHashLower, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashLower>(dlgSoftFallbackHashLower));
+            SetDelegateInfo(dlgSoftFallbackHashMajority, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashMajority>(dlgSoftFallbackHashMajority));
+            SetDelegateInfo(dlgSoftFallbackHashParity, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashParity>(dlgSoftFallbackHashParity));
+            SetDelegateInfo(dlgSoftFallbackHashUpper, Marshal.GetFunctionPointerForDelegate<SoftFallbackHashUpper>(dlgSoftFallbackHashUpper));
+            SetDelegateInfo(dlgSoftFallbackInverseMixColumns, Marshal.GetFunctionPointerForDelegate<SoftFallbackInverseMixColumns>(dlgSoftFallbackInverseMixColumns));
+            SetDelegateInfo(dlgSoftFallbackMixColumns, Marshal.GetFunctionPointerForDelegate<SoftFallbackMixColumns>(dlgSoftFallbackMixColumns));
+            SetDelegateInfo(dlgSoftFallbackPolynomialMult64_128, Marshal.GetFunctionPointerForDelegate<SoftFallbackPolynomialMult64_128>(dlgSoftFallbackPolynomialMult64_128));
+            SetDelegateInfo(dlgSoftFallbackSatF32ToS32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToS32>(dlgSoftFallbackSatF32ToS32));
+            SetDelegateInfo(dlgSoftFallbackSatF32ToS64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToS64>(dlgSoftFallbackSatF32ToS64));
+            SetDelegateInfo(dlgSoftFallbackSatF32ToU32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToU32>(dlgSoftFallbackSatF32ToU32));
+            SetDelegateInfo(dlgSoftFallbackSatF32ToU64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF32ToU64>(dlgSoftFallbackSatF32ToU64));
+            SetDelegateInfo(dlgSoftFallbackSatF64ToS32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToS32>(dlgSoftFallbackSatF64ToS32));
+            SetDelegateInfo(dlgSoftFallbackSatF64ToS64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToS64>(dlgSoftFallbackSatF64ToS64));
+            SetDelegateInfo(dlgSoftFallbackSatF64ToU32, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToU32>(dlgSoftFallbackSatF64ToU32));
+            SetDelegateInfo(dlgSoftFallbackSatF64ToU64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSatF64ToU64>(dlgSoftFallbackSatF64ToU64));
+            SetDelegateInfo(dlgSoftFallbackSha1SchedulePart1, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha1SchedulePart1>(dlgSoftFallbackSha1SchedulePart1));
+            SetDelegateInfo(dlgSoftFallbackSha1SchedulePart2, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha1SchedulePart2>(dlgSoftFallbackSha1SchedulePart2));
+            SetDelegateInfo(dlgSoftFallbackSha256SchedulePart1, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha256SchedulePart1>(dlgSoftFallbackSha256SchedulePart1));
+            SetDelegateInfo(dlgSoftFallbackSha256SchedulePart2, Marshal.GetFunctionPointerForDelegate<SoftFallbackSha256SchedulePart2>(dlgSoftFallbackSha256SchedulePart2));
+            SetDelegateInfo(dlgSoftFallbackSignedShrImm64, Marshal.GetFunctionPointerForDelegate<SoftFallbackSignedShrImm64>(dlgSoftFallbackSignedShrImm64));
+            SetDelegateInfo(dlgSoftFallbackTbl1, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl1>(dlgSoftFallbackTbl1));
+            SetDelegateInfo(dlgSoftFallbackTbl2, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl2>(dlgSoftFallbackTbl2));
+            SetDelegateInfo(dlgSoftFallbackTbl3, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl3>(dlgSoftFallbackTbl3));
+            SetDelegateInfo(dlgSoftFallbackTbl4, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbl4>(dlgSoftFallbackTbl4));
+            SetDelegateInfo(dlgSoftFallbackTbx1, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx1>(dlgSoftFallbackTbx1));
+            SetDelegateInfo(dlgSoftFallbackTbx2, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx2>(dlgSoftFallbackTbx2));
+            SetDelegateInfo(dlgSoftFallbackTbx3, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx3>(dlgSoftFallbackTbx3));
+            SetDelegateInfo(dlgSoftFallbackTbx4, Marshal.GetFunctionPointerForDelegate<SoftFallbackTbx4>(dlgSoftFallbackTbx4));
+            SetDelegateInfo(dlgSoftFallbackUnsignedShrImm64, Marshal.GetFunctionPointerForDelegate<SoftFallbackUnsignedShrImm64>(dlgSoftFallbackUnsignedShrImm64));
+
+            SetDelegateInfo(dlgSoftFloat16_32FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat16_32FPConvert>(dlgSoftFloat16_32FPConvert));
+            SetDelegateInfo(dlgSoftFloat16_64FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat16_64FPConvert>(dlgSoftFloat16_64FPConvert));
+
+            SetDelegateInfo(dlgSoftFloat32FPAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPAdd>(dlgSoftFloat32FPAdd));
+            SetDelegateInfo(dlgSoftFloat32FPAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPAddFpscr>(dlgSoftFloat32FPAddFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPCompare, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompare>(dlgSoftFloat32FPCompare));
+            SetDelegateInfo(dlgSoftFloat32FPCompareEQ, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareEQ>(dlgSoftFloat32FPCompareEQ));
+            SetDelegateInfo(dlgSoftFloat32FPCompareEQFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareEQFpscr>(dlgSoftFloat32FPCompareEQFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPCompareGE, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGE>(dlgSoftFloat32FPCompareGE));
+            SetDelegateInfo(dlgSoftFloat32FPCompareGEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGEFpscr>(dlgSoftFloat32FPCompareGEFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPCompareGT, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGT>(dlgSoftFloat32FPCompareGT));
+            SetDelegateInfo(dlgSoftFloat32FPCompareGTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareGTFpscr>(dlgSoftFloat32FPCompareGTFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPCompareLE, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLE>(dlgSoftFloat32FPCompareLE));
+            SetDelegateInfo(dlgSoftFloat32FPCompareLEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLEFpscr>(dlgSoftFloat32FPCompareLEFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPCompareLT, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLT>(dlgSoftFloat32FPCompareLT));
+            SetDelegateInfo(dlgSoftFloat32FPCompareLTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPCompareLTFpscr>(dlgSoftFloat32FPCompareLTFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPDiv, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPDiv>(dlgSoftFloat32FPDiv));
+            SetDelegateInfo(dlgSoftFloat32FPMax, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMax>(dlgSoftFloat32FPMax));
+            SetDelegateInfo(dlgSoftFloat32FPMaxFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxFpscr>(dlgSoftFloat32FPMaxFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMaxNum, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxNum>(dlgSoftFloat32FPMaxNum));
+            SetDelegateInfo(dlgSoftFloat32FPMaxNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMaxNumFpscr>(dlgSoftFloat32FPMaxNumFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMin, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMin>(dlgSoftFloat32FPMin));
+            SetDelegateInfo(dlgSoftFloat32FPMinFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinFpscr>(dlgSoftFloat32FPMinFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMinNum, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinNum>(dlgSoftFloat32FPMinNum));
+            SetDelegateInfo(dlgSoftFloat32FPMinNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMinNumFpscr>(dlgSoftFloat32FPMinNumFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMul, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMul>(dlgSoftFloat32FPMul));
+            SetDelegateInfo(dlgSoftFloat32FPMulFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulFpscr>(dlgSoftFloat32FPMulFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulAdd>(dlgSoftFloat32FPMulAdd));
+            SetDelegateInfo(dlgSoftFloat32FPMulAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulAddFpscr>(dlgSoftFloat32FPMulAddFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulSub>(dlgSoftFloat32FPMulSub));
+            SetDelegateInfo(dlgSoftFloat32FPMulSubFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulSubFpscr>(dlgSoftFloat32FPMulSubFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPMulX, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPMulX>(dlgSoftFloat32FPMulX));
+            SetDelegateInfo(dlgSoftFloat32FPNegMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPNegMulAdd>(dlgSoftFloat32FPNegMulAdd));
+            SetDelegateInfo(dlgSoftFloat32FPNegMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPNegMulSub>(dlgSoftFloat32FPNegMulSub));
+            SetDelegateInfo(dlgSoftFloat32FPRecipEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipEstimate>(dlgSoftFloat32FPRecipEstimate));
+            SetDelegateInfo(dlgSoftFloat32FPRecipEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipEstimateFpscr>(dlgSoftFloat32FPRecipEstimateFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPRecipStep, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipStep>(dlgSoftFloat32FPRecipStep)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPRecipStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecipStepFused>(dlgSoftFloat32FPRecipStepFused));
+            SetDelegateInfo(dlgSoftFloat32FPRecpX, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRecpX>(dlgSoftFloat32FPRecpX));
+            SetDelegateInfo(dlgSoftFloat32FPRSqrtEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtEstimate>(dlgSoftFloat32FPRSqrtEstimate));
+            SetDelegateInfo(dlgSoftFloat32FPRSqrtEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtEstimateFpscr>(dlgSoftFloat32FPRSqrtEstimateFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPRSqrtStep, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtStep>(dlgSoftFloat32FPRSqrtStep)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat32FPRSqrtStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPRSqrtStepFused>(dlgSoftFloat32FPRSqrtStepFused));
+            SetDelegateInfo(dlgSoftFloat32FPSqrt, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPSqrt>(dlgSoftFloat32FPSqrt));
+            SetDelegateInfo(dlgSoftFloat32FPSub, Marshal.GetFunctionPointerForDelegate<SoftFloat32FPSub>(dlgSoftFloat32FPSub));
+
+            SetDelegateInfo(dlgSoftFloat32_16FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat32_16FPConvert>(dlgSoftFloat32_16FPConvert));
+
+            SetDelegateInfo(dlgSoftFloat64FPAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPAdd>(dlgSoftFloat64FPAdd));
+            SetDelegateInfo(dlgSoftFloat64FPAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPAddFpscr>(dlgSoftFloat64FPAddFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPCompare, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompare>(dlgSoftFloat64FPCompare));
+            SetDelegateInfo(dlgSoftFloat64FPCompareEQ, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareEQ>(dlgSoftFloat64FPCompareEQ));
+            SetDelegateInfo(dlgSoftFloat64FPCompareEQFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareEQFpscr>(dlgSoftFloat64FPCompareEQFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPCompareGE, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGE>(dlgSoftFloat64FPCompareGE));
+            SetDelegateInfo(dlgSoftFloat64FPCompareGEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGEFpscr>(dlgSoftFloat64FPCompareGEFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPCompareGT, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGT>(dlgSoftFloat64FPCompareGT));
+            SetDelegateInfo(dlgSoftFloat64FPCompareGTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareGTFpscr>(dlgSoftFloat64FPCompareGTFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPCompareLE, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLE>(dlgSoftFloat64FPCompareLE));
+            SetDelegateInfo(dlgSoftFloat64FPCompareLEFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLEFpscr>(dlgSoftFloat64FPCompareLEFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPCompareLT, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLT>(dlgSoftFloat64FPCompareLT));
+            SetDelegateInfo(dlgSoftFloat64FPCompareLTFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPCompareLTFpscr>(dlgSoftFloat64FPCompareLTFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPDiv, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPDiv>(dlgSoftFloat64FPDiv));
+            SetDelegateInfo(dlgSoftFloat64FPMax, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMax>(dlgSoftFloat64FPMax));
+            SetDelegateInfo(dlgSoftFloat64FPMaxFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxFpscr>(dlgSoftFloat64FPMaxFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMaxNum, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxNum>(dlgSoftFloat64FPMaxNum));
+            SetDelegateInfo(dlgSoftFloat64FPMaxNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMaxNumFpscr>(dlgSoftFloat64FPMaxNumFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMin, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMin>(dlgSoftFloat64FPMin));
+            SetDelegateInfo(dlgSoftFloat64FPMinFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinFpscr>(dlgSoftFloat64FPMinFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMinNum, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinNum>(dlgSoftFloat64FPMinNum));
+            SetDelegateInfo(dlgSoftFloat64FPMinNumFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMinNumFpscr>(dlgSoftFloat64FPMinNumFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMul, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMul>(dlgSoftFloat64FPMul));
+            SetDelegateInfo(dlgSoftFloat64FPMulFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulFpscr>(dlgSoftFloat64FPMulFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulAdd>(dlgSoftFloat64FPMulAdd));
+            SetDelegateInfo(dlgSoftFloat64FPMulAddFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulAddFpscr>(dlgSoftFloat64FPMulAddFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulSub>(dlgSoftFloat64FPMulSub));
+            SetDelegateInfo(dlgSoftFloat64FPMulSubFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulSubFpscr>(dlgSoftFloat64FPMulSubFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPMulX, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPMulX>(dlgSoftFloat64FPMulX));
+            SetDelegateInfo(dlgSoftFloat64FPNegMulAdd, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPNegMulAdd>(dlgSoftFloat64FPNegMulAdd));
+            SetDelegateInfo(dlgSoftFloat64FPNegMulSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPNegMulSub>(dlgSoftFloat64FPNegMulSub));
+            SetDelegateInfo(dlgSoftFloat64FPRecipEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipEstimate>(dlgSoftFloat64FPRecipEstimate));
+            SetDelegateInfo(dlgSoftFloat64FPRecipEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipEstimateFpscr>(dlgSoftFloat64FPRecipEstimateFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPRecipStep, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipStep>(dlgSoftFloat64FPRecipStep)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPRecipStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecipStepFused>(dlgSoftFloat64FPRecipStepFused));
+            SetDelegateInfo(dlgSoftFloat64FPRecpX, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRecpX>(dlgSoftFloat64FPRecpX));
+            SetDelegateInfo(dlgSoftFloat64FPRSqrtEstimate, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtEstimate>(dlgSoftFloat64FPRSqrtEstimate));
+            SetDelegateInfo(dlgSoftFloat64FPRSqrtEstimateFpscr, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtEstimateFpscr>(dlgSoftFloat64FPRSqrtEstimateFpscr)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPRSqrtStep, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtStep>(dlgSoftFloat64FPRSqrtStep)); // A32 only.
+            SetDelegateInfo(dlgSoftFloat64FPRSqrtStepFused, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPRSqrtStepFused>(dlgSoftFloat64FPRSqrtStepFused));
+            SetDelegateInfo(dlgSoftFloat64FPSqrt, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPSqrt>(dlgSoftFloat64FPSqrt));
+            SetDelegateInfo(dlgSoftFloat64FPSub, Marshal.GetFunctionPointerForDelegate<SoftFloat64FPSub>(dlgSoftFloat64FPSub));
+
+            SetDelegateInfo(dlgSoftFloat64_16FPConvert, Marshal.GetFunctionPointerForDelegate<SoftFloat64_16FPConvert>(dlgSoftFloat64_16FPConvert));
         }
 
         private delegate double MathAbs(double value);

src/ARMeilleure/Translation/PTC/Ptc.cs

@@ -29,7 +29,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 5518; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 6950; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";
@@ -857,8 +857,14 @@ namespace ARMeilleure.Translation.PTC
 
             Stopwatch sw = Stopwatch.StartNew();
 
-            threads.ForEach((thread) => thread.Start());
-            threads.ForEach((thread) => thread.Join());
+            foreach (var thread in threads)
+            {
+                thread.Start();
+            }
+            foreach (var thread in threads)
+            {
+                thread.Join();
+            }
 
             threads.Clear();
 

src/ARMeilleure/Translation/RegisterUsage.cs

@@ -89,6 +89,17 @@ namespace ARMeilleure.Translation
 
         public static void RunPass(ControlFlowGraph cfg, ExecutionMode mode)
         {
+            if (cfg.Entry.Predecessors.Count != 0)
+            {
+                // We expect the entry block to have no predecessors.
+                // This is required because we have a implicit context load at the start of the function,
+                // but if there is a jump to the start of the function, the context load would trash the modified values.
+                // Here we insert a new entry block that will jump to the existing entry block.
+                BasicBlock newEntry = new BasicBlock(cfg.Blocks.Count);
+
+                cfg.UpdateEntry(newEntry);
+            }
+
             // Compute local register inputs and outputs used inside blocks.
             RegisterMask[] localInputs = new RegisterMask[cfg.Blocks.Count];
             RegisterMask[] localOutputs = new RegisterMask[cfg.Blocks.Count];
@@ -201,7 +212,7 @@ namespace ARMeilleure.Translation
 
                 // The only block without any predecessor should be the entry block.
                 // It always needs a context load as it is the first block to run.
-                if (block.Predecessors.Count == 0 || hasContextLoad)
+                if (block == cfg.Entry || hasContextLoad)
                 {
                     long vecMask = globalInputs[block.Index].VecMask;
                     long intMask = globalInputs[block.Index].IntMask;

src/ARMeilleure/Translation/TranslatorQueue.cs

@@ -80,7 +80,10 @@ namespace ARMeilleure.Translation
                         return true;
                     }
 
-                    Monitor.Wait(Sync);
+                    if (!_disposed)
+                    {
+                        Monitor.Wait(Sync);
+                    }
                 }
             }
 

src/Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceSession.cs

@@ -1,8 +1,10 @@
 using Ryujinx.Audio.Backends.Common;
 using Ryujinx.Audio.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Threading;
 
@@ -87,7 +89,9 @@ namespace Ryujinx.Audio.Backends.SDL2
                 return;
             }
 
-            byte[] samples = new byte[frameCount * _bytesPerFrame];
+            using SpanOwner<byte> samplesOwner = SpanOwner<byte>.Rent(frameCount * _bytesPerFrame);
+
+            Span<byte> samples = samplesOwner.Span;
 
             _ringBuffer.Read(samples, 0, samples.Length);
 

src/Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceSession.cs

@@ -1,8 +1,10 @@
 using Ryujinx.Audio.Backends.Common;
 using Ryujinx.Audio.Backends.SoundIo.Native;
 using Ryujinx.Audio.Common;
+using Ryujinx.Common.Memory;
 using Ryujinx.Memory;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -37,7 +39,7 @@ namespace Ryujinx.Audio.Backends.SoundIo
             _outputStream = _driver.OpenStream(RequestedSampleFormat, RequestedSampleRate, RequestedChannelCount);
             _outputStream.WriteCallback += Update;
             _outputStream.Volume = requestedVolume;
-            // TODO: Setup other callbacks (errors, ect).
+            // TODO: Setup other callbacks (errors, etc.)
 
             _outputStream.Open();
         }
@@ -120,7 +122,9 @@ namespace Ryujinx.Audio.Backends.SoundIo
 
             int channelCount = areas.Length;
 
-            byte[] samples = new byte[frameCount * bytesPerFrame];
+            using SpanOwner<byte> samplesOwner = SpanOwner<byte>.Rent(frameCount * bytesPerFrame);
+
+            Span<byte> samples = samplesOwner.Span;
 
             _ringBuffer.Read(samples, 0, samples.Length);
 

src/Ryujinx.Audio/Backends/Common/DynamicRingBuffer.cs

@@ -1,5 +1,7 @@
 using Ryujinx.Common;
+using Ryujinx.Common.Memory;
 using System;
+using System.Buffers;
 
 namespace Ryujinx.Audio.Backends.Common
 {
@@ -12,7 +14,8 @@ namespace Ryujinx.Audio.Backends.Common
 
         private readonly object _lock = new();
 
-        private byte[] _buffer;
+        private MemoryOwner<byte> _bufferOwner;
+        private Memory<byte> _buffer;
         private int _size;
         private int _headOffset;
         private int _tailOffset;
@@ -21,7 +24,8 @@ namespace Ryujinx.Audio.Backends.Common
 
         public DynamicRingBuffer(int initialCapacity = RingBufferAlignment)
         {
-            _buffer = new byte[initialCapacity];
+            _bufferOwner = MemoryOwner<byte>.RentCleared(initialCapacity);
+            _buffer = _bufferOwner.Memory;
         }
 
         public void Clear()
@@ -33,6 +37,11 @@ namespace Ryujinx.Audio.Backends.Common
 
         public void Clear(int size)
         {
+            if (size == 0)
+            {
+                return;
+            }
+
             lock (_lock)
             {
                 if (size > _size)
@@ -40,11 +49,6 @@ namespace Ryujinx.Audio.Backends.Common
                     size = _size;
                 }
 
-                if (size == 0)
-                {
-                    return;
-                }
-
                 _headOffset = (_headOffset + size) % _buffer.Length;
                 _size -= size;
 
@@ -58,28 +62,31 @@ namespace Ryujinx.Audio.Backends.Common
 
         private void SetCapacityLocked(int capacity)
         {
-            byte[] buffer = new byte[capacity];
+            MemoryOwner<byte> newBufferOwner = MemoryOwner<byte>.RentCleared(capacity);
+            Memory<byte> newBuffer = newBufferOwner.Memory;
 
             if (_size > 0)
             {
                 if (_headOffset < _tailOffset)
                 {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, 0, _size);
+                    _buffer.Slice(_headOffset, _size).CopyTo(newBuffer);
                 }
                 else
                 {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, 0, _buffer.Length - _headOffset);
-                    Buffer.BlockCopy(_buffer, 0, buffer, _buffer.Length - _headOffset, _tailOffset);
+                    _buffer[_headOffset..].CopyTo(newBuffer);
+                    _buffer[.._tailOffset].CopyTo(newBuffer[(_buffer.Length - _headOffset)..]);
                 }
             }
 
-            _buffer = buffer;
+            _bufferOwner.Dispose();
+
+            _bufferOwner = newBufferOwner;
+            _buffer = newBuffer;
             _headOffset = 0;
             _tailOffset = _size;
         }
 
-
-        public void Write<T>(T[] buffer, int index, int count)
+        public void Write(ReadOnlySpan<byte> buffer, int index, int count)
         {
             if (count == 0)
             {
@@ -99,17 +106,17 @@ namespace Ryujinx.Audio.Backends.Common
 
                     if (tailLength >= count)
                     {
-                        Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, count);
+                        buffer.Slice(index, count).CopyTo(_buffer.Span[_tailOffset..]);
                     }
                     else
                     {
-                        Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, tailLength);
-                        Buffer.BlockCopy(buffer, index + tailLength, _buffer, 0, count - tailLength);
+                        buffer.Slice(index, tailLength).CopyTo(_buffer.Span[_tailOffset..]);
+                        buffer.Slice(index + tailLength, count - tailLength).CopyTo(_buffer.Span);
                     }
                 }
                 else
                 {
-                    Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, count);
+                    buffer.Slice(index, count).CopyTo(_buffer.Span[_tailOffset..]);
                 }
 
                 _size += count;
@@ -117,8 +124,13 @@ namespace Ryujinx.Audio.Backends.Common
             }
         }
 
-        public int Read<T>(T[] buffer, int index, int count)
+        public int Read(Span<byte> buffer, int index, int count)
         {
+            if (count == 0)
+            {
+                return 0;
+            }
+
             lock (_lock)
             {
                 if (count > _size)
@@ -126,14 +138,9 @@ namespace Ryujinx.Audio.Backends.Common
                     count = _size;
                 }
 
-                if (count == 0)
-                {
-                    return 0;
-                }
-
                 if (_headOffset < _tailOffset)
                 {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, index, count);
+                    _buffer.Span.Slice(_headOffset, count).CopyTo(buffer[index..]);
                 }
                 else
                 {
@@ -141,12 +148,12 @@ namespace Ryujinx.Audio.Backends.Common
 
                     if (tailLength >= count)
                     {
-                        Buffer.BlockCopy(_buffer, _headOffset, buffer, index, count);
+                        _buffer.Span.Slice(_headOffset, count).CopyTo(buffer[index..]);
                     }
                     else
                     {
-                        Buffer.BlockCopy(_buffer, _headOffset, buffer, index, tailLength);
-                        Buffer.BlockCopy(_buffer, 0, buffer, index + tailLength, count - tailLength);
+                        _buffer.Span.Slice(_headOffset, tailLength).CopyTo(buffer[index..]);
+                        _buffer.Span[..(count - tailLength)].CopyTo(buffer[(index + tailLength)..]);
                     }
                 }
 

src/Ryujinx.Audio/Renderer/Common/BehaviourParameter.cs

@@ -25,7 +25,7 @@ namespace Ryujinx.Audio.Renderer.Common
         public ulong Flags;
 
         /// <summary>
-        /// Represents an error during <see cref="Server.AudioRenderSystem.Update(System.Memory{byte}, System.Memory{byte}, System.ReadOnlyMemory{byte})"/>.
+        /// Represents an error during <see cref="Server.AudioRenderSystem.Update(System.Memory{byte}, System.Memory{byte}, System.Buffers.ReadOnlySequence{byte})"/>.
         /// </summary>
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         public struct ErrorInfo

src/Ryujinx.Audio/Renderer/Common/UpdateDataHeader.cs

@@ -4,7 +4,7 @@ using System.Runtime.CompilerServices;
 namespace Ryujinx.Audio.Renderer.Common
 {
     /// <summary>
-    /// Update data header used for input and output of <see cref="Server.AudioRenderSystem.Update(System.Memory{byte}, System.Memory{byte}, System.ReadOnlyMemory{byte})"/>.
+    /// Update data header used for input and output of <see cref="Server.AudioRenderSystem.Update(System.Memory{byte}, System.Memory{byte}, System.Buffers.ReadOnlySequence{byte})"/>.
     /// </summary>
     public struct UpdateDataHeader
     {

src/Ryujinx.Audio/Renderer/Common/VoiceUpdateState.cs

@@ -15,7 +15,6 @@ namespace Ryujinx.Audio.Renderer.Common
     {
         public const int Align = 0x10;
         public const int BiquadStateOffset = 0x0;
-        public const int BiquadStateSize = 0x10;
 
         /// <summary>
         /// The state of the biquad filters of this voice.

src/Ryujinx.Audio/Renderer/Dsp/BiquadFilterHelper.cs

@@ -16,10 +16,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
         /// <param name="parameter">The biquad filter parameter</param>
         /// <param name="state">The biquad filter state</param>
         /// <param name="outputBuffer">The output buffer to write the result</param>
-        /// <param name="inputBuffer">The input buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
         /// <param name="sampleCount">The count of samples to process</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ProcessBiquadFilter(ref BiquadFilterParameter parameter, ref BiquadFilterState state, Span<float> outputBuffer, ReadOnlySpan<float> inputBuffer, uint sampleCount)
+        public static void ProcessBiquadFilter(
+            ref BiquadFilterParameter parameter,
+            ref BiquadFilterState state,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount)
         {
             float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
             float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
@@ -40,6 +45,96 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
         }
 
+        /// <summary>
+        /// Apply a single biquad filter and mix the result into the output buffer.
+        /// </summary>
+        /// <remarks>This is implemented with a direct form 1.</remarks>
+        /// <param name="parameter">The biquad filter parameter</param>
+        /// <param name="state">The biquad filter state</param>
+        /// <param name="outputBuffer">The output buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
+        /// <param name="sampleCount">The count of samples to process</param>
+        /// <param name="volume">Mix volume</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ProcessBiquadFilterAndMix(
+            ref BiquadFilterParameter parameter,
+            ref BiquadFilterState state,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount,
+            float volume)
+        {
+            float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+            float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+            float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+            float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+
+            for (int i = 0; i < sampleCount; i++)
+            {
+                float input = inputBuffer[i];
+                float output = input * a0 + state.State0 * a1 + state.State1 * a2 + state.State2 * b1 + state.State3 * b2;
+
+                state.State1 = state.State0;
+                state.State0 = input;
+                state.State3 = state.State2;
+                state.State2 = output;
+
+                outputBuffer[i] += FloatingPointHelper.MultiplyRoundUp(output, volume);
+            }
+        }
+
+        /// <summary>
+        /// Apply a single biquad filter and mix the result into the output buffer with volume ramp.
+        /// </summary>
+        /// <remarks>This is implemented with a direct form 1.</remarks>
+        /// <param name="parameter">The biquad filter parameter</param>
+        /// <param name="state">The biquad filter state</param>
+        /// <param name="outputBuffer">The output buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
+        /// <param name="sampleCount">The count of samples to process</param>
+        /// <param name="volume">Initial mix volume</param>
+        /// <param name="ramp">Volume increment step</param>
+        /// <returns>Last filtered sample value</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float ProcessBiquadFilterAndMixRamp(
+            ref BiquadFilterParameter parameter,
+            ref BiquadFilterState state,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount,
+            float volume,
+            float ramp)
+        {
+            float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+            float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+            float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+            float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+
+            float mixState = 0f;
+
+            for (int i = 0; i < sampleCount; i++)
+            {
+                float input = inputBuffer[i];
+                float output = input * a0 + state.State0 * a1 + state.State1 * a2 + state.State2 * b1 + state.State3 * b2;
+
+                state.State1 = state.State0;
+                state.State0 = input;
+                state.State3 = state.State2;
+                state.State2 = output;
+
+                mixState = FloatingPointHelper.MultiplyRoundUp(output, volume);
+
+                outputBuffer[i] += mixState;
+                volume += ramp;
+            }
+
+            return mixState;
+        }
+
         /// <summary>
         /// Apply multiple biquad filter.
         /// </summary>
@@ -47,10 +142,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
         /// <param name="parameters">The biquad filter parameter</param>
         /// <param name="states">The biquad filter state</param>
         /// <param name="outputBuffer">The output buffer to write the result</param>
-        /// <param name="inputBuffer">The input buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
         /// <param name="sampleCount">The count of samples to process</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ProcessBiquadFilter(ReadOnlySpan<BiquadFilterParameter> parameters, Span<BiquadFilterState> states, Span<float> outputBuffer, ReadOnlySpan<float> inputBuffer, uint sampleCount)
+        public static void ProcessBiquadFilter(
+            ReadOnlySpan<BiquadFilterParameter> parameters,
+            Span<BiquadFilterState> states,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount)
         {
             for (int stageIndex = 0; stageIndex < parameters.Length; stageIndex++)
             {
@@ -67,7 +167,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
 
                 for (int i = 0; i < sampleCount; i++)
                 {
-                    float input = inputBuffer[i];
+                    float input = stageIndex != 0 ? outputBuffer[i] : inputBuffer[i];
                     float output = input * a0 + state.State0 * a1 + state.State1 * a2 + state.State2 * b1 + state.State3 * b2;
 
                     state.State1 = state.State0;
@@ -79,5 +179,129 @@ namespace Ryujinx.Audio.Renderer.Dsp
                 }
             }
         }
+
+        /// <summary>
+        /// Apply double biquad filter and mix the result into the output buffer.
+        /// </summary>
+        /// <remarks>This is implemented with a direct form 1.</remarks>
+        /// <param name="parameters">The biquad filter parameter</param>
+        /// <param name="states">The biquad filter state</param>
+        /// <param name="outputBuffer">The output buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
+        /// <param name="sampleCount">The count of samples to process</param>
+        /// <param name="volume">Mix volume</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ProcessDoubleBiquadFilterAndMix(
+            ref BiquadFilterParameter parameter0,
+            ref BiquadFilterParameter parameter1,
+            ref BiquadFilterState state0,
+            ref BiquadFilterState state1,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount,
+            float volume)
+        {
+            float a00 = FixedPointHelper.ToFloat(parameter0.Numerator[0], FixedPointPrecisionForParameter);
+            float a10 = FixedPointHelper.ToFloat(parameter0.Numerator[1], FixedPointPrecisionForParameter);
+            float a20 = FixedPointHelper.ToFloat(parameter0.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b10 = FixedPointHelper.ToFloat(parameter0.Denominator[0], FixedPointPrecisionForParameter);
+            float b20 = FixedPointHelper.ToFloat(parameter0.Denominator[1], FixedPointPrecisionForParameter);
+
+            float a01 = FixedPointHelper.ToFloat(parameter1.Numerator[0], FixedPointPrecisionForParameter);
+            float a11 = FixedPointHelper.ToFloat(parameter1.Numerator[1], FixedPointPrecisionForParameter);
+            float a21 = FixedPointHelper.ToFloat(parameter1.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b11 = FixedPointHelper.ToFloat(parameter1.Denominator[0], FixedPointPrecisionForParameter);
+            float b21 = FixedPointHelper.ToFloat(parameter1.Denominator[1], FixedPointPrecisionForParameter);
+
+            for (int i = 0; i < sampleCount; i++)
+            {
+                float input = inputBuffer[i];
+                float output = input * a00 + state0.State0 * a10 + state0.State1 * a20 + state0.State2 * b10 + state0.State3 * b20;
+
+                state0.State1 = state0.State0;
+                state0.State0 = input;
+                state0.State3 = state0.State2;
+                state0.State2 = output;
+
+                input = output;
+                output = input * a01 + state1.State0 * a11 + state1.State1 * a21 + state1.State2 * b11 + state1.State3 * b21;
+
+                state1.State1 = state1.State0;
+                state1.State0 = input;
+                state1.State3 = state1.State2;
+                state1.State2 = output;
+
+                outputBuffer[i] += FloatingPointHelper.MultiplyRoundUp(output, volume);
+            }
+        }
+
+        /// <summary>
+        /// Apply double biquad filter and mix the result into the output buffer with volume ramp.
+        /// </summary>
+        /// <remarks>This is implemented with a direct form 1.</remarks>
+        /// <param name="parameters">The biquad filter parameter</param>
+        /// <param name="states">The biquad filter state</param>
+        /// <param name="outputBuffer">The output buffer to write the result</param>
+        /// <param name="inputBuffer">The input buffer to read the samples from</param>
+        /// <param name="sampleCount">The count of samples to process</param>
+        /// <param name="volume">Initial mix volume</param>
+        /// <param name="ramp">Volume increment step</param>
+        /// <returns>Last filtered sample value</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float ProcessDoubleBiquadFilterAndMixRamp(
+            ref BiquadFilterParameter parameter0,
+            ref BiquadFilterParameter parameter1,
+            ref BiquadFilterState state0,
+            ref BiquadFilterState state1,
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            uint sampleCount,
+            float volume,
+            float ramp)
+        {
+            float a00 = FixedPointHelper.ToFloat(parameter0.Numerator[0], FixedPointPrecisionForParameter);
+            float a10 = FixedPointHelper.ToFloat(parameter0.Numerator[1], FixedPointPrecisionForParameter);
+            float a20 = FixedPointHelper.ToFloat(parameter0.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b10 = FixedPointHelper.ToFloat(parameter0.Denominator[0], FixedPointPrecisionForParameter);
+            float b20 = FixedPointHelper.ToFloat(parameter0.Denominator[1], FixedPointPrecisionForParameter);
+
+            float a01 = FixedPointHelper.ToFloat(parameter1.Numerator[0], FixedPointPrecisionForParameter);
+            float a11 = FixedPointHelper.ToFloat(parameter1.Numerator[1], FixedPointPrecisionForParameter);
+            float a21 = FixedPointHelper.ToFloat(parameter1.Numerator[2], FixedPointPrecisionForParameter);
+
+            float b11 = FixedPointHelper.ToFloat(parameter1.Denominator[0], FixedPointPrecisionForParameter);
+            float b21 = FixedPointHelper.ToFloat(parameter1.Denominator[1], FixedPointPrecisionForParameter);
+
+            float mixState = 0f;
+
+            for (int i = 0; i < sampleCount; i++)
+            {
+                float input = inputBuffer[i];
+                float output = input * a00 + state0.State0 * a10 + state0.State1 * a20 + state0.State2 * b10 + state0.State3 * b20;
+
+                state0.State1 = state0.State0;
+                state0.State0 = input;
+                state0.State3 = state0.State2;
+                state0.State2 = output;
+
+                input = output;
+                output = input * a01 + state1.State0 * a11 + state1.State1 * a21 + state1.State2 * b11 + state1.State3 * b21;
+
+                state1.State1 = state1.State0;
+                state1.State0 = input;
+                state1.State3 = state1.State2;
+                state1.State2 = output;
+
+                mixState = FloatingPointHelper.MultiplyRoundUp(output, volume);
+
+                outputBuffer[i] += mixState;
+                volume += ramp;
+            }
+
+            return mixState;
+        }
     }
 }

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

@@ -0,0 +1,123 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using System;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Command
+{
+    public class BiquadFilterAndMixCommand : ICommand
+    {
+        public bool Enabled { get; set; }
+
+        public int NodeId { get; }
+
+        public CommandType CommandType => CommandType.BiquadFilterAndMix;
+
+        public uint EstimatedProcessingTime { get; set; }
+
+        public ushort InputBufferIndex { get; }
+        public ushort OutputBufferIndex { get; }
+
+        private BiquadFilterParameter _parameter;
+
+        public Memory<BiquadFilterState> BiquadFilterState { get; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState { get; }
+
+        public Memory<VoiceUpdateState> State { get; }
+
+        public int LastSampleIndex { get; }
+
+        public float Volume0 { get; }
+        public float Volume1 { get; }
+
+        public bool NeedInitialization { get; }
+        public bool HasVolumeRamp { get; }
+        public bool IsFirstMixBuffer { get; }
+
+        public BiquadFilterAndMixCommand(
+            float volume0,
+            float volume1,
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            int lastSampleIndex,
+            Memory<VoiceUpdateState> state,
+            ref BiquadFilterParameter filter,
+            Memory<BiquadFilterState> biquadFilterState,
+            Memory<BiquadFilterState> previousBiquadFilterState,
+            bool needInitialization,
+            bool hasVolumeRamp,
+            bool isFirstMixBuffer,
+            int nodeId)
+        {
+            Enabled = true;
+            NodeId = nodeId;
+
+            InputBufferIndex = (ushort)inputBufferIndex;
+            OutputBufferIndex = (ushort)outputBufferIndex;
+
+            _parameter = filter;
+            BiquadFilterState = biquadFilterState;
+            PreviousBiquadFilterState = previousBiquadFilterState;
+
+            State = state;
+            LastSampleIndex = lastSampleIndex;
+
+            Volume0 = volume0;
+            Volume1 = volume1;
+
+            NeedInitialization = needInitialization;
+            HasVolumeRamp = hasVolumeRamp;
+            IsFirstMixBuffer = isFirstMixBuffer;
+        }
+
+        public void Process(CommandList context)
+        {
+            ReadOnlySpan<float> inputBuffer = context.GetBuffer(InputBufferIndex);
+            Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);
+
+            if (NeedInitialization)
+            {
+                // If there is no previous state, initialize to zero.
+
+                BiquadFilterState.Span[0] = new BiquadFilterState();
+            }
+            else if (IsFirstMixBuffer)
+            {
+                // This is the first buffer, set previous state to current state.
+
+                PreviousBiquadFilterState.Span[0] = BiquadFilterState.Span[0];
+            }
+            else
+            {
+                // Rewind the current state by copying back the previous state.
+
+                BiquadFilterState.Span[0] = PreviousBiquadFilterState.Span[0];
+            }
+
+            if (HasVolumeRamp)
+            {
+                float volume = Volume0;
+                float ramp = (Volume1 - Volume0) / (int)context.SampleCount;
+
+                State.Span[0].LastSamples[LastSampleIndex] = BiquadFilterHelper.ProcessBiquadFilterAndMixRamp(
+                    ref _parameter,
+                    ref BiquadFilterState.Span[0],
+                    outputBuffer,
+                    inputBuffer,
+                    context.SampleCount,
+                    volume,
+                    ramp);
+            }
+            else
+            {
+                BiquadFilterHelper.ProcessBiquadFilterAndMix(
+                    ref _parameter,
+                    ref BiquadFilterState.Span[0],
+                    outputBuffer,
+                    inputBuffer,
+                    context.SampleCount,
+                    Volume1);
+            }
+        }
+    }
+}

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

@@ -30,8 +30,10 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         CopyMixBuffer,
         LimiterVersion1,
         LimiterVersion2,
-        GroupedBiquadFilter,
+        MultiTapBiquadFilter,
         CaptureBuffer,
         Compressor,
+        BiquadFilterAndMix,
+        MultiTapBiquadFilterAndMix,
     }
 }

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

@@ -1,9 +1,11 @@
 using Ryujinx.Audio.Renderer.Dsp.Effect;
 using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
 using Ryujinx.Audio.Renderer.Parameter.Effect;
 using Ryujinx.Audio.Renderer.Server.Effect;
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 
 namespace Ryujinx.Audio.Renderer.Dsp.Command
 {
@@ -21,18 +23,20 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public CompressorParameter Parameter => _parameter;
         public Memory<CompressorState> State { get; }
+        public Memory<EffectResultState> ResultState { get; }
         public ushort[] OutputBufferIndices { get; }
         public ushort[] InputBufferIndices { get; }
         public bool IsEffectEnabled { get; }
 
         private CompressorParameter _parameter;
 
-        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, Memory<EffectResultState> resultState, bool isEnabled, int nodeId)
         {
             Enabled = true;
             NodeId = nodeId;
             _parameter = parameter;
             State = state;
+            ResultState = resultState;
 
             IsEffectEnabled = isEnabled;
 
@@ -71,9 +75,16 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             if (IsEffectEnabled && _parameter.IsChannelCountValid())
             {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
+                if (!ResultState.IsEmpty && _parameter.StatisticsReset)
+                {
+                    ref CompressorStatistics statistics = ref MemoryMarshal.Cast<byte, CompressorStatistics>(ResultState.Span[0].SpecificData)[0];
+
+                    statistics.Reset(_parameter.ChannelCount);
+                }
+
+                Span<IntPtr> inputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
+                Span<IntPtr> outputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
+                Span<float> channelInput = stackalloc float[_parameter.ChannelCount];
                 ExponentialMovingAverage inputMovingAverage = state.InputMovingAverage;
                 float unknown4 = state.Unknown4;
                 ExponentialMovingAverage compressionGainAverage = state.CompressionGainAverage;
@@ -92,7 +103,8 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                         channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex);
                     }
 
-                    float newMean = inputMovingAverage.Update(FloatingPointHelper.MeanSquare(channelInput), _parameter.InputGain);
+                    float mean = FloatingPointHelper.MeanSquare(channelInput);
+                    float newMean = inputMovingAverage.Update(mean, _parameter.InputGain);
                     float y = FloatingPointHelper.Log10(newMean) * 10.0f;
                     float z = 1.0f;
 
@@ -111,7 +123,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         if (y >= state.Unknown14)
                         {
-                            tmpGain = ((1.0f / Parameter.Ratio) - 1.0f) * (y - Parameter.Threshold);
+                            tmpGain = ((1.0f / _parameter.Ratio) - 1.0f) * (y - _parameter.Threshold);
                         }
                         else
                         {
@@ -126,7 +138,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                     if ((unknown4 - z) <= 0.08f)
                     {
-                        compressionEmaAlpha = Parameter.ReleaseCoefficient;
+                        compressionEmaAlpha = _parameter.ReleaseCoefficient;
 
                         if ((unknown4 - z) >= -0.08f)
                         {
@@ -140,18 +152,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                     }
                     else
                     {
-                        compressionEmaAlpha = Parameter.AttackCoefficient;
+                        compressionEmaAlpha = _parameter.AttackCoefficient;
                     }
 
                     float compressionGain = compressionGainAverage.Update(z, compressionEmaAlpha);
 
-                    for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
+                    for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
                     {
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = channelInput[channelIndex] * compressionGain * state.OutputGain;
                     }
 
                     unknown4 = unknown4New;
                     previousCompressionEmaAlpha = compressionEmaAlpha;
+
+                    if (!ResultState.IsEmpty)
+                    {
+                        ref CompressorStatistics statistics = ref MemoryMarshal.Cast<byte, CompressorStatistics>(ResultState.Span[0].SpecificData)[0];
+
+                        statistics.MinimumGain = MathF.Min(statistics.MinimumGain, compressionGain * state.OutputGain);
+                        statistics.MaximumMean = MathF.Max(statistics.MaximumMean, mean);
+
+                        for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
+                        {
+                            statistics.LastSamples[channelIndex] = MathF.Abs(channelInput[channelIndex] * (1f / 32768f));
+                        }
+                    }
                 }
 
                 state.InputMovingAverage = inputMovingAverage;
@@ -161,7 +186,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
             else
             {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
+                for (int i = 0; i < _parameter.ChannelCount; i++)
                 {
                     if (InputBufferIndices[i] != OutputBufferIndices[i])
                     {

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

@@ -38,10 +38,10 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
 
-            for (int i = 0; i < Parameter.ChannelCount; i++)
+            for (int i = 0; i < _parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
             }
         }
 
@@ -51,11 +51,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             if (IsEffectEnabled)
             {
-                if (Parameter.Status == UsageState.Invalid)
+                if (_parameter.Status == UsageState.Invalid)
                 {
                     state = new LimiterState(ref _parameter, WorkBuffer);
                 }
-                else if (Parameter.Status == UsageState.New)
+                else if (_parameter.Status == UsageState.New)
                 {
                     LimiterState.UpdateParameter(ref _parameter);
                 }
@@ -66,56 +66,56 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         private unsafe void ProcessLimiter(CommandList context, ref LimiterState state)
         {
-            Debug.Assert(Parameter.IsChannelCountValid());
+            Debug.Assert(_parameter.IsChannelCountValid());
 
-            if (IsEffectEnabled && Parameter.IsChannelCountValid())
+            if (IsEffectEnabled && _parameter.IsChannelCountValid())
             {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<IntPtr> inputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
+                Span<IntPtr> outputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
 
-                for (int i = 0; i < Parameter.ChannelCount; i++)
+                for (int i = 0; i < _parameter.ChannelCount; i++)
                 {
                     inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
                     outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
                 }
 
-                for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
+                for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
                 {
                     for (int sampleIndex = 0; sampleIndex < context.SampleCount; sampleIndex++)
                     {
                         float rawInputSample = *((float*)inputBuffers[channelIndex] + sampleIndex);
 
-                        float inputSample = (rawInputSample / short.MaxValue) * Parameter.InputGain;
+                        float inputSample = (rawInputSample / short.MaxValue) * _parameter.InputGain;
 
                         float sampleInputMax = Math.Abs(inputSample);
 
-                        float inputCoefficient = Parameter.ReleaseCoefficient;
+                        float inputCoefficient = _parameter.ReleaseCoefficient;
 
                         if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
-                            inputCoefficient = Parameter.AttackCoefficient;
+                            inputCoefficient = _parameter.AttackCoefficient;
                         }
 
                         float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (detectorValue > Parameter.Threshold)
+                        if (detectorValue > _parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / detectorValue;
+                            attenuation = _parameter.Threshold / detectorValue;
                         }
 
-                        float outputCoefficient = Parameter.ReleaseCoefficient;
+                        float outputCoefficient = _parameter.ReleaseCoefficient;
 
                         if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
-                            outputCoefficient = Parameter.AttackCoefficient;
+                            outputCoefficient = _parameter.AttackCoefficient;
                         }
 
                         float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
-                        ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
+                        ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * _parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * _parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 
@@ -123,16 +123,16 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         state.DelayedSampleBufferPosition[channelIndex]++;
 
-                        while (state.DelayedSampleBufferPosition[channelIndex] >= Parameter.DelayBufferSampleCountMin)
+                        while (state.DelayedSampleBufferPosition[channelIndex] >= _parameter.DelayBufferSampleCountMin)
                         {
-                            state.DelayedSampleBufferPosition[channelIndex] -= Parameter.DelayBufferSampleCountMin;
+                            state.DelayedSampleBufferPosition[channelIndex] -= _parameter.DelayBufferSampleCountMin;
                         }
                     }
                 }
             }
             else
             {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
+                for (int i = 0; i < _parameter.ChannelCount; i++)
                 {
                     if (InputBufferIndices[i] != OutputBufferIndices[i])
                     {

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

@@ -49,10 +49,10 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
 
-            for (int i = 0; i < Parameter.ChannelCount; i++)
+            for (int i = 0; i < _parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
             }
         }
 
@@ -62,11 +62,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             if (IsEffectEnabled)
             {
-                if (Parameter.Status == UsageState.Invalid)
+                if (_parameter.Status == UsageState.Invalid)
                 {
                     state = new LimiterState(ref _parameter, WorkBuffer);
                 }
-                else if (Parameter.Status == UsageState.New)
+                else if (_parameter.Status == UsageState.New)
                 {
                     LimiterState.UpdateParameter(ref _parameter);
                 }
@@ -77,63 +77,63 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         private unsafe void ProcessLimiter(CommandList context, ref LimiterState state)
         {
-            Debug.Assert(Parameter.IsChannelCountValid());
+            Debug.Assert(_parameter.IsChannelCountValid());
 
-            if (IsEffectEnabled && Parameter.IsChannelCountValid())
+            if (IsEffectEnabled && _parameter.IsChannelCountValid())
             {
-                if (!ResultState.IsEmpty && Parameter.StatisticsReset)
+                if (!ResultState.IsEmpty && _parameter.StatisticsReset)
                 {
                     ref LimiterStatistics statistics = ref MemoryMarshal.Cast<byte, LimiterStatistics>(ResultState.Span[0].SpecificData)[0];
 
                     statistics.Reset();
                 }
 
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<IntPtr> inputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
+                Span<IntPtr> outputBuffers = stackalloc IntPtr[_parameter.ChannelCount];
 
-                for (int i = 0; i < Parameter.ChannelCount; i++)
+                for (int i = 0; i < _parameter.ChannelCount; i++)
                 {
                     inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
                     outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
                 }
 
-                for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
+                for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
                 {
                     for (int sampleIndex = 0; sampleIndex < context.SampleCount; sampleIndex++)
                     {
                         float rawInputSample = *((float*)inputBuffers[channelIndex] + sampleIndex);
 
-                        float inputSample = (rawInputSample / short.MaxValue) * Parameter.InputGain;
+                        float inputSample = (rawInputSample / short.MaxValue) * _parameter.InputGain;
 
                         float sampleInputMax = Math.Abs(inputSample);
 
-                        float inputCoefficient = Parameter.ReleaseCoefficient;
+                        float inputCoefficient = _parameter.ReleaseCoefficient;
 
                         if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
-                            inputCoefficient = Parameter.AttackCoefficient;
+                            inputCoefficient = _parameter.AttackCoefficient;
                         }
 
                         float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (detectorValue > Parameter.Threshold)
+                        if (detectorValue > _parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / detectorValue;
+                            attenuation = _parameter.Threshold / detectorValue;
                         }
 
-                        float outputCoefficient = Parameter.ReleaseCoefficient;
+                        float outputCoefficient = _parameter.ReleaseCoefficient;
 
                         if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
-                            outputCoefficient = Parameter.AttackCoefficient;
+                            outputCoefficient = _parameter.AttackCoefficient;
                         }
 
                         float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
-                        ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
+                        ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * _parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * _parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 
@@ -141,9 +141,9 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         state.DelayedSampleBufferPosition[channelIndex]++;
 
-                        while (state.DelayedSampleBufferPosition[channelIndex] >= Parameter.DelayBufferSampleCountMin)
+                        while (state.DelayedSampleBufferPosition[channelIndex] >= _parameter.DelayBufferSampleCountMin)
                         {
-                            state.DelayedSampleBufferPosition[channelIndex] -= Parameter.DelayBufferSampleCountMin;
+                            state.DelayedSampleBufferPosition[channelIndex] -= _parameter.DelayBufferSampleCountMin;
                         }
 
                         if (!ResultState.IsEmpty)
@@ -158,7 +158,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             }
             else
             {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
+                for (int i = 0; i < _parameter.ChannelCount; i++)
                 {
                     if (InputBufferIndices[i] != OutputBufferIndices[i])
                     {

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

@@ -24,7 +24,14 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public Memory<VoiceUpdateState> State { get; }
 
-        public MixRampGroupedCommand(uint mixBufferCount, uint inputBufferIndex, uint outputBufferIndex, Span<float> volume0, Span<float> volume1, Memory<VoiceUpdateState> state, int nodeId)
+        public MixRampGroupedCommand(
+            uint mixBufferCount,
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            ReadOnlySpan<float> volume0,
+            ReadOnlySpan<float> volume1,
+            Memory<VoiceUpdateState> state,
+            int nodeId)
         {
             Enabled = true;
             MixBufferCount = mixBufferCount;
@@ -48,7 +55,12 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static float ProcessMixRampGrouped(Span<float> outputBuffer, ReadOnlySpan<float> inputBuffer, float volume0, float volume1, int sampleCount)
+        private static float ProcessMixRampGrouped(
+            Span<float> outputBuffer,
+            ReadOnlySpan<float> inputBuffer,
+            float volume0,
+            float volume1,
+            int sampleCount)
         {
             float ramp = (volume1 - volume0) / sampleCount;
             float volume = volume0;

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

@@ -0,0 +1,145 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter;
+using System;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Command
+{
+    public class MultiTapBiquadFilterAndMixCommand : ICommand
+    {
+        public bool Enabled { get; set; }
+
+        public int NodeId { get; }
+
+        public CommandType CommandType => CommandType.MultiTapBiquadFilterAndMix;
+
+        public uint EstimatedProcessingTime { get; set; }
+
+        public ushort InputBufferIndex { get; }
+        public ushort OutputBufferIndex { get; }
+
+        private BiquadFilterParameter _parameter0;
+        private BiquadFilterParameter _parameter1;
+
+        public Memory<BiquadFilterState> BiquadFilterState0 { get; }
+        public Memory<BiquadFilterState> BiquadFilterState1 { get; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState0 { get; }
+        public Memory<BiquadFilterState> PreviousBiquadFilterState1 { get; }
+
+        public Memory<VoiceUpdateState> State { get; }
+
+        public int LastSampleIndex { get; }
+
+        public float Volume0 { get; }
+        public float Volume1 { get; }
+
+        public bool NeedInitialization0 { get; }
+        public bool NeedInitialization1 { get; }
+        public bool HasVolumeRamp { get; }
+        public bool IsFirstMixBuffer { get; }
+
+        public MultiTapBiquadFilterAndMixCommand(
+            float volume0,
+            float volume1,
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            int lastSampleIndex,
+            Memory<VoiceUpdateState> state,
+            ref BiquadFilterParameter filter0,
+            ref BiquadFilterParameter filter1,
+            Memory<BiquadFilterState> biquadFilterState0,
+            Memory<BiquadFilterState> biquadFilterState1,
+            Memory<BiquadFilterState> previousBiquadFilterState0,
+            Memory<BiquadFilterState> previousBiquadFilterState1,
+            bool needInitialization0,
+            bool needInitialization1,
+            bool hasVolumeRamp,
+            bool isFirstMixBuffer,
+            int nodeId)
+        {
+            Enabled = true;
+            NodeId = nodeId;
+
+            InputBufferIndex = (ushort)inputBufferIndex;
+            OutputBufferIndex = (ushort)outputBufferIndex;
+
+            _parameter0 = filter0;
+            _parameter1 = filter1;
+            BiquadFilterState0 = biquadFilterState0;
+            BiquadFilterState1 = biquadFilterState1;
+            PreviousBiquadFilterState0 = previousBiquadFilterState0;
+            PreviousBiquadFilterState1 = previousBiquadFilterState1;
+
+            State = state;
+            LastSampleIndex = lastSampleIndex;
+
+            Volume0 = volume0;
+            Volume1 = volume1;
+
+            NeedInitialization0 = needInitialization0;
+            NeedInitialization1 = needInitialization1;
+            HasVolumeRamp = hasVolumeRamp;
+            IsFirstMixBuffer = isFirstMixBuffer;
+        }
+
+        private void UpdateState(Memory<BiquadFilterState> state, Memory<BiquadFilterState> previousState, bool needInitialization)
+        {
+            if (needInitialization)
+            {
+                // If there is no previous state, initialize to zero.
+
+                state.Span[0] = new BiquadFilterState();
+            }
+            else if (IsFirstMixBuffer)
+            {
+                // This is the first buffer, set previous state to current state.
+
+                previousState.Span[0] = state.Span[0];
+            }
+            else
+            {
+                // Rewind the current state by copying back the previous state.
+
+                state.Span[0] = previousState.Span[0];
+            }
+        }
+
+        public void Process(CommandList context)
+        {
+            ReadOnlySpan<float> inputBuffer = context.GetBuffer(InputBufferIndex);
+            Span<float> outputBuffer = context.GetBuffer(OutputBufferIndex);
+
+            UpdateState(BiquadFilterState0, PreviousBiquadFilterState0, NeedInitialization0);
+            UpdateState(BiquadFilterState1, PreviousBiquadFilterState1, NeedInitialization1);
+
+            if (HasVolumeRamp)
+            {
+                float volume = Volume0;
+                float ramp = (Volume1 - Volume0) / (int)context.SampleCount;
+
+                State.Span[0].LastSamples[LastSampleIndex] = BiquadFilterHelper.ProcessDoubleBiquadFilterAndMixRamp(
+                    ref _parameter0,
+                    ref _parameter1,
+                    ref BiquadFilterState0.Span[0],
+                    ref BiquadFilterState1.Span[0],
+                    outputBuffer,
+                    inputBuffer,
+                    context.SampleCount,
+                    volume,
+                    ramp);
+            }
+            else
+            {
+                BiquadFilterHelper.ProcessDoubleBiquadFilterAndMix(
+                    ref _parameter0,
+                    ref _parameter1,
+                    ref BiquadFilterState0.Span[0],
+                    ref BiquadFilterState1.Span[0],
+                    outputBuffer,
+                    inputBuffer,
+                    context.SampleCount,
+                    Volume1);
+            }
+        }
+    }
+}

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

@@ -4,13 +4,13 @@ using System;
 
 namespace Ryujinx.Audio.Renderer.Dsp.Command
 {
-    public class GroupedBiquadFilterCommand : ICommand
+    public class MultiTapBiquadFilterCommand : ICommand
     {
         public bool Enabled { get; set; }
 
         public int NodeId { get; }
 
-        public CommandType CommandType => CommandType.GroupedBiquadFilter;
+        public CommandType CommandType => CommandType.MultiTapBiquadFilter;
 
         public uint EstimatedProcessingTime { get; set; }
 
@@ -20,7 +20,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         private readonly int _outputBufferIndex;
         private readonly bool[] _isInitialized;
 
-        public GroupedBiquadFilterCommand(int baseIndex, ReadOnlySpan<BiquadFilterParameter> filters, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
+        public MultiTapBiquadFilterCommand(int baseIndex, ReadOnlySpan<BiquadFilterParameter> filters, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
         {
             _parameters = filters.ToArray();
             _biquadFilterStates = biquadFilterStateMemory;

src/Ryujinx.Audio/Renderer/Dsp/State/BiquadFilterState.cs

@@ -2,12 +2,16 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x10)]
+    [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x20)]
     public struct BiquadFilterState
     {
         public float State0;
         public float State1;
         public float State2;
         public float State3;
+        public float State4;
+        public float State5;
+        public float State6;
+        public float State7;
     }
 }

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

@@ -8,7 +8,7 @@ namespace Ryujinx.Audio.Renderer.Parameter
     /// <summary>
     /// Output information for behaviour.
     /// </summary>
-    /// <remarks>This is used to report errors to the user during <see cref="Server.AudioRenderSystem.Update(Memory{byte}, Memory{byte}, ReadOnlyMemory{byte})"/> processing.</remarks>
+    /// <remarks>This is used to report errors to the user during <see cref="Server.AudioRenderSystem.Update(Memory{byte}, Memory{byte}, System.Buffers.ReadOnlySequence{byte})"/> processing.</remarks>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct BehaviourErrorInfoOutStatus
     {

src/Ryujinx.Audio/Renderer/Parameter/Effect/CompressorParameter.cs

@@ -90,9 +90,16 @@ namespace Ryujinx.Audio.Renderer.Parameter.Effect
         public bool MakeupGainEnabled;
 
         /// <summary>
-        /// Reserved/padding.
+        /// Indicate if the compressor effect should output statistics.
         /// </summary>
-        private Array2<byte> _reserved;
+        [MarshalAs(UnmanagedType.I1)]
+        public bool StatisticsEnabled;
+
+        /// <summary>
+        /// Indicate to the DSP that the user did a statistics reset.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool StatisticsReset;
 
         /// <summary>
         /// Check if the <see cref="ChannelCount"/> is valid.

src/Ryujinx.Audio/Renderer/Parameter/Effect/CompressorStatistics.cs

@@ -0,0 +1,38 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Parameter.Effect
+{
+    /// <summary>
+    /// Effect result state for <seealso cref="Common.EffectType.Compressor"/>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct CompressorStatistics
+    {
+        /// <summary>
+        /// Maximum input mean value since last reset.
+        /// </summary>
+        public float MaximumMean;
+
+        /// <summary>
+        /// Minimum output gain since last reset.
+        /// </summary>
+        public float MinimumGain;
+
+        /// <summary>
+        /// Last processed input sample, per channel.
+        /// </summary>
+        public Array6<float> LastSamples;
+
+        /// <summary>
+        /// Reset the statistics.
+        /// </summary>
+        /// <param name="channelCount">Number of channels to reset.</param>
+        public void Reset(ushort channelCount)
+        {
+            MaximumMean = 0.0f;
+            MinimumGain = 1.0f;
+            LastSamples.AsSpan()[..channelCount].Clear();
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+using Ryujinx.Common.Memory;
+using System;
+
+namespace Ryujinx.Audio.Renderer.Parameter
+{
+    /// <summary>
+    /// Generic interface for the splitter destination parameters.
+    /// </summary>
+    public interface ISplitterDestinationInParameter
+    {
+        /// <summary>
+        /// Target splitter destination data id.
+        /// </summary>
+        int Id { get; }
+
+        /// <summary>
+        /// The mix to output the result of the splitter.
+        /// </summary>
+        int DestinationId { get; }
+
+        /// <summary>
+        /// Biquad filter parameters.
+        /// </summary>
+        Array2<BiquadFilterParameter> BiquadFilters { get; }
+
+        /// <summary>
+        /// Set to true if in use.
+        /// </summary>
+        bool IsUsed { get; }
+
+        /// <summary>
+        /// Set to true to force resetting the previous mix volumes.
+        /// </summary>
+        bool ResetPrevVolume { get; }
+
+        /// <summary>
+        /// Mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        Span<float> MixBufferVolume { get; }
+
+        /// <summary>
+        /// Check if the magic is valid.
+        /// </summary>
+        /// <returns>Returns true if the magic is valid.</returns>
+        bool IsMagicValid();
+    }
+}

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

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Memory;
 using Ryujinx.Common.Utilities;
 using System;
 using System.Runtime.InteropServices;
@@ -5,10 +6,10 @@ using System.Runtime.InteropServices;
 namespace Ryujinx.Audio.Renderer.Parameter
 {
     /// <summary>
-    /// Input header for a splitter destination update.
+    /// Input header for a splitter destination version 1 update.
     /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
-    public struct SplitterDestinationInParameter
+    public struct SplitterDestinationInParameterVersion1 : ISplitterDestinationInParameter
     {
         /// <summary>
         /// Magic of the input header.
@@ -36,12 +37,18 @@ namespace Ryujinx.Audio.Renderer.Parameter
         [MarshalAs(UnmanagedType.I1)]
         public bool IsUsed;
 
+        /// <summary>
+        /// Set to true to force resetting the previous mix volumes.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool ResetPrevVolume;
+
         /// <summary>
         /// Reserved/padding.
         /// </summary>
-        private unsafe fixed byte _reserved[3];
+        private unsafe fixed byte _reserved[2];
 
-        [StructLayout(LayoutKind.Sequential, Size = 4 * Constants.MixBufferCountMax, Pack = 1)]
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(float) * Constants.MixBufferCountMax, Pack = 1)]
         private struct MixArray { }
 
         /// <summary>
@@ -50,6 +57,15 @@ namespace Ryujinx.Audio.Renderer.Parameter
         /// <remarks>Used when a splitter id is specified in the mix.</remarks>
         public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mixBufferVolume);
 
+        readonly int ISplitterDestinationInParameter.Id => Id;
+
+        readonly int ISplitterDestinationInParameter.DestinationId => DestinationId;
+
+        readonly Array2<BiquadFilterParameter> ISplitterDestinationInParameter.BiquadFilters => default;
+
+        readonly bool ISplitterDestinationInParameter.IsUsed => IsUsed;
+        readonly bool ISplitterDestinationInParameter.ResetPrevVolume => ResetPrevVolume;
+
         /// <summary>
         /// The expected constant of any input header.
         /// </summary>

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

@@ -0,0 +1,88 @@
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Parameter
+{
+    /// <summary>
+    /// Input header for a splitter destination version 2 update.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct SplitterDestinationInParameterVersion2 : ISplitterDestinationInParameter
+    {
+        /// <summary>
+        /// Magic of the input header.
+        /// </summary>
+        public uint Magic;
+
+        /// <summary>
+        /// Target splitter destination data id.
+        /// </summary>
+        public int Id;
+
+        /// <summary>
+        /// Mix buffer volumes storage.
+        /// </summary>
+        private MixArray _mixBufferVolume;
+
+        /// <summary>
+        /// The mix to output the result of the splitter.
+        /// </summary>
+        public int DestinationId;
+
+        /// <summary>
+        /// Biquad filter parameters.
+        /// </summary>
+        public Array2<BiquadFilterParameter> BiquadFilters;
+
+        /// <summary>
+        /// Set to true if in use.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsUsed;
+
+        /// <summary>
+        /// Set to true to force resetting the previous mix volumes.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool ResetPrevVolume;
+
+        /// <summary>
+        /// Reserved/padding.
+        /// </summary>
+        private unsafe fixed byte _reserved[10];
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(float) * Constants.MixBufferCountMax, Pack = 1)]
+        private struct MixArray { }
+
+        /// <summary>
+        /// Mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mixBufferVolume);
+
+        readonly int ISplitterDestinationInParameter.Id => Id;
+
+        readonly int ISplitterDestinationInParameter.DestinationId => DestinationId;
+
+        readonly Array2<BiquadFilterParameter> ISplitterDestinationInParameter.BiquadFilters => BiquadFilters;
+
+        readonly bool ISplitterDestinationInParameter.IsUsed => IsUsed;
+        readonly bool ISplitterDestinationInParameter.ResetPrevVolume => ResetPrevVolume;
+
+        /// <summary>
+        /// The expected constant of any input header.
+        /// </summary>
+        private const uint ValidMagic = 0x44444E53;
+
+        /// <summary>
+        /// Check if the magic is valid.
+        /// </summary>
+        /// <returns>Returns true if the magic is valid.</returns>
+        public readonly bool IsMagicValid()
+        {
+            return Magic == ValidMagic;
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 using Ryujinx.Audio.Integration;
 using Ryujinx.Audio.Renderer.Common;
 using Ryujinx.Audio.Renderer.Dsp.Command;
+using Ryujinx.Audio.Renderer.Dsp.State;
 using Ryujinx.Audio.Renderer.Parameter;
 using Ryujinx.Audio.Renderer.Server.Effect;
 using Ryujinx.Audio.Renderer.Server.MemoryPool;
@@ -173,6 +174,22 @@ namespace Ryujinx.Audio.Renderer.Server
                 return ResultCode.WorkBufferTooSmall;
             }
 
+            Memory<BiquadFilterState> splitterBqfStates = Memory<BiquadFilterState>.Empty;
+
+            if (_behaviourContext.IsBiquadFilterParameterForSplitterEnabled() &&
+                parameter.SplitterCount > 0 &&
+                parameter.SplitterDestinationCount > 0)
+            {
+                splitterBqfStates = workBufferAllocator.Allocate<BiquadFilterState>(parameter.SplitterDestinationCount * SplitterContext.BqfStatesPerDestination, 0x10);
+
+                if (splitterBqfStates.IsEmpty)
+                {
+                    return ResultCode.WorkBufferTooSmall;
+                }
+
+                splitterBqfStates.Span.Clear();
+            }
+
             // Invalidate DSP cache on what was currently allocated with workBuffer.
             AudioProcessorMemoryManager.InvalidateDspCache(_dspMemoryPoolState.Translate(workBuffer, workBufferAllocator.Offset), workBufferAllocator.Offset);
 
@@ -292,7 +309,7 @@ namespace Ryujinx.Audio.Renderer.Server
                 state = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu);
             }
 
-            if (!_splitterContext.Initialize(ref _behaviourContext, ref parameter, workBufferAllocator))
+            if (!_splitterContext.Initialize(ref _behaviourContext, ref parameter, workBufferAllocator, splitterBqfStates))
             {
                 return ResultCode.WorkBufferTooSmall;
             }
@@ -386,7 +403,7 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
-        public ResultCode Update(Memory<byte> output, Memory<byte> performanceOutput, ReadOnlyMemory<byte> input)
+        public ResultCode Update(Memory<byte> output, Memory<byte> performanceOutput, ReadOnlySequence<byte> input)
         {
             lock (_lock)
             {
@@ -419,14 +436,16 @@ namespace Ryujinx.Audio.Renderer.Server
                     return result;
                 }
 
-                result = stateUpdater.UpdateVoices(_voiceContext, _memoryPools);
+                PoolMapper poolMapper = new PoolMapper(_processHandle, _memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
+
+                result = stateUpdater.UpdateVoices(_voiceContext, poolMapper);
 
                 if (result != ResultCode.Success)
                 {
                     return result;
                 }
 
-                result = stateUpdater.UpdateEffects(_effectContext, _isActive, _memoryPools);
+                result = stateUpdater.UpdateEffects(_effectContext, _isActive, poolMapper);
 
                 if (result != ResultCode.Success)
                 {
@@ -450,7 +469,7 @@ namespace Ryujinx.Audio.Renderer.Server
                     return result;
                 }
 
-                result = stateUpdater.UpdateSinks(_sinkContext, _memoryPools);
+                result = stateUpdater.UpdateSinks(_sinkContext, poolMapper);
 
                 if (result != ResultCode.Success)
                 {
@@ -773,6 +792,13 @@ namespace Ryujinx.Audio.Renderer.Server
             // Splitter
             size = SplitterContext.GetWorkBufferSize(size, ref behaviourContext, ref parameter);
 
+            if (behaviourContext.IsBiquadFilterParameterForSplitterEnabled() &&
+                parameter.SplitterCount > 0 &&
+                parameter.SplitterDestinationCount > 0)
+            {
+                size = WorkBufferAllocator.GetTargetSize<BiquadFilterState>(size, parameter.SplitterDestinationCount * SplitterContext.BqfStatesPerDestination, 0x10);
+            }
+
             // DSP Voice
             size = WorkBufferAllocator.GetTargetSize<VoiceUpdateState>(size, parameter.VoiceCount, VoiceUpdateState.Align);
 

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

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Diagnostics;
 using static Ryujinx.Audio.Renderer.Common.BehaviourParameter;
 
@@ -44,7 +45,6 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <see cref="Parameter.RendererInfoOutStatus"/> was added to supply the count of update done sent to the DSP.
         /// A new version of the command estimator was added to address timing changes caused by the voice changes.
         /// Additionally, the rendering limit percent was incremented to 80%.
-        ///
         /// </summary>
         /// <remarks>This was added in system update 6.0.0</remarks>
         public const int Revision5 = 5 << 24;
@@ -100,10 +100,26 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <remarks>This was added in system update 14.0.0 but some changes were made in 15.0.0</remarks>
         public const int Revision11 = 11 << 24;
 
+        /// <summary>
+        /// REV12:
+        /// Two new commands were added to for biquad filtering and mixing (with optinal volume ramp) on the same command.
+        /// Splitter destinations can now specify up to two biquad filtering parameters, used for filtering the buffer before mixing.
+        /// </summary>
+        /// <remarks>This was added in system update 17.0.0</remarks>
+        public const int Revision12 = 12 << 24;
+
+        /// <summary>
+        /// REV13:
+        /// The compressor effect can now output statistics.
+        /// Splitter destinations now explicitly reset the previous mix volume, instead of doing so on first use.
+        /// </summary>
+        /// <remarks>This was added in system update 18.0.0</remarks>
+        public const int Revision13 = 13 << 24;
+
         /// <summary>
         /// Last revision supported by the implementation.
         /// </summary>
-        public const int LastRevision = Revision11;
+        public const int LastRevision = Revision13;
 
         /// <summary>
         /// Target revision magic supported by the implementation.
@@ -211,7 +227,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <summary>
         /// Check if the audio renderer should fix the GC-ADPCM context not being provided to the DSP.
         /// </summary>
-        /// <returns>True if if the audio renderer should fix it.</returns>
+        /// <returns>True if the audio renderer should fix it.</returns>
         public bool IsAdpcmLoopContextBugFixed()
         {
             return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision2);
@@ -273,7 +289,7 @@ namespace Ryujinx.Audio.Renderer.Server
         }
 
         /// <summary>
-        /// Check if the audio renderer should trust the user destination count in <see cref="Splitter.SplitterState.Update(Splitter.SplitterContext, ref Parameter.SplitterInParameter, ReadOnlySpan{byte})"/>.
+        /// Check if the audio renderer should trust the user destination count in <see cref="Renderer.Server.Splitter.SplitterState.Update(Renderer.Server.Splitter.SplitterContext, Renderer.Parameter.SplitterInParameter, SequenceReader{byte})"/>.
         /// </summary>
         /// <returns>True if the audio renderer should trust the user destination count.</returns>
         public bool IsSplitterBugFixed()
@@ -353,7 +369,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// Check if the audio renderer should use an optimized Biquad Filter (Direct Form 1) in case of two biquad filters are defined on a voice.
         /// </summary>
         /// <returns>True if the audio renderer should use the optimization.</returns>
-        public bool IsBiquadFilterGroupedOptimizationSupported()
+        public bool UseMultiTapBiquadFilterProcessing()
         {
             return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision10);
         }
@@ -367,6 +383,24 @@ namespace Ryujinx.Audio.Renderer.Server
             return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision11);
         }
 
+        /// <summary>
+        /// Check if the audio renderer should support biquad filter on splitter.
+        /// </summary>
+        /// <returns>True if the audio renderer support biquad filter on splitter</returns>
+        public bool IsBiquadFilterParameterForSplitterEnabled()
+        {
+            return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision12);
+        }
+
+        /// <summary>
+        /// Check if the audio renderer should support explicit previous mix volume reset on splitter.
+        /// </summary>
+        /// <returns>True if the audio renderer support explicit previous mix volume reset on splitter</returns>
+        public bool IsSplitterPrevVolumeResetSupported()
+        {
+            return CheckFeatureSupported(UserRevision, BaseRevisionMagic + Revision13);
+        }
+
         /// <summary>
         /// Get the version of the <see cref="ICommandProcessingTimeEstimator"/>.
         /// </summary>

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

@@ -204,7 +204,7 @@ namespace Ryujinx.Audio.Renderer.Server
         }
 
         /// <summary>
-        /// Create a new <see cref="GroupedBiquadFilterCommand"/>.
+        /// Create a new <see cref="MultiTapBiquadFilterCommand"/>.
         /// </summary>
         /// <param name="baseIndex">The base index of the input and output buffer.</param>
         /// <param name="filters">The biquad filter parameters.</param>
@@ -213,9 +213,9 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="outputBufferOffset">The output buffer offset.</param>
         /// <param name="isInitialized">Set to true if the biquad filter state is initialized.</param>
         /// <param name="nodeId">The node id associated to this command.</param>
-        public void GenerateGroupedBiquadFilter(int baseIndex, ReadOnlySpan<BiquadFilterParameter> filters, Memory<BiquadFilterState> biquadFilterStatesMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
+        public void GenerateMultiTapBiquadFilter(int baseIndex, ReadOnlySpan<BiquadFilterParameter> filters, Memory<BiquadFilterState> biquadFilterStatesMemory, int inputBufferOffset, int outputBufferOffset, ReadOnlySpan<bool> isInitialized, int nodeId)
         {
-            GroupedBiquadFilterCommand command = new(baseIndex, filters, biquadFilterStatesMemory, inputBufferOffset, outputBufferOffset, isInitialized, nodeId);
+            MultiTapBiquadFilterCommand command = new(baseIndex, filters, biquadFilterStatesMemory, inputBufferOffset, outputBufferOffset, isInitialized, nodeId);
 
             command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 
@@ -232,7 +232,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="volume">The new volume.</param>
         /// <param name="state">The <see cref="VoiceUpdateState"/> to generate the command from.</param>
         /// <param name="nodeId">The node id associated to this command.</param>
-        public void GenerateMixRampGrouped(uint mixBufferCount, uint inputBufferIndex, uint outputBufferIndex, Span<float> previousVolume, Span<float> volume, Memory<VoiceUpdateState> state, int nodeId)
+        public void GenerateMixRampGrouped(uint mixBufferCount, uint inputBufferIndex, uint outputBufferIndex, ReadOnlySpan<float> previousVolume, ReadOnlySpan<float> volume, Memory<VoiceUpdateState> state, int nodeId)
         {
             MixRampGroupedCommand command = new(mixBufferCount, inputBufferIndex, outputBufferIndex, previousVolume, volume, state, nodeId);
 
@@ -260,6 +260,120 @@ namespace Ryujinx.Audio.Renderer.Server
             AddCommand(command);
         }
 
+        /// <summary>
+        /// Generate a new <see cref="BiquadFilterAndMixCommand"/>.
+        /// </summary>
+        /// <param name="previousVolume">The previous volume.</param>
+        /// <param name="volume">The new volume.</param>
+        /// <param name="inputBufferIndex">The input buffer index.</param>
+        /// <param name="outputBufferIndex">The output buffer index.</param>
+        /// <param name="lastSampleIndex">The index in the <see cref="VoiceUpdateState.LastSamples"/> array to store the ramped sample.</param>
+        /// <param name="state">The <see cref="VoiceUpdateState"/> to generate the command from.</param>
+        /// <param name="filter">The biquad filter parameter.</param>
+        /// <param name="biquadFilterState">The biquad state.</param>
+        /// <param name="previousBiquadFilterState">The previous biquad state.</param>
+        /// <param name="needInitialization">Set to true if the biquad filter state needs to be initialized.</param>
+        /// <param name="hasVolumeRamp">Set to true if the mix has volume ramp, and <paramref name="previousVolume"/> should be taken into account.</param>
+        /// <param name="isFirstMixBuffer">Set to true if the buffer is the first mix buffer.</param>
+        /// <param name="nodeId">The node id associated to this command.</param>
+        public void GenerateBiquadFilterAndMix(
+            float previousVolume,
+            float volume,
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            int lastSampleIndex,
+            Memory<VoiceUpdateState> state,
+            ref BiquadFilterParameter filter,
+            Memory<BiquadFilterState> biquadFilterState,
+            Memory<BiquadFilterState> previousBiquadFilterState,
+            bool needInitialization,
+            bool hasVolumeRamp,
+            bool isFirstMixBuffer,
+            int nodeId)
+        {
+            BiquadFilterAndMixCommand command = new(
+                previousVolume,
+                volume,
+                inputBufferIndex,
+                outputBufferIndex,
+                lastSampleIndex,
+                state,
+                ref filter,
+                biquadFilterState,
+                previousBiquadFilterState,
+                needInitialization,
+                hasVolumeRamp,
+                isFirstMixBuffer,
+                nodeId);
+
+            command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
+
+            AddCommand(command);
+        }
+
+        /// <summary>
+        /// Generate a new <see cref="MultiTapBiquadFilterAndMixCommand"/>.
+        /// </summary>
+        /// <param name="previousVolume">The previous volume.</param>
+        /// <param name="volume">The new volume.</param>
+        /// <param name="inputBufferIndex">The input buffer index.</param>
+        /// <param name="outputBufferIndex">The output buffer index.</param>
+        /// <param name="lastSampleIndex">The index in the <see cref="VoiceUpdateState.LastSamples"/> array to store the ramped sample.</param>
+        /// <param name="state">The <see cref="VoiceUpdateState"/> to generate the command from.</param>
+        /// <param name="filter0">First biquad filter parameter.</param>
+        /// <param name="filter1">Second biquad filter parameter.</param>
+        /// <param name="biquadFilterState0">First biquad state.</param>
+        /// <param name="biquadFilterState1">Second biquad state.</param>
+        /// <param name="previousBiquadFilterState0">First previous biquad state.</param>
+        /// <param name="previousBiquadFilterState1">Second previous biquad state.</param>
+        /// <param name="needInitialization0">Set to true if the first biquad filter state needs to be initialized.</param>
+        /// <param name="needInitialization1">Set to true if the second biquad filter state needs to be initialized.</param>
+        /// <param name="hasVolumeRamp">Set to true if the mix has volume ramp, and <paramref name="previousVolume"/> should be taken into account.</param>
+        /// <param name="isFirstMixBuffer">Set to true if the buffer is the first mix buffer.</param>
+        /// <param name="nodeId">The node id associated to this command.</param>
+        public void GenerateMultiTapBiquadFilterAndMix(
+            float previousVolume,
+            float volume,
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            int lastSampleIndex,
+            Memory<VoiceUpdateState> state,
+            ref BiquadFilterParameter filter0,
+            ref BiquadFilterParameter filter1,
+            Memory<BiquadFilterState> biquadFilterState0,
+            Memory<BiquadFilterState> biquadFilterState1,
+            Memory<BiquadFilterState> previousBiquadFilterState0,
+            Memory<BiquadFilterState> previousBiquadFilterState1,
+            bool needInitialization0,
+            bool needInitialization1,
+            bool hasVolumeRamp,
+            bool isFirstMixBuffer,
+            int nodeId)
+        {
+            MultiTapBiquadFilterAndMixCommand command = new(
+                previousVolume,
+                volume,
+                inputBufferIndex,
+                outputBufferIndex,
+                lastSampleIndex,
+                state,
+                ref filter0,
+                ref filter1,
+                biquadFilterState0,
+                biquadFilterState1,
+                previousBiquadFilterState0,
+                previousBiquadFilterState1,
+                needInitialization0,
+                needInitialization1,
+                hasVolumeRamp,
+                isFirstMixBuffer,
+                nodeId);
+
+            command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
+
+            AddCommand(command);
+        }
+
         /// <summary>
         /// Generate a new <see cref="DepopForMixBuffersCommand"/>.
         /// </summary>
@@ -268,7 +382,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <param name="bufferCount">The buffer count.</param>
         /// <param name="nodeId">The node id associated to this command.</param>
         /// <param name="sampleRate">The target sample rate in use.</param>
-        public void GenerateDepopForMixBuffersCommand(Memory<float> depopBuffer, uint bufferOffset, uint bufferCount, int nodeId, uint sampleRate)
+        public void GenerateDepopForMixBuffers(Memory<float> depopBuffer, uint bufferOffset, uint bufferCount, int nodeId, uint sampleRate)
         {
             DepopForMixBuffersCommand command = new(depopBuffer, bufferOffset, bufferCount, nodeId, sampleRate);
 
@@ -469,11 +583,20 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
-        public void GenerateCompressorEffect(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        /// <summary>
+        /// Generate a new <see cref="CompressorCommand"/>.
+        /// </summary>
+        /// <param name="bufferOffset">The target buffer offset.</param>
+        /// <param name="parameter">The compressor parameter.</param>
+        /// <param name="state">The compressor state.</param>
+        /// <param name="effectResultState">The DSP effect result state.</param>
+        /// <param name="isEnabled">Set to true if the effect should be active.</param>
+        /// <param name="nodeId">The node id associated to this command.</param>
+        public void GenerateCompressorEffect(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, Memory<EffectResultState> effectResultState, bool isEnabled, int nodeId)
         {
             if (parameter.IsChannelCountValid())
             {
-                CompressorCommand command = new(bufferOffset, parameter, state, isEnabled, nodeId);
+                CompressorCommand command = new(bufferOffset, parameter, state, effectResultState, isEnabled, nodeId);
 
                 command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
 

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

@@ -12,6 +12,7 @@ using Ryujinx.Audio.Renderer.Server.Voice;
 using Ryujinx.Audio.Renderer.Utils;
 using System;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Audio.Renderer.Server
 {
@@ -46,12 +47,13 @@ namespace Ryujinx.Audio.Renderer.Server
             {
                 ref MixState mix = ref _mixContext.GetState(voiceState.MixId);
 
-                _commandBuffer.GenerateDepopPrepare(dspState,
-                                                    _rendererContext.DepopBuffer,
-                                                    mix.BufferCount,
-                                                    mix.BufferOffset,
-                                                    voiceState.NodeId,
-                                                    voiceState.WasPlaying);
+                _commandBuffer.GenerateDepopPrepare(
+                    dspState,
+                    _rendererContext.DepopBuffer,
+                    mix.BufferCount,
+                    mix.BufferOffset,
+                    voiceState.NodeId,
+                    voiceState.WasPlaying);
             }
             else if (voiceState.SplitterId != Constants.UnusedSplitterId)
             {
@@ -59,15 +61,13 @@ namespace Ryujinx.Audio.Renderer.Server
 
                 while (true)
                 {
-                    Span<SplitterDestination> destinationSpan = _splitterContext.GetDestination((int)voiceState.SplitterId, destinationId++);
+                    SplitterDestination destination = _splitterContext.GetDestination((int)voiceState.SplitterId, destinationId++);
 
-                    if (destinationSpan.IsEmpty)
+                    if (destination.IsNull)
                     {
                         break;
                     }
 
-                    ref SplitterDestination destination = ref destinationSpan[0];
-
                     if (destination.IsConfigured())
                     {
                         int mixId = destination.DestinationId;
@@ -76,12 +76,13 @@ namespace Ryujinx.Audio.Renderer.Server
                         {
                             ref MixState mix = ref _mixContext.GetState(mixId);
 
-                            _commandBuffer.GenerateDepopPrepare(dspState,
-                                                                _rendererContext.DepopBuffer,
-                                                                mix.BufferCount,
-                                                                mix.BufferOffset,
-                                                                voiceState.NodeId,
-                                                                voiceState.WasPlaying);
+                            _commandBuffer.GenerateDepopPrepare(
+                                dspState,
+                                _rendererContext.DepopBuffer,
+                                mix.BufferCount,
+                                mix.BufferOffset,
+                                voiceState.NodeId,
+                                voiceState.WasPlaying);
 
                             destination.MarkAsNeedToUpdateInternalState();
                         }
@@ -95,35 +96,39 @@ namespace Ryujinx.Audio.Renderer.Server
 
                 if (_rendererContext.BehaviourContext.IsWaveBufferVersion2Supported())
                 {
-                    _commandBuffer.GenerateDataSourceVersion2(ref voiceState,
-                                                              dspState,
-                                                              (ushort)_rendererContext.MixBufferCount,
-                                                              (ushort)channelIndex,
-                                                              voiceState.NodeId);
+                    _commandBuffer.GenerateDataSourceVersion2(
+                        ref voiceState,
+                        dspState,
+                        (ushort)_rendererContext.MixBufferCount,
+                        (ushort)channelIndex,
+                        voiceState.NodeId);
                 }
                 else
                 {
                     switch (voiceState.SampleFormat)
                     {
                         case SampleFormat.PcmInt16:
-                            _commandBuffer.GeneratePcmInt16DataSourceVersion1(ref voiceState,
-                                                                              dspState,
-                                                                              (ushort)_rendererContext.MixBufferCount,
-                                                                              (ushort)channelIndex,
-                                                                              voiceState.NodeId);
+                            _commandBuffer.GeneratePcmInt16DataSourceVersion1(
+                                ref voiceState,
+                                dspState,
+                                (ushort)_rendererContext.MixBufferCount,
+                                (ushort)channelIndex,
+                                voiceState.NodeId);
                             break;
                         case SampleFormat.PcmFloat:
-                            _commandBuffer.GeneratePcmFloatDataSourceVersion1(ref voiceState,
-                                                                              dspState,
-                                                                              (ushort)_rendererContext.MixBufferCount,
-                                                                              (ushort)channelIndex,
-                                                                              voiceState.NodeId);
+                            _commandBuffer.GeneratePcmFloatDataSourceVersion1(
+                                ref voiceState,
+                                dspState,
+                                (ushort)_rendererContext.MixBufferCount,
+                                (ushort)channelIndex,
+                                voiceState.NodeId);
                             break;
                         case SampleFormat.Adpcm:
-                            _commandBuffer.GenerateAdpcmDataSourceVersion1(ref voiceState,
-                                                                           dspState,
-                                                                           (ushort)_rendererContext.MixBufferCount,
-                                                                           voiceState.NodeId);
+                            _commandBuffer.GenerateAdpcmDataSourceVersion1(
+                                ref voiceState,
+                                dspState,
+                                (ushort)_rendererContext.MixBufferCount,
+                                voiceState.NodeId);
                             break;
                         default:
                             throw new NotImplementedException($"Unsupported data source {voiceState.SampleFormat}");
@@ -134,14 +139,14 @@ namespace Ryujinx.Audio.Renderer.Server
 
         private void GenerateBiquadFilterForVoice(ref VoiceState voiceState, Memory<VoiceUpdateState> state, int baseIndex, int bufferOffset, int nodeId)
         {
-            bool supportsOptimizedPath = _rendererContext.BehaviourContext.IsBiquadFilterGroupedOptimizationSupported();
+            bool supportsOptimizedPath = _rendererContext.BehaviourContext.UseMultiTapBiquadFilterProcessing();
 
             if (supportsOptimizedPath && voiceState.BiquadFilters[0].Enable && voiceState.BiquadFilters[1].Enable)
             {
-                Memory<byte> biquadStateRawMemory = SpanMemoryManager<byte>.Cast(state)[..(VoiceUpdateState.BiquadStateSize * Constants.VoiceBiquadFilterCount)];
+                Memory<byte> biquadStateRawMemory = SpanMemoryManager<byte>.Cast(state)[..(Unsafe.SizeOf<BiquadFilterState>() * Constants.VoiceBiquadFilterCount)];
                 Memory<BiquadFilterState> stateMemory = SpanMemoryManager<BiquadFilterState>.Cast(biquadStateRawMemory);
 
-                _commandBuffer.GenerateGroupedBiquadFilter(baseIndex, voiceState.BiquadFilters.AsSpan(), stateMemory, bufferOffset, bufferOffset, voiceState.BiquadFilterNeedInitialization, nodeId);
+                _commandBuffer.GenerateMultiTapBiquadFilter(baseIndex, voiceState.BiquadFilters.AsSpan(), stateMemory, bufferOffset, bufferOffset, voiceState.BiquadFilterNeedInitialization, nodeId);
             }
             else
             {
@@ -151,33 +156,134 @@ namespace Ryujinx.Audio.Renderer.Server
 
                     if (filter.Enable)
                     {
-                        Memory<byte> biquadStateRawMemory = SpanMemoryManager<byte>.Cast(state)[..(VoiceUpdateState.BiquadStateSize * Constants.VoiceBiquadFilterCount)];
-
+                        Memory<byte> biquadStateRawMemory = SpanMemoryManager<byte>.Cast(state)[..(Unsafe.SizeOf<BiquadFilterState>() * Constants.VoiceBiquadFilterCount)];
                         Memory<BiquadFilterState> stateMemory = SpanMemoryManager<BiquadFilterState>.Cast(biquadStateRawMemory);
 
-                        _commandBuffer.GenerateBiquadFilter(baseIndex,
-                                                            ref filter,
-                                                            stateMemory.Slice(i, 1),
-                                                            bufferOffset,
-                                                            bufferOffset,
-                                                            !voiceState.BiquadFilterNeedInitialization[i],
-                                                            nodeId);
+                        _commandBuffer.GenerateBiquadFilter(
+                            baseIndex,
+                            ref filter,
+                            stateMemory.Slice(i, 1),
+                            bufferOffset,
+                            bufferOffset,
+                            !voiceState.BiquadFilterNeedInitialization[i],
+                            nodeId);
                     }
                 }
             }
         }
 
-        private void GenerateVoiceMix(Span<float> mixVolumes, Span<float> previousMixVolumes, Memory<VoiceUpdateState> state, uint bufferOffset, uint bufferCount, uint bufferIndex, int nodeId)
+        private void GenerateVoiceMixWithSplitter(
+            SplitterDestination destination,
+            Memory<VoiceUpdateState> state,
+            uint bufferOffset,
+            uint bufferCount,
+            uint bufferIndex,
+            int nodeId)
+        {
+            ReadOnlySpan<float> mixVolumes = destination.MixBufferVolume;
+            ReadOnlySpan<float> previousMixVolumes = destination.PreviousMixBufferVolume;
+
+            ref BiquadFilterParameter bqf0 = ref destination.GetBiquadFilterParameter(0);
+            ref BiquadFilterParameter bqf1 = ref destination.GetBiquadFilterParameter(1);
+
+            Memory<BiquadFilterState> bqfState = _splitterContext.GetBiquadFilterState(destination);
+
+            bool isFirstMixBuffer = true;
+
+            for (int i = 0; i < bufferCount; i++)
+            {
+                float previousMixVolume = previousMixVolumes[i];
+                float mixVolume = mixVolumes[i];
+
+                if (mixVolume != 0.0f || previousMixVolume != 0.0f)
+                {
+                    if (bqf0.Enable && bqf1.Enable)
+                    {
+                        _commandBuffer.GenerateMultiTapBiquadFilterAndMix(
+                            previousMixVolume,
+                            mixVolume,
+                            bufferIndex,
+                            bufferOffset + (uint)i,
+                            i,
+                            state,
+                            ref bqf0,
+                            ref bqf1,
+                            bqfState[..1],
+                            bqfState.Slice(1, 1),
+                            bqfState.Slice(2, 1),
+                            bqfState.Slice(3, 1),
+                            !destination.IsBiquadFilterEnabledPrev(),
+                            !destination.IsBiquadFilterEnabledPrev(),
+                            true,
+                            isFirstMixBuffer,
+                            nodeId);
+
+                        destination.UpdateBiquadFilterEnabledPrev(0);
+                        destination.UpdateBiquadFilterEnabledPrev(1);
+                    }
+                    else if (bqf0.Enable)
+                    {
+                        _commandBuffer.GenerateBiquadFilterAndMix(
+                            previousMixVolume,
+                            mixVolume,
+                            bufferIndex,
+                            bufferOffset + (uint)i,
+                            i,
+                            state,
+                            ref bqf0,
+                            bqfState[..1],
+                            bqfState.Slice(1, 1),
+                            !destination.IsBiquadFilterEnabledPrev(),
+                            true,
+                            isFirstMixBuffer,
+                            nodeId);
+
+                        destination.UpdateBiquadFilterEnabledPrev(0);
+                    }
+                    else if (bqf1.Enable)
+                    {
+                        _commandBuffer.GenerateBiquadFilterAndMix(
+                            previousMixVolume,
+                            mixVolume,
+                            bufferIndex,
+                            bufferOffset + (uint)i,
+                            i,
+                            state,
+                            ref bqf1,
+                            bqfState[..1],
+                            bqfState.Slice(1, 1),
+                            !destination.IsBiquadFilterEnabledPrev(),
+                            true,
+                            isFirstMixBuffer,
+                            nodeId);
+
+                        destination.UpdateBiquadFilterEnabledPrev(1);
+                    }
+
+                    isFirstMixBuffer = false;
+                }
+            }
+        }
+
+        private void GenerateVoiceMix(
+            ReadOnlySpan<float> mixVolumes,
+            ReadOnlySpan<float> previousMixVolumes,
+            Memory<VoiceUpdateState> state,
+            uint bufferOffset,
+            uint bufferCount,
+            uint bufferIndex,
+            int nodeId)
         {
             if (bufferCount > Constants.VoiceChannelCountMax)
             {
-                _commandBuffer.GenerateMixRampGrouped(bufferCount,
-                                                      bufferIndex,
-                                                      bufferOffset,
-                                                      previousMixVolumes,
-                                                      mixVolumes,
-                                                      state,
-                                                      nodeId);
+                _commandBuffer.GenerateMixRampGrouped(
+                    bufferCount,
+                    bufferIndex,
+                    bufferOffset,
+                    previousMixVolumes,
+                    mixVolumes,
+                    state,
+                    nodeId);
             }
             else
             {
@@ -188,13 +294,14 @@ namespace Ryujinx.Audio.Renderer.Server
 
                     if (mixVolume != 0.0f || previousMixVolume != 0.0f)
                     {
-                        _commandBuffer.GenerateMixRamp(previousMixVolume,
-                                                       mixVolume,
-                                                       bufferIndex,
-                                                       bufferOffset + (uint)i,
-                                                       i,
-                                                       state,
-                                                       nodeId);
+                        _commandBuffer.GenerateMixRamp(
+                            previousMixVolume,
+                            mixVolume,
+                            bufferIndex,
+                            bufferOffset + (uint)i,
+                            i,
+                            state,
+                            nodeId);
                     }
                 }
             }
@@ -271,10 +378,11 @@ namespace Ryujinx.Audio.Renderer.Server
                         GeneratePerformance(ref performanceEntry, PerformanceCommand.Type.Start, nodeId);
                     }
 
-                    _commandBuffer.GenerateVolumeRamp(voiceState.PreviousVolume,
-                                                      voiceState.Volume,
-                                                      _rendererContext.MixBufferCount + (uint)channelIndex,
-                                                      nodeId);
+                    _commandBuffer.GenerateVolumeRamp(
+                        voiceState.PreviousVolume,
+                        voiceState.Volume,
+                        _rendererContext.MixBufferCount + (uint)channelIndex,
+                        nodeId);
 
                     if (performanceInitialized)
                     {
@@ -291,15 +399,13 @@ namespace Ryujinx.Audio.Renderer.Server
 
                             while (true)
                             {
-                                Span<SplitterDestination> destinationSpan = _splitterContext.GetDestination((int)voiceState.SplitterId, destinationId);
+                                SplitterDestination destination = _splitterContext.GetDestination((int)voiceState.SplitterId, destinationId);
 
-                                if (destinationSpan.IsEmpty)
+                                if (destination.IsNull)
                                 {
                                     break;
                                 }
 
-                                ref SplitterDestination destination = ref destinationSpan[0];
-
                                 destinationId += (int)channelsCount;
 
                                 if (destination.IsConfigured())
@@ -310,13 +416,27 @@ namespace Ryujinx.Audio.Renderer.Server
                                     {
                                         ref MixState mix = ref _mixContext.GetState(mixId);
 
-                                        GenerateVoiceMix(destination.MixBufferVolume,
-                                                         destination.PreviousMixBufferVolume,
-                                                         dspStateMemory,
-                                                         mix.BufferOffset,
-                                                         mix.BufferCount,
-                                                         _rendererContext.MixBufferCount + (uint)channelIndex,
-                                                         nodeId);
+                                        if (destination.IsBiquadFilterEnabled())
+                                        {
+                                            GenerateVoiceMixWithSplitter(
+                                                destination,
+                                                dspStateMemory,
+                                                mix.BufferOffset,
+                                                mix.BufferCount,
+                                                _rendererContext.MixBufferCount + (uint)channelIndex,
+                                                nodeId);
+                                        }
+                                        else
+                                        {
+                                            GenerateVoiceMix(
+                                                destination.MixBufferVolume,
+                                                destination.PreviousMixBufferVolume,
+                                                dspStateMemory,
+                                                mix.BufferOffset,
+                                                mix.BufferCount,
+                                                _rendererContext.MixBufferCount + (uint)channelIndex,
+                                                nodeId);
+                                        }
 
                                         destination.MarkAsNeedToUpdateInternalState();
                                     }
@@ -337,13 +457,14 @@ namespace Ryujinx.Audio.Renderer.Server
                             GeneratePerformance(ref performanceEntry, PerformanceCommand.Type.Start, nodeId);
                         }
 
-                        GenerateVoiceMix(channelResource.Mix.AsSpan(),
-                                         channelResource.PreviousMix.AsSpan(),
-                                         dspStateMemory,
-                                         mix.BufferOffset,
-                                         mix.BufferCount,
-                                         _rendererContext.MixBufferCount + (uint)channelIndex,
-                                         nodeId);
+                        GenerateVoiceMix(
+                            channelResource.Mix.AsSpan(),
+                            channelResource.PreviousMix.AsSpan(),
+                            dspStateMemory,
+                            mix.BufferOffset,
+                            mix.BufferCount,
+                            _rendererContext.MixBufferCount + (uint)channelIndex,
+                            nodeId);
 
                         if (performanceInitialized)
                         {
@@ -409,10 +530,11 @@ namespace Ryujinx.Audio.Renderer.Server
                 {
                     if (effect.Parameter.Volumes[i] != 0.0f)
                     {
-                        _commandBuffer.GenerateMix((uint)bufferOffset + effect.Parameter.Input[i],
-                                                   (uint)bufferOffset + effect.Parameter.Output[i],
-                                                   nodeId,
-                                                   effect.Parameter.Volumes[i]);
+                        _commandBuffer.GenerateMix(
+                            (uint)bufferOffset + effect.Parameter.Input[i],
+                            (uint)bufferOffset + effect.Parameter.Output[i],
+                            nodeId,
+                            effect.Parameter.Volumes[i]);
                     }
                 }
             }
@@ -447,17 +569,18 @@ namespace Ryujinx.Audio.Renderer.Server
                         updateCount = newUpdateCount;
                     }
 
-                    _commandBuffer.GenerateAuxEffect(bufferOffset,
-                                                     effect.Parameter.Input[i],
-                                                     effect.Parameter.Output[i],
-                                                     ref effect.State,
-                                                     effect.IsEnabled,
-                                                     effect.Parameter.BufferStorageSize,
-                                                     effect.State.SendBufferInfoBase,
-                                                     effect.State.ReturnBufferInfoBase,
-                                                     updateCount,
-                                                     writeOffset,
-                                                     nodeId);
+                    _commandBuffer.GenerateAuxEffect(
+                        bufferOffset,
+                        effect.Parameter.Input[i],
+                        effect.Parameter.Output[i],
+                        ref effect.State,
+                        effect.IsEnabled,
+                        effect.Parameter.BufferStorageSize,
+                        effect.State.SendBufferInfoBase,
+                        effect.State.ReturnBufferInfoBase,
+                        updateCount,
+                        writeOffset,
+                        nodeId);
 
                     writeOffset = newUpdateCount;
 
@@ -500,7 +623,7 @@ namespace Ryujinx.Audio.Renderer.Server
             if (effect.IsEnabled)
             {
                 bool needInitialization = effect.Parameter.Status == UsageState.Invalid ||
-                                         (effect.Parameter.Status == UsageState.New && !_rendererContext.BehaviourContext.IsBiquadFilterEffectStateClearBugFixed());
+                    (effect.Parameter.Status == UsageState.New && !_rendererContext.BehaviourContext.IsBiquadFilterEffectStateClearBugFixed());
 
                 BiquadFilterParameter parameter = new()
                 {
@@ -512,11 +635,14 @@ namespace Ryujinx.Audio.Renderer.Server
 
                 for (int i = 0; i < effect.Parameter.ChannelCount; i++)
                 {
-                    _commandBuffer.GenerateBiquadFilter((int)bufferOffset, ref parameter, effect.State.Slice(i, 1),
-                                                        effect.Parameter.Input[i],
-                                                        effect.Parameter.Output[i],
-                                                        needInitialization,
-                                                        nodeId);
+                    _commandBuffer.GenerateBiquadFilter(
+                        (int)bufferOffset,
+                        ref parameter,
+                        effect.State.Slice(i, 1),
+                        effect.Parameter.Input[i],
+                        effect.Parameter.Output[i],
+                        needInitialization,
+                        nodeId);
                 }
             }
             else
@@ -591,15 +717,16 @@ namespace Ryujinx.Audio.Renderer.Server
                         updateCount = newUpdateCount;
                     }
 
-                    _commandBuffer.GenerateCaptureEffect(bufferOffset,
-                                                         effect.Parameter.Input[i],
-                                                         effect.State.SendBufferInfo,
-                                                         effect.IsEnabled,
-                                                         effect.Parameter.BufferStorageSize,
-                                                         effect.State.SendBufferInfoBase,
-                                                         updateCount,
-                                                         writeOffset,
-                                                         nodeId);
+                    _commandBuffer.GenerateCaptureEffect(
+                        bufferOffset,
+                        effect.Parameter.Input[i],
+                        effect.State.SendBufferInfo,
+                        effect.IsEnabled,
+                        effect.Parameter.BufferStorageSize,
+                        effect.State.SendBufferInfoBase,
+                        updateCount,
+                        writeOffset,
+                        nodeId);
 
                     writeOffset = newUpdateCount;
 
@@ -608,15 +735,28 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
-        private void GenerateCompressorEffect(uint bufferOffset, CompressorEffect effect, int nodeId)
+        private void GenerateCompressorEffect(uint bufferOffset, CompressorEffect effect, int nodeId, int effectId)
         {
             Debug.Assert(effect.Type == EffectType.Compressor);
 
-            _commandBuffer.GenerateCompressorEffect(bufferOffset,
-                                                    effect.Parameter,
-                                                    effect.State,
-                                                    effect.IsEnabled,
-                                                    nodeId);
+            Memory<EffectResultState> dspResultState;
+
+            if (effect.Parameter.StatisticsEnabled)
+            {
+                dspResultState = _effectContext.GetDspStateMemory(effectId);
+            }
+            else
+            {
+                dspResultState = Memory<EffectResultState>.Empty;
+            }
+
+            _commandBuffer.GenerateCompressorEffect(
+                bufferOffset,
+                effect.Parameter,
+                effect.State,
+                dspResultState,
+                effect.IsEnabled,
+                nodeId);
         }
 
         private void GenerateEffect(ref MixState mix, int effectId, BaseEffect effect)
@@ -629,8 +769,11 @@ namespace Ryujinx.Audio.Renderer.Server
 
             bool performanceInitialized = false;
 
-            if (_performanceManager != null && _performanceManager.GetNextEntry(out performanceEntry, effect.GetPerformanceDetailType(),
-                                                isFinalMix ? PerformanceEntryType.FinalMix : PerformanceEntryType.SubMix, nodeId))
+            if (_performanceManager != null && _performanceManager.GetNextEntry(
+                out performanceEntry,
+                effect.GetPerformanceDetailType(),
+                isFinalMix ? PerformanceEntryType.FinalMix : PerformanceEntryType.SubMix,
+                nodeId))
             {
                 performanceInitialized = true;
 
@@ -664,7 +807,7 @@ namespace Ryujinx.Audio.Renderer.Server
                     GenerateCaptureEffect(mix.BufferOffset, (CaptureBufferEffect)effect, nodeId);
                     break;
                 case EffectType.Compressor:
-                    GenerateCompressorEffect(mix.BufferOffset, (CompressorEffect)effect, nodeId);
+                    GenerateCompressorEffect(mix.BufferOffset, (CompressorEffect)effect, nodeId, effectId);
                     break;
                 default:
                     throw new NotImplementedException($"Unsupported effect type {effect.Type}");
@@ -706,6 +849,85 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
+        private void GenerateMixWithSplitter(
+            uint inputBufferIndex,
+            uint outputBufferIndex,
+            float volume,
+            SplitterDestination destination,
+            ref bool isFirstMixBuffer,
+            int nodeId)
+        {
+            ref BiquadFilterParameter bqf0 = ref destination.GetBiquadFilterParameter(0);
+            ref BiquadFilterParameter bqf1 = ref destination.GetBiquadFilterParameter(1);
+
+            Memory<BiquadFilterState> bqfState = _splitterContext.GetBiquadFilterState(destination);
+
+            if (bqf0.Enable && bqf1.Enable)
+            {
+                _commandBuffer.GenerateMultiTapBiquadFilterAndMix(
+                    0f,
+                    volume,
+                    inputBufferIndex,
+                    outputBufferIndex,
+                    0,
+                    Memory<VoiceUpdateState>.Empty,
+                    ref bqf0,
+                    ref bqf1,
+                    bqfState[..1],
+                    bqfState.Slice(1, 1),
+                    bqfState.Slice(2, 1),
+                    bqfState.Slice(3, 1),
+                    !destination.IsBiquadFilterEnabledPrev(),
+                    !destination.IsBiquadFilterEnabledPrev(),
+                    false,
+                    isFirstMixBuffer,
+                    nodeId);
+
+                destination.UpdateBiquadFilterEnabledPrev(0);
+                destination.UpdateBiquadFilterEnabledPrev(1);
+            }
+            else if (bqf0.Enable)
+            {
+                _commandBuffer.GenerateBiquadFilterAndMix(
+                    0f,
+                    volume,
+                    inputBufferIndex,
+                    outputBufferIndex,
+                    0,
+                    Memory<VoiceUpdateState>.Empty,
+                    ref bqf0,
+                    bqfState[..1],
+                    bqfState.Slice(1, 1),
+                    !destination.IsBiquadFilterEnabledPrev(),
+                    false,
+                    isFirstMixBuffer,
+                    nodeId);
+
+                destination.UpdateBiquadFilterEnabledPrev(0);
+            }
+            else if (bqf1.Enable)
+            {
+                _commandBuffer.GenerateBiquadFilterAndMix(
+                    0f,
+                    volume,
+                    inputBufferIndex,
+                    outputBufferIndex,
+                    0,
+                    Memory<VoiceUpdateState>.Empty,
+                    ref bqf1,
+                    bqfState[..1],
+                    bqfState.Slice(1, 1),
+                    !destination.IsBiquadFilterEnabledPrev(),
+                    false,
+                    isFirstMixBuffer,
+                    nodeId);
+
+                destination.UpdateBiquadFilterEnabledPrev(1);
+            }
+
+            isFirstMixBuffer = false;
+        }
+
         private void GenerateMix(ref MixState mix)
         {
             if (mix.HasAnyDestination())
@@ -722,15 +944,13 @@ namespace Ryujinx.Audio.Renderer.Server
                         {
                             int destinationIndex = destinationId++;
 
-                            Span<SplitterDestination> destinationSpan = _splitterContext.GetDestination((int)mix.DestinationSplitterId, destinationIndex);
+                            SplitterDestination destination = _splitterContext.GetDestination((int)mix.DestinationSplitterId, destinationIndex);
 
-                            if (destinationSpan.IsEmpty)
+                            if (destination.IsNull)
                             {
                                 break;
                             }
 
-                            ref SplitterDestination destination = ref destinationSpan[0];
-
                             if (destination.IsConfigured())
                             {
                                 int mixId = destination.DestinationId;
@@ -741,16 +961,32 @@ namespace Ryujinx.Audio.Renderer.Server
 
                                     uint inputBufferIndex = mix.BufferOffset + ((uint)destinationIndex % mix.BufferCount);
 
+                                    bool isFirstMixBuffer = true;
+
                                     for (uint bufferDestinationIndex = 0; bufferDestinationIndex < destinationMix.BufferCount; bufferDestinationIndex++)
                                     {
                                         float volume = mix.Volume * destination.GetMixVolume((int)bufferDestinationIndex);
 
                                         if (volume != 0.0f)
                                         {
-                                            _commandBuffer.GenerateMix(inputBufferIndex,
-                                                                       destinationMix.BufferOffset + bufferDestinationIndex,
-                                                                       mix.NodeId,
-                                                                       volume);
+                                            if (destination.IsBiquadFilterEnabled())
+                                            {
+                                                GenerateMixWithSplitter(
+                                                    inputBufferIndex,
+                                                    destinationMix.BufferOffset + bufferDestinationIndex,
+                                                    volume,
+                                                    destination,
+                                                    ref isFirstMixBuffer,
+                                                    mix.NodeId);
+                                            }
+                                            else
+                                            {
+                                                _commandBuffer.GenerateMix(
+                                                    inputBufferIndex,
+                                                    destinationMix.BufferOffset + bufferDestinationIndex,
+                                                    mix.NodeId,
+                                                    volume);
+                                            }
                                         }
                                     }
                                 }
@@ -770,10 +1006,11 @@ namespace Ryujinx.Audio.Renderer.Server
 
                             if (volume != 0.0f)
                             {
-                                _commandBuffer.GenerateMix(mix.BufferOffset + bufferIndex,
-                                                           destinationMix.BufferOffset + bufferDestinationIndex,
-                                                           mix.NodeId,
-                                                           volume);
+                                _commandBuffer.GenerateMix(
+                                    mix.BufferOffset + bufferIndex,
+                                    destinationMix.BufferOffset + bufferDestinationIndex,
+                                    mix.NodeId,
+                                    volume);
                             }
                         }
                     }
@@ -783,11 +1020,12 @@ namespace Ryujinx.Audio.Renderer.Server
 
         private void GenerateSubMix(ref MixState subMix)
         {
-            _commandBuffer.GenerateDepopForMixBuffersCommand(_rendererContext.DepopBuffer,
-                                                             subMix.BufferOffset,
-                                                             subMix.BufferCount,
-                                                             subMix.NodeId,
-                                                             subMix.SampleRate);
+            _commandBuffer.GenerateDepopForMixBuffers(
+                _rendererContext.DepopBuffer,
+                subMix.BufferOffset,
+                subMix.BufferCount,
+                subMix.NodeId,
+                subMix.SampleRate);
 
             GenerateEffects(ref subMix);
 
@@ -847,11 +1085,12 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             ref MixState finalMix = ref _mixContext.GetFinalState();
 
-            _commandBuffer.GenerateDepopForMixBuffersCommand(_rendererContext.DepopBuffer,
-                                                             finalMix.BufferOffset,
-                                                             finalMix.BufferCount,
-                                                             finalMix.NodeId,
-                                                             finalMix.SampleRate);
+            _commandBuffer.GenerateDepopForMixBuffers(
+                _rendererContext.DepopBuffer,
+                finalMix.BufferOffset,
+                finalMix.BufferCount,
+                finalMix.NodeId,
+                finalMix.SampleRate);
 
             GenerateEffects(ref finalMix);
 
@@ -882,9 +1121,10 @@ namespace Ryujinx.Audio.Renderer.Server
                         GeneratePerformance(ref performanceEntry, PerformanceCommand.Type.Start, nodeId);
                     }
 
-                    _commandBuffer.GenerateVolume(finalMix.Volume,
-                                                  finalMix.BufferOffset + bufferIndex,
-                                                  nodeId);
+                    _commandBuffer.GenerateVolume(
+                        finalMix.Volume,
+                        finalMix.BufferOffset + bufferIndex,
+                        nodeId);
 
                     if (performanceSubInitialized)
                     {
@@ -938,41 +1178,45 @@ namespace Ryujinx.Audio.Renderer.Server
 
             if (useCustomDownMixingCommand)
             {
-                _commandBuffer.GenerateDownMixSurroundToStereo(finalMix.BufferOffset,
-                                                               sink.Parameter.Input.AsSpan(),
-                                                               sink.Parameter.Input.AsSpan(),
-                                                               sink.DownMixCoefficients,
-                                                               Constants.InvalidNodeId);
+                _commandBuffer.GenerateDownMixSurroundToStereo(
+                    finalMix.BufferOffset,
+                    sink.Parameter.Input.AsSpan(),
+                    sink.Parameter.Input.AsSpan(),
+                    sink.DownMixCoefficients,
+                    Constants.InvalidNodeId);
             }
             // NOTE: We do the downmixing at the DSP level as it's easier that way.
             else if (_rendererContext.ChannelCount == 2 && sink.Parameter.InputCount == 6)
             {
-                _commandBuffer.GenerateDownMixSurroundToStereo(finalMix.BufferOffset,
-                                                               sink.Parameter.Input.AsSpan(),
-                                                               sink.Parameter.Input.AsSpan(),
-                                                               Constants.DefaultSurroundToStereoCoefficients,
-                                                               Constants.InvalidNodeId);
+                _commandBuffer.GenerateDownMixSurroundToStereo(
+                    finalMix.BufferOffset,
+                    sink.Parameter.Input.AsSpan(),
+                    sink.Parameter.Input.AsSpan(),
+                    Constants.DefaultSurroundToStereoCoefficients,
+                    Constants.InvalidNodeId);
             }
 
             CommandList commandList = _commandBuffer.CommandList;
 
             if (sink.UpsamplerState != null)
             {
-                _commandBuffer.GenerateUpsample(finalMix.BufferOffset,
-                                                sink.UpsamplerState,
-                                                sink.Parameter.InputCount,
-                                                sink.Parameter.Input.AsSpan(),
-                                                commandList.BufferCount,
-                                                commandList.SampleCount,
-                                                commandList.SampleRate,
-                                                Constants.InvalidNodeId);
+                _commandBuffer.GenerateUpsample(
+                    finalMix.BufferOffset,
+                    sink.UpsamplerState,
+                    sink.Parameter.InputCount,
+                    sink.Parameter.Input.AsSpan(),
+                    commandList.BufferCount,
+                    commandList.SampleCount,
+                    commandList.SampleRate,
+                    Constants.InvalidNodeId);
             }
 
-            _commandBuffer.GenerateDeviceSink(finalMix.BufferOffset,
-                                              sink,
-                                              _rendererContext.SessionId,
-                                              commandList.Buffers,
-                                              Constants.InvalidNodeId);
+            _commandBuffer.GenerateDeviceSink(
+                finalMix.BufferOffset,
+                sink,
+                _rendererContext.SessionId,
+                commandList.Buffers,
+                Constants.InvalidNodeId);
         }
 
         private void GenerateSink(BaseSink sink, ref MixState finalMix)

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

@@ -170,7 +170,7 @@ namespace Ryujinx.Audio.Renderer.Server
             return 0;
         }
 
-        public uint Estimate(GroupedBiquadFilterCommand command)
+        public uint Estimate(MultiTapBiquadFilterCommand command)
         {
             return 0;
         }
@@ -184,5 +184,15 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(BiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
+
+        public uint Estimate(MultiTapBiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
     }
 }

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

@@ -462,7 +462,7 @@ namespace Ryujinx.Audio.Renderer.Server
             return 0;
         }
 
-        public uint Estimate(GroupedBiquadFilterCommand command)
+        public uint Estimate(MultiTapBiquadFilterCommand command)
         {
             return 0;
         }
@@ -476,5 +476,15 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(BiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
+
+        public uint Estimate(MultiTapBiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
     }
 }

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

@@ -632,7 +632,7 @@ namespace Ryujinx.Audio.Renderer.Server
             };
         }
 
-        public virtual uint Estimate(GroupedBiquadFilterCommand command)
+        public virtual uint Estimate(MultiTapBiquadFilterCommand command)
         {
             return 0;
         }
@@ -646,5 +646,15 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public virtual uint Estimate(BiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
+
+        public virtual uint Estimate(MultiTapBiquadFilterAndMixCommand command)
+        {
+            return 0;
+        }
     }
 }

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

@@ -10,7 +10,7 @@ namespace Ryujinx.Audio.Renderer.Server
     {
         public CommandProcessingTimeEstimatorVersion4(uint sampleCount, uint bufferCount) : base(sampleCount, bufferCount) { }
 
-        public override uint Estimate(GroupedBiquadFilterCommand command)
+        public override uint Estimate(MultiTapBiquadFilterCommand command)
         {
             Debug.Assert(SampleCount == 160 || SampleCount == 240);
 

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

@@ -169,14 +169,28 @@ namespace Ryujinx.Audio.Renderer.Server
             {
                 if (command.Enabled)
                 {
-                    return command.Parameter.ChannelCount switch
+                    if (command.Parameter.StatisticsEnabled)
                     {
-                        1 => 34431,
-                        2 => 44253,
-                        4 => 63827,
-                        6 => 83361,
-                        _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
-                    };
+                        return command.Parameter.ChannelCount switch
+                        {
+                            1 => 22100,
+                            2 => 33211,
+                            4 => 41587,
+                            6 => 58819,
+                            _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
+                        };
+                    }
+                    else
+                    {
+                        return command.Parameter.ChannelCount switch
+                        {
+                            1 => 19052,
+                            2 => 29852,
+                            4 => 37904,
+                            6 => 55020,
+                            _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
+                        };
+                    }
                 }
 
                 return command.Parameter.ChannelCount switch
@@ -191,14 +205,28 @@ namespace Ryujinx.Audio.Renderer.Server
 
             if (command.Enabled)
             {
-                return command.Parameter.ChannelCount switch
+                if (command.Parameter.StatisticsEnabled)
                 {
-                    1 => 51095,
-                    2 => 65693,
-                    4 => 95383,
-                    6 => 124510,
-                    _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
-                };
+                    return command.Parameter.ChannelCount switch
+                    {
+                        1 => 32518,
+                        2 => 49102,
+                        4 => 61685,
+                        6 => 87250,
+                        _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
+                    };
+                }
+                else
+                {
+                    return command.Parameter.ChannelCount switch
+                    {
+                        1 => 27963,
+                        2 => 44016,
+                        4 => 56183,
+                        6 => 81862,
+                        _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
+                    };
+                }
             }
 
             return command.Parameter.ChannelCount switch
@@ -210,5 +238,53 @@ namespace Ryujinx.Audio.Renderer.Server
                 _ => throw new NotImplementedException($"{command.Parameter.ChannelCount}"),
             };
         }
+
+        public override uint Estimate(BiquadFilterAndMixCommand command)
+        {
+            Debug.Assert(SampleCount == 160 || SampleCount == 240);
+
+            if (command.HasVolumeRamp)
+            {
+                if (SampleCount == 160)
+                {
+                    return 5204;
+                }
+
+                return 6683;
+            }
+            else
+            {
+                if (SampleCount == 160)
+                {
+                    return 3427;
+                }
+
+                return 4752;
+            }
+        }
+
+        public override uint Estimate(MultiTapBiquadFilterAndMixCommand command)
+        {
+            Debug.Assert(SampleCount == 160 || SampleCount == 240);
+
+            if (command.HasVolumeRamp)
+            {
+                if (SampleCount == 160)
+                {
+                    return 7939;
+                }
+
+                return 10669;
+            }
+            else
+            {
+                if (SampleCount == 160)
+                {
+                    return 6256;
+                }
+
+                return 8683;
+            }
+        }
     }
 }

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

@@ -33,21 +33,21 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return WorkBuffers[index].GetReference(true);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = MemoryMarshal.Cast<byte, AuxiliaryBufferParameter>(parameter.SpecificData)[0];
             IsEnabled = parameter.IsEnabled;

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

@@ -81,7 +81,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
         /// <returns>Returns true if the <see cref="EffectType"/> sent by the user matches the internal <see cref="EffectType"/>.</returns>
-        public bool IsTypeValid<T>(ref T parameter) where T : unmanaged, IEffectInParameter
+        public bool IsTypeValid<T>(in T parameter) where T : unmanaged, IEffectInParameter
         {
             return parameter.Type == TargetEffectType;
         }
@@ -98,7 +98,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// Update the internal common parameters from a user parameter.
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
-        protected void UpdateParameterBase<T>(ref T parameter) where T : unmanaged, IEffectInParameter
+        protected void UpdateParameterBase<T>(in T parameter) where T : unmanaged, IEffectInParameter
         {
             MixId = parameter.MixId;
             ProcessingOrder = parameter.ProcessingOrder;
@@ -139,7 +139,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// <summary>
         /// Initialize the given <paramref name="state"/> result state.
         /// </summary>
-        /// <param name="state">The state to initalize</param>
+        /// <param name="state">The state to initialize</param>
         public virtual void InitializeResultState(ref EffectResultState state) { }
 
         /// <summary>
@@ -155,9 +155,9 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// <param name="updateErrorInfo">The possible <see cref="ErrorInfo"/> that was generated.</param>
         /// <param name="parameter">The user parameter.</param>
         /// <param name="mapper">The mapper to use.</param>
-        public virtual void Update(out ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public virtual void Update(out ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             updateErrorInfo = new ErrorInfo();
         }
@@ -168,9 +168,9 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
         /// <param name="updateErrorInfo">The possible <see cref="ErrorInfo"/> that was generated.</param>
         /// <param name="parameter">The user parameter.</param>
         /// <param name="mapper">The mapper to use.</param>
-        public virtual void Update(out ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public virtual void Update(out ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             updateErrorInfo = new ErrorInfo();
         }

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

@@ -35,21 +35,21 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
         public override EffectType TargetEffectType => EffectType.BiquadFilter;
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = MemoryMarshal.Cast<byte, BiquadFilterEffectParameter>(parameter.SpecificData)[0];
             IsEnabled = parameter.IsEnabled;

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

@@ -19,21 +19,21 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
         public override EffectType TargetEffectType => EffectType.BufferMix;
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = MemoryMarshal.Cast<byte, BufferMixParameter>(parameter.SpecificData)[0];
             IsEnabled = parameter.IsEnabled;

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

@@ -32,21 +32,21 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return WorkBuffers[index].GetReference(true);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = MemoryMarshal.Cast<byte, AuxiliaryBufferParameter>(parameter.SpecificData)[0];
             IsEnabled = parameter.IsEnabled;

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

@@ -39,17 +39,17 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return GetSingleBuffer();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
             // Nintendo doesn't do anything here but we still require updateErrorInfo to be initialised.
             updateErrorInfo = new BehaviourParameter.ErrorInfo();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = MemoryMarshal.Cast<byte, CompressorParameter>(parameter.SpecificData)[0];
             IsEnabled = parameter.IsEnabled;
@@ -62,6 +62,19 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             UpdateUsageStateForCommandGeneration();
 
             Parameter.Status = UsageState.Enabled;
+            Parameter.StatisticsReset = false;
+        }
+
+        public override void InitializeResultState(ref EffectResultState state)
+        {
+            ref CompressorStatistics statistics = ref MemoryMarshal.Cast<byte, CompressorStatistics>(state.SpecificData)[0];
+
+            statistics.Reset(Parameter.ChannelCount);
+        }
+
+        public override void UpdateResultState(ref EffectResultState destState, ref EffectResultState srcState)
+        {
+            destState = srcState;
         }
     }
 }

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

@@ -37,19 +37,19 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return GetSingleBuffer();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref DelayParameter delayParameter = ref MemoryMarshal.Cast<byte, DelayParameter>(parameter.SpecificData)[0];
 
@@ -57,7 +57,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
             if (delayParameter.IsChannelCountMaxValid())
             {
-                UpdateParameterBase(ref parameter);
+                UpdateParameterBase(in parameter);
 
                 UsageState oldParameterStatus = Parameter.Status;
 

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

@@ -39,25 +39,25 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return GetSingleBuffer();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref LimiterParameter limiterParameter = ref MemoryMarshal.Cast<byte, LimiterParameter>(parameter.SpecificData)[0];
 
             updateErrorInfo = new BehaviourParameter.ErrorInfo();
 
-            UpdateParameterBase(ref parameter);
+            UpdateParameterBase(in parameter);
 
             Parameter = limiterParameter;
 

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

@@ -36,19 +36,19 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return GetSingleBuffer();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref Reverb3dParameter reverbParameter = ref MemoryMarshal.Cast<byte, Reverb3dParameter>(parameter.SpecificData)[0];
 
@@ -56,7 +56,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
             if (reverbParameter.IsChannelCountMaxValid())
             {
-                UpdateParameterBase(ref parameter);
+                UpdateParameterBase(in parameter);
 
                 UsageState oldParameterStatus = Parameter.ParameterStatus;
 

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

@@ -39,19 +39,19 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
             return GetSingleBuffer();
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion1 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, in EffectInParameterVersion2 parameter, PoolMapper mapper)
         {
-            Update(out updateErrorInfo, ref parameter, mapper);
+            Update(out updateErrorInfo, in parameter, mapper);
         }
 
-        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        public void Update<T>(out BehaviourParameter.ErrorInfo updateErrorInfo, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref ReverbParameter reverbParameter = ref MemoryMarshal.Cast<byte, ReverbParameter>(parameter.SpecificData)[0];
 
@@ -59,7 +59,7 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
 
             if (reverbParameter.IsChannelCountMaxValid())
             {
-                UpdateParameterBase(ref parameter);
+                UpdateParameterBase(in parameter);
 
                 UsageState oldParameterStatus = Parameter.Status;
 

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

@@ -33,8 +33,10 @@ namespace Ryujinx.Audio.Renderer.Server
         uint Estimate(UpsampleCommand command);
         uint Estimate(LimiterCommandVersion1 command);
         uint Estimate(LimiterCommandVersion2 command);
-        uint Estimate(GroupedBiquadFilterCommand command);
+        uint Estimate(MultiTapBiquadFilterCommand command);
         uint Estimate(CaptureBufferCommand command);
         uint Estimate(CompressorCommand command);
+        uint Estimate(BiquadFilterAndMixCommand command);
+        uint Estimate(MultiTapBiquadFilterAndMixCommand command);
     }
 }

src/Ryujinx.Audio/Renderer/Server/MemoryPool/PoolMapper.cs

@@ -249,7 +249,7 @@ namespace Ryujinx.Audio.Renderer.Server.MemoryPool
         /// <param name="inParameter">Input user parameter.</param>
         /// <param name="outStatus">Output user parameter.</param>
         /// <returns>Returns the <see cref="UpdateResult"/> of the operations performed.</returns>
-        public UpdateResult Update(ref MemoryPoolState memoryPool, ref MemoryPoolInParameter inParameter, ref MemoryPoolOutStatus outStatus)
+        public UpdateResult Update(ref MemoryPoolState memoryPool, in MemoryPoolInParameter inParameter, ref MemoryPoolOutStatus outStatus)
         {
             MemoryPoolUserState inputState = inParameter.State;
 

src/Ryujinx.Audio/Renderer/Server/Mix/MixState.cs

@@ -195,7 +195,7 @@ namespace Ryujinx.Audio.Renderer.Server.Mix
         /// <param name="parameter">The input parameter of the mix.</param>
         /// <param name="splitterContext">The splitter context.</param>
         /// <returns>Return true, new connections were done on the adjacency matrix.</returns>
-        private bool UpdateConnection(EdgeMatrix edgeMatrix, ref MixParameter parameter, ref SplitterContext splitterContext)
+        private bool UpdateConnection(EdgeMatrix edgeMatrix, in MixParameter parameter, ref SplitterContext splitterContext)
         {
             bool hasNewConnections;
 
@@ -225,11 +225,11 @@ namespace Ryujinx.Audio.Renderer.Server.Mix
 
                     for (int i = 0; i < splitter.DestinationCount; i++)
                     {
-                        Span<SplitterDestination> destination = splitter.GetData(i);
+                        SplitterDestination destination = splitter.GetData(i);
 
-                        if (!destination.IsEmpty)
+                        if (!destination.IsNull)
                         {
-                            int destinationMixId = destination[0].DestinationId;
+                            int destinationMixId = destination.DestinationId;
 
                             if (destinationMixId != UnusedMixId)
                             {
@@ -259,7 +259,7 @@ namespace Ryujinx.Audio.Renderer.Server.Mix
         /// <param name="splitterContext">The splitter context.</param>
         /// <param name="behaviourContext">The behaviour context.</param>
         /// <returns>Return true if the mix was changed.</returns>
-        public bool Update(EdgeMatrix edgeMatrix, ref MixParameter parameter, EffectContext effectContext, SplitterContext splitterContext, BehaviourContext behaviourContext)
+        public bool Update(EdgeMatrix edgeMatrix, in MixParameter parameter, EffectContext effectContext, SplitterContext splitterContext, BehaviourContext behaviourContext)
         {
             bool isDirty;
 
@@ -273,7 +273,7 @@ namespace Ryujinx.Audio.Renderer.Server.Mix
 
             if (behaviourContext.IsSplitterSupported())
             {
-                isDirty = UpdateConnection(edgeMatrix, ref parameter, ref splitterContext);
+                isDirty = UpdateConnection(edgeMatrix, in parameter, ref splitterContext);
             }
             else
             {

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

@@ -18,16 +18,12 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
 
             if (version == 2)
             {
-                return (ulong)PerformanceManagerGeneric<PerformanceFrameHeaderVersion2,
-                                                 PerformanceEntryVersion2,
-                                                 PerformanceDetailVersion2>.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter);
+                return (ulong)PerformanceManagerGeneric<PerformanceFrameHeaderVersion2, PerformanceEntryVersion2, PerformanceDetailVersion2>.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter);
             }
 
             if (version == 1)
             {
-                return (ulong)PerformanceManagerGeneric<PerformanceFrameHeaderVersion1,
-                    PerformanceEntryVersion1,
-                    PerformanceDetailVersion1>.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter);
+                return (ulong)PerformanceManagerGeneric<PerformanceFrameHeaderVersion1, PerformanceEntryVersion1, PerformanceDetailVersion1>.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter);
             }
 
             throw new NotImplementedException($"Unknown Performance metrics data format version {version}");

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

@@ -234,7 +234,7 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
         {
             performanceEntry = null;
 
-            if (_entryDetailIndex > MaxFrameDetailCount)
+            if (_entryDetailIndex >= MaxFrameDetailCount)
             {
                 return false;
             }
@@ -245,7 +245,7 @@ namespace Ryujinx.Audio.Renderer.Server.Performance
                 EntryCountOffset = (uint)CurrentHeader.GetEntryCountOffset(),
             };
 
-            uint baseEntryOffset = (uint)(Unsafe.SizeOf<THeader>() + GetEntriesSize() + Unsafe.SizeOf<IPerformanceDetailEntry>() * _entryDetailIndex);
+            uint baseEntryOffset = (uint)(Unsafe.SizeOf<THeader>() + GetEntriesSize() + Unsafe.SizeOf<TEntryDetail>() * _entryDetailIndex);
 
             ref TEntryDetail entryDetail = ref EntriesDetail[_entryDetailIndex];
 

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

@@ -59,7 +59,7 @@ namespace Ryujinx.Audio.Renderer.Server.Sink
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
         /// <returns>Return true, if the <see cref="SinkType"/> sent by the user match the internal <see cref="SinkType"/>.</returns>
-        public bool IsTypeValid(ref SinkInParameter parameter)
+        public bool IsTypeValid(in SinkInParameter parameter)
         {
             return parameter.Type == TargetSinkType;
         }
@@ -76,7 +76,7 @@ namespace Ryujinx.Audio.Renderer.Server.Sink
         /// Update the internal common parameters from user parameter.
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
-        protected void UpdateStandardParameter(ref SinkInParameter parameter)
+        protected void UpdateStandardParameter(in SinkInParameter parameter)
         {
             if (IsUsed != parameter.IsUsed)
             {
@@ -92,9 +92,9 @@ namespace Ryujinx.Audio.Renderer.Server.Sink
         /// <param name="parameter">The user parameter.</param>
         /// <param name="outStatus">The user output status.</param>
         /// <param name="mapper">The mapper to use.</param>
-        public virtual void Update(out ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        public virtual void Update(out ErrorInfo errorInfo, in SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             errorInfo = new ErrorInfo();
         }

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

@@ -44,18 +44,18 @@ namespace Ryujinx.Audio.Renderer.Server.Sink
 
         public override SinkType TargetSinkType => SinkType.CircularBuffer;
 
-        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, in SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
         {
             errorInfo = new BehaviourParameter.ErrorInfo();
             outStatus = new SinkOutStatus();
 
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref CircularBufferParameter inputDeviceParameter = ref MemoryMarshal.Cast<byte, CircularBufferParameter>(parameter.SpecificData)[0];
 
             if (parameter.IsUsed != IsUsed || ShouldSkip)
             {
-                UpdateStandardParameter(ref parameter);
+                UpdateStandardParameter(in parameter);
 
                 if (parameter.IsUsed)
                 {

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

@@ -49,15 +49,15 @@ namespace Ryujinx.Audio.Renderer.Server.Sink
 
         public override SinkType TargetSinkType => SinkType.Device;
 
-        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, ref SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
+        public override void Update(out BehaviourParameter.ErrorInfo errorInfo, in SinkInParameter parameter, ref SinkOutStatus outStatus, PoolMapper mapper)
         {
-            Debug.Assert(IsTypeValid(ref parameter));
+            Debug.Assert(IsTypeValid(in parameter));
 
             ref DeviceParameter inputDeviceParameter = ref MemoryMarshal.Cast<byte, DeviceParameter>(parameter.SpecificData)[0];
 
             if (parameter.IsUsed != IsUsed)
             {
-                UpdateStandardParameter(ref parameter);
+                UpdateStandardParameter(in parameter);
                 Parameter = inputDeviceParameter;
             }
             else

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

@@ -1,11 +1,13 @@
 using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
 using Ryujinx.Audio.Renderer.Parameter;
 using Ryujinx.Audio.Renderer.Utils;
 using Ryujinx.Common;
+using Ryujinx.Common.Extensions;
 using System;
+using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 
 namespace Ryujinx.Audio.Renderer.Server.Splitter
 {
@@ -14,33 +16,63 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
     /// </summary>
     public class SplitterContext
     {
+        /// <summary>
+        /// Amount of biquad filter states per splitter destination.
+        /// </summary>
+        public const int BqfStatesPerDestination = 4;
+
         /// <summary>
         /// Storage for <see cref="SplitterState"/>.
         /// </summary>
         private Memory<SplitterState> _splitters;
 
         /// <summary>
-        /// Storage for <see cref="SplitterDestination"/>.
+        /// Storage for <see cref="SplitterDestinationVersion1"/>.
         /// </summary>
-        private Memory<SplitterDestination> _splitterDestinations;
+        private Memory<SplitterDestinationVersion1> _splitterDestinationsV1;
 
         /// <summary>
-        /// If set to true, trust the user destination count in <see cref="SplitterState.Update(SplitterContext, ref SplitterInParameter, ReadOnlySpan{byte})"/>.
+        /// Storage for <see cref="SplitterDestinationVersion2"/>.
+        /// </summary>
+        private Memory<SplitterDestinationVersion2> _splitterDestinationsV2;
+
+        /// <summary>
+        /// Splitter biquad filtering states.
+        /// </summary>
+        private Memory<BiquadFilterState> _splitterBqfStates;
+
+        /// <summary>
+        /// Version of the splitter context that is being used, currently can be 1 or 2.
+        /// </summary>
+        public int Version { get; private set; }
+
+        /// <summary>
+        /// If set to true, trust the user destination count in <see cref="SplitterState.Update(SplitterContext, in SplitterInParameter, ref SequenceReader{byte})"/>.
         /// </summary>
         public bool IsBugFixed { get; private set; }
 
+        /// <summary>
+        /// If set to true, the previous mix volume is explicitly resetted using the input parameter, instead of implicitly on first use.
+        /// </summary>
+        public bool IsSplitterPrevVolumeResetSupported { get; private set; }
+
         /// <summary>
         /// Initialize <see cref="SplitterContext"/>.
         /// </summary>
         /// <param name="behaviourContext">The behaviour context.</param>
         /// <param name="parameter">The audio renderer configuration.</param>
         /// <param name="workBufferAllocator">The <see cref="WorkBufferAllocator"/>.</param>
+        /// <param name="splitterBqfStates">Memory to store the biquad filtering state for splitters during processing.</param>
         /// <returns>Return true if the initialization was successful.</returns>
-        public bool Initialize(ref BehaviourContext behaviourContext, ref AudioRendererConfiguration parameter, WorkBufferAllocator workBufferAllocator)
+        public bool Initialize(
+            ref BehaviourContext behaviourContext,
+            ref AudioRendererConfiguration parameter,
+            WorkBufferAllocator workBufferAllocator,
+            Memory<BiquadFilterState> splitterBqfStates)
         {
             if (!behaviourContext.IsSplitterSupported() || parameter.SplitterCount <= 0 || parameter.SplitterDestinationCount <= 0)
             {
-                Setup(Memory<SplitterState>.Empty, Memory<SplitterDestination>.Empty, false);
+                Setup(Memory<SplitterState>.Empty, Memory<SplitterDestinationVersion1>.Empty, Memory<SplitterDestinationVersion2>.Empty, false);
 
                 return true;
             }
@@ -59,23 +91,64 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
                 splitter = new SplitterState(splitterId++);
             }
 
-            Memory<SplitterDestination> splitterDestinations = workBufferAllocator.Allocate<SplitterDestination>(parameter.SplitterDestinationCount,
-                SplitterDestination.Alignment);
+            Memory<SplitterDestinationVersion1> splitterDestinationsV1 = Memory<SplitterDestinationVersion1>.Empty;
+            Memory<SplitterDestinationVersion2> splitterDestinationsV2 = Memory<SplitterDestinationVersion2>.Empty;
 
-            if (splitterDestinations.IsEmpty)
+            if (!behaviourContext.IsBiquadFilterParameterForSplitterEnabled())
             {
-                return false;
+                Version = 1;
+
+                splitterDestinationsV1 = workBufferAllocator.Allocate<SplitterDestinationVersion1>(parameter.SplitterDestinationCount,
+                    SplitterDestinationVersion1.Alignment);
+
+                if (splitterDestinationsV1.IsEmpty)
+                {
+                    return false;
+                }
+
+                int splitterDestinationId = 0;
+                foreach (ref SplitterDestinationVersion1 data in splitterDestinationsV1.Span)
+                {
+                    data = new SplitterDestinationVersion1(splitterDestinationId++);
+                }
+            }
+            else
+            {
+                Version = 2;
+
+                splitterDestinationsV2 = workBufferAllocator.Allocate<SplitterDestinationVersion2>(parameter.SplitterDestinationCount,
+                    SplitterDestinationVersion2.Alignment);
+
+                if (splitterDestinationsV2.IsEmpty)
+                {
+                    return false;
+                }
+
+                int splitterDestinationId = 0;
+                foreach (ref SplitterDestinationVersion2 data in splitterDestinationsV2.Span)
+                {
+                    data = new SplitterDestinationVersion2(splitterDestinationId++);
+                }
+
+                if (parameter.SplitterDestinationCount > 0)
+                {
+                    // Official code stores it in the SplitterDestinationVersion2 struct,
+                    // but we don't to avoid using unsafe code.
+
+                    splitterBqfStates.Span.Clear();
+                    _splitterBqfStates = splitterBqfStates;
+                }
+                else
+                {
+                    _splitterBqfStates = Memory<BiquadFilterState>.Empty;
+                }
             }
 
-            int splitterDestinationId = 0;
-            foreach (ref SplitterDestination data in splitterDestinations.Span)
-            {
-                data = new SplitterDestination(splitterDestinationId++);
-            }
+            IsSplitterPrevVolumeResetSupported = behaviourContext.IsSplitterPrevVolumeResetSupported();
 
             SplitterState.InitializeSplitters(splitters.Span);
 
-            Setup(splitters, splitterDestinations, behaviourContext.IsSplitterBugFixed());
+            Setup(splitters, splitterDestinationsV1, splitterDestinationsV2, behaviourContext.IsSplitterBugFixed());
 
             return true;
         }
@@ -92,7 +165,15 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
             if (behaviourContext.IsSplitterSupported())
             {
                 size = WorkBufferAllocator.GetTargetSize<SplitterState>(size, parameter.SplitterCount, SplitterState.Alignment);
-                size = WorkBufferAllocator.GetTargetSize<SplitterDestination>(size, parameter.SplitterDestinationCount, SplitterDestination.Alignment);
+
+                if (behaviourContext.IsBiquadFilterParameterForSplitterEnabled())
+                {
+                    size = WorkBufferAllocator.GetTargetSize<SplitterDestinationVersion2>(size, parameter.SplitterDestinationCount, SplitterDestinationVersion2.Alignment);
+                }
+                else
+                {
+                    size = WorkBufferAllocator.GetTargetSize<SplitterDestinationVersion1>(size, parameter.SplitterDestinationCount, SplitterDestinationVersion1.Alignment);
+                }
 
                 if (behaviourContext.IsSplitterBugFixed())
                 {
@@ -109,12 +190,18 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// Setup the <see cref="SplitterContext"/> instance.
         /// </summary>
         /// <param name="splitters">The <see cref="SplitterState"/> storage.</param>
-        /// <param name="splitterDestinations">The <see cref="SplitterDestination"/> storage.</param>
-        /// <param name="isBugFixed">If set to true, trust the user destination count in <see cref="SplitterState.Update(SplitterContext, ref SplitterInParameter, ReadOnlySpan{byte})"/>.</param>
-        private void Setup(Memory<SplitterState> splitters, Memory<SplitterDestination> splitterDestinations, bool isBugFixed)
+        /// <param name="splitterDestinationsV1">The <see cref="SplitterDestinationVersion1"/> storage.</param>
+        /// <param name="splitterDestinationsV2">The <see cref="SplitterDestinationVersion2"/> storage.</param>
+        /// <param name="isBugFixed">If set to true, trust the user destination count in <see cref="SplitterState.Update(SplitterContext, in SplitterInParameter, ref SequenceReader{byte})"/>.</param>
+        private void Setup(
+            Memory<SplitterState> splitters,
+            Memory<SplitterDestinationVersion1> splitterDestinationsV1,
+            Memory<SplitterDestinationVersion2> splitterDestinationsV2,
+            bool isBugFixed)
         {
             _splitters = splitters;
-            _splitterDestinations = splitterDestinations;
+            _splitterDestinationsV1 = splitterDestinationsV1;
+            _splitterDestinationsV2 = splitterDestinationsV2;
             IsBugFixed = isBugFixed;
         }
 
@@ -140,7 +227,9 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
                 return 0;
             }
 
-            return _splitterDestinations.Length / _splitters.Length;
+            int length = _splitterDestinationsV2.IsEmpty ? _splitterDestinationsV1.Length : _splitterDestinationsV2.Length;
+
+            return length / _splitters.Length;
         }
 
         /// <summary>
@@ -148,11 +237,11 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         /// <param name="inputHeader">The splitter header.</param>
         /// <param name="input">The raw data after the splitter header.</param>
-        private void UpdateState(scoped ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
+        private void UpdateState(in SplitterInParameterHeader inputHeader, ref SequenceReader<byte> input)
         {
             for (int i = 0; i < inputHeader.SplitterCount; i++)
             {
-                SplitterInParameter parameter = MemoryMarshal.Read<SplitterInParameter>(input);
+                ref readonly SplitterInParameter parameter = ref input.GetRefOrRefToCopy<SplitterInParameter>(out _);
 
                 Debug.Assert(parameter.IsMagicValid());
 
@@ -162,37 +251,78 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
                     {
                         ref SplitterState splitter = ref GetState(parameter.Id);
 
-                        splitter.Update(this, ref parameter, input[Unsafe.SizeOf<SplitterInParameter>()..]);
+                        splitter.Update(this, in parameter, ref input);
                     }
 
-                    input = input[(0x1C + parameter.DestinationCount * 4)..];
+                    // NOTE: there are 12 bytes of unused/unknown data after the destination IDs array.
+                    input.Advance(0xC);
+                }
+                else
+                {
+                    input.Rewind(Unsafe.SizeOf<SplitterInParameter>());
+                    break;
                 }
             }
         }
 
         /// <summary>
-        /// Update one or multiple <see cref="SplitterDestination"/> from user parameters.
+        /// Update one splitter destination data from user parameters.
+        /// </summary>
+        /// <param name="input">The raw data after the splitter header.</param>
+        /// <returns>True if the update was successful, false otherwise</returns>
+        private bool UpdateData<T>(ref SequenceReader<byte> input) where T : unmanaged, ISplitterDestinationInParameter
+        {
+            ref readonly T parameter = ref input.GetRefOrRefToCopy<T>(out _);
+
+            Debug.Assert(parameter.IsMagicValid());
+
+            if (parameter.IsMagicValid())
+            {
+                int length = _splitterDestinationsV2.IsEmpty ? _splitterDestinationsV1.Length : _splitterDestinationsV2.Length;
+
+                if (parameter.Id >= 0 && parameter.Id < length)
+                {
+                    SplitterDestination destination = GetDestination(parameter.Id);
+
+                    destination.Update(parameter, IsSplitterPrevVolumeResetSupported);
+                }
+
+                return true;
+            }
+            else
+            {
+                input.Rewind(Unsafe.SizeOf<T>());
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Update one or multiple splitter destination data from user parameters.
         /// </summary>
         /// <param name="inputHeader">The splitter header.</param>
         /// <param name="input">The raw data after the splitter header.</param>
-        private void UpdateData(scoped ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
+        private void UpdateData(in SplitterInParameterHeader inputHeader, ref SequenceReader<byte> input)
         {
             for (int i = 0; i < inputHeader.SplitterDestinationCount; i++)
             {
-                SplitterDestinationInParameter parameter = MemoryMarshal.Read<SplitterDestinationInParameter>(input);
-
-                Debug.Assert(parameter.IsMagicValid());
-
-                if (parameter.IsMagicValid())
+                if (Version == 1)
                 {
-                    if (parameter.Id >= 0 && parameter.Id < _splitterDestinations.Length)
+                    if (!UpdateData<SplitterDestinationInParameterVersion1>(ref input))
                     {
-                        ref SplitterDestination destination = ref GetDestination(parameter.Id);
-
-                        destination.Update(parameter);
+                        break;
                     }
-
-                    input = input[Unsafe.SizeOf<SplitterDestinationInParameter>()..];
+                }
+                else if (Version == 2)
+                {
+                    if (!UpdateData<SplitterDestinationInParameterVersion2>(ref input))
+                    {
+                        break;
+                    }
+                }
+                else
+                {
+                    Debug.Fail($"Invalid splitter context version {Version}.");
                 }
             }
         }
@@ -201,36 +331,33 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// Update splitter from user parameters.
         /// </summary>
         /// <param name="input">The input raw user data.</param>
-        /// <param name="consumedSize">The total consumed size.</param>
         /// <returns>Return true if the update was successful.</returns>
-        public bool Update(ReadOnlySpan<byte> input, out int consumedSize)
+        public bool Update(ref SequenceReader<byte> input)
         {
-            if (_splitterDestinations.IsEmpty || _splitters.IsEmpty)
+            if (!UsingSplitter())
             {
-                consumedSize = 0;
-
                 return true;
             }
 
-            int originalSize = input.Length;
-
-            SplitterInParameterHeader header = SpanIOHelper.Read<SplitterInParameterHeader>(ref input);
+            ref readonly SplitterInParameterHeader header = ref input.GetRefOrRefToCopy<SplitterInParameterHeader>(out _);
 
             if (header.IsMagicValid())
             {
                 ClearAllNewConnectionFlag();
 
-                UpdateState(ref header, ref input);
-                UpdateData(ref header, ref input);
+                UpdateState(in header, ref input);
+                UpdateData(in header, ref input);
 
-                consumedSize = BitUtils.AlignUp(originalSize - input.Length, 0x10);
+                input.SetConsumed(BitUtils.AlignUp(input.Consumed, 0x10));
 
                 return true;
             }
+            else
+            {
+                input.Rewind(Unsafe.SizeOf<SplitterInParameterHeader>());
 
-            consumedSize = 0;
-
-            return false;
+                return false;
+            }
         }
 
         /// <summary>
@@ -244,45 +371,52 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         }
 
         /// <summary>
-        /// Get a reference to a <see cref="SplitterDestination"/> at the given <paramref name="id"/>.
+        /// Get a reference to the splitter destination data at the given <paramref name="id"/>.
         /// </summary>
         /// <param name="id">The index to use.</param>
-        /// <returns>A reference to a <see cref="SplitterDestination"/> at the given <paramref name="id"/>.</returns>
-        public ref SplitterDestination GetDestination(int id)
+        /// <returns>A reference to the splitter destination data at the given <paramref name="id"/>.</returns>
+        public SplitterDestination GetDestination(int id)
         {
-            return ref SpanIOHelper.GetFromMemory(_splitterDestinations, id, (uint)_splitterDestinations.Length);
+            if (_splitterDestinationsV2.IsEmpty)
+            {
+                return new SplitterDestination(ref SpanIOHelper.GetFromMemory(_splitterDestinationsV1, id, (uint)_splitterDestinationsV1.Length));
+            }
+            else
+            {
+                return new SplitterDestination(ref SpanIOHelper.GetFromMemory(_splitterDestinationsV2, id, (uint)_splitterDestinationsV2.Length));
+            }
         }
 
         /// <summary>
-        /// Get a <see cref="Memory{SplitterDestination}"/> at the given <paramref name="id"/>.
-        /// </summary>
-        /// <param name="id">The index to use.</param>
-        /// <returns>A <see cref="Memory{SplitterDestination}"/> at the given <paramref name="id"/>.</returns>
-        public Memory<SplitterDestination> GetDestinationMemory(int id)
-        {
-            return SpanIOHelper.GetMemory(_splitterDestinations, id, (uint)_splitterDestinations.Length);
-        }
-
-        /// <summary>
-        /// Get a <see cref="Span{SplitterDestination}"/> in the <see cref="SplitterState"/> at <paramref name="id"/> and pass <paramref name="destinationId"/> to <see cref="SplitterState.GetData(int)"/>.
+        /// Get a <see cref="SplitterDestination"/> in the <see cref="SplitterState"/> at <paramref name="id"/> and pass <paramref name="destinationId"/> to <see cref="SplitterState.GetData(int)"/>.
         /// </summary>
         /// <param name="id">The index to use to get the <see cref="SplitterState"/>.</param>
         /// <param name="destinationId">The index of the <see cref="SplitterDestination"/>.</param>
-        /// <returns>A <see cref="Span{SplitterDestination}"/>.</returns>
-        public Span<SplitterDestination> GetDestination(int id, int destinationId)
+        /// <returns>A <see cref="SplitterDestination"/>.</returns>
+        public SplitterDestination GetDestination(int id, int destinationId)
         {
             ref SplitterState splitter = ref GetState(id);
 
             return splitter.GetData(destinationId);
         }
 
+        /// <summary>
+        /// Gets the biquad filter state for a given splitter destination.
+        /// </summary>
+        /// <param name="destination">The splitter destination.</param>
+        /// <returns>Biquad filter state for the specified destination.</returns>
+        public Memory<BiquadFilterState> GetBiquadFilterState(SplitterDestination destination)
+        {
+            return _splitterBqfStates.Slice(destination.Id * BqfStatesPerDestination, BqfStatesPerDestination);
+        }
+
         /// <summary>
         /// Return true if the audio renderer has any splitters.
         /// </summary>
         /// <returns>True if the audio renderer has any splitters.</returns>
         public bool UsingSplitter()
         {
-            return !_splitters.IsEmpty && !_splitterDestinations.IsEmpty;
+            return !_splitters.IsEmpty && (!_splitterDestinationsV1.IsEmpty || !_splitterDestinationsV2.IsEmpty);
         }
 
         /// <summary>

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

@@ -1,115 +1,199 @@
 using Ryujinx.Audio.Renderer.Parameter;
-using Ryujinx.Common.Utilities;
 using System;
 using System.Diagnostics;
-using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Audio.Renderer.Server.Splitter
 {
     /// <summary>
     /// Server state for a splitter destination.
     /// </summary>
-    [StructLayout(LayoutKind.Sequential, Size = 0xE0, Pack = Alignment)]
-    public struct SplitterDestination
+    public ref struct SplitterDestination
     {
-        public const int Alignment = 0x10;
+        private ref SplitterDestinationVersion1 _v1;
+        private ref SplitterDestinationVersion2 _v2;
 
         /// <summary>
-        /// The unique id of this <see cref="SplitterDestination"/>.
+        /// Checks if the splitter destination data reference is null.
         /// </summary>
-        public int Id;
+        public bool IsNull => Unsafe.IsNullRef(ref _v1) && Unsafe.IsNullRef(ref _v2);
 
         /// <summary>
-        /// The mix to output the result of the splitter.
+        /// The splitter unique id.
         /// </summary>
-        public int DestinationId;
-
-        /// <summary>
-        /// Mix buffer volumes storage.
-        /// </summary>
-        private MixArray _mix;
-        private MixArray _previousMix;
-
-        /// <summary>
-        /// Pointer to the next linked element.
-        /// </summary>
-        private unsafe SplitterDestination* _next;
-
-        /// <summary>
-        /// Set to true if in use.
-        /// </summary>
-        [MarshalAs(UnmanagedType.I1)]
-        public bool IsUsed;
-
-        /// <summary>
-        /// Set to true if the internal state need to be updated.
-        /// </summary>
-        [MarshalAs(UnmanagedType.I1)]
-        public bool NeedToUpdateInternalState;
-
-        [StructLayout(LayoutKind.Sequential, Size = 4 * Constants.MixBufferCountMax, Pack = 1)]
-        private struct MixArray { }
-
-        /// <summary>
-        /// Mix buffer volumes.
-        /// </summary>
-        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
-        public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mix);
-
-        /// <summary>
-        /// Previous mix buffer volumes.
-        /// </summary>
-        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
-        public Span<float> PreviousMixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _previousMix);
-
-        /// <summary>
-        /// Get the  <see cref="Span{SplitterDestination}"/> of the next element or <see cref="Span{SplitterDestination}.Empty"/> if not present.
-        /// </summary>
-        public readonly Span<SplitterDestination> Next
+        public int Id
         {
             get
             {
-                unsafe
+                if (Unsafe.IsNullRef(ref _v2))
                 {
-                    return _next != null ? new Span<SplitterDestination>(_next, 1) : Span<SplitterDestination>.Empty;
+                    if (Unsafe.IsNullRef(ref _v1))
+                    {
+                        return 0;
+                    }
+                    else
+                    {
+                        return _v1.Id;
+                    }
+                }
+                else
+                {
+                    return _v2.Id;
                 }
             }
         }
 
         /// <summary>
-        /// Create a new <see cref="SplitterDestination"/>.
+        /// The mix to output the result of the splitter.
         /// </summary>
-        /// <param name="id">The unique id of this <see cref="SplitterDestination"/>.</param>
-        public SplitterDestination(int id) : this()
+        public int DestinationId
         {
-            Id = id;
-            DestinationId = Constants.UnusedMixId;
-
-            ClearVolumes();
+            get
+            {
+                if (Unsafe.IsNullRef(ref _v2))
+                {
+                    if (Unsafe.IsNullRef(ref _v1))
+                    {
+                        return 0;
+                    }
+                    else
+                    {
+                        return _v1.DestinationId;
+                    }
+                }
+                else
+                {
+                    return _v2.DestinationId;
+                }
+            }
         }
 
         /// <summary>
-        /// Update the <see cref="SplitterDestination"/> from user parameter.
+        /// Mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> MixBufferVolume
+        {
+            get
+            {
+                if (Unsafe.IsNullRef(ref _v2))
+                {
+                    if (Unsafe.IsNullRef(ref _v1))
+                    {
+                        return Span<float>.Empty;
+                    }
+                    else
+                    {
+                        return _v1.MixBufferVolume;
+                    }
+                }
+                else
+                {
+                    return _v2.MixBufferVolume;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Previous mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> PreviousMixBufferVolume
+        {
+            get
+            {
+                if (Unsafe.IsNullRef(ref _v2))
+                {
+                    if (Unsafe.IsNullRef(ref _v1))
+                    {
+                        return Span<float>.Empty;
+                    }
+                    else
+                    {
+                        return _v1.PreviousMixBufferVolume;
+                    }
+                }
+                else
+                {
+                    return _v2.PreviousMixBufferVolume;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the <see cref="SplitterDestination"/> of the next element or null if not present.
+        /// </summary>
+        public readonly SplitterDestination Next
+        {
+            get
+            {
+                unsafe
+                {
+                    if (Unsafe.IsNullRef(ref _v2))
+                    {
+                        if (Unsafe.IsNullRef(ref _v1))
+                        {
+                            return new SplitterDestination();
+                        }
+                        else
+                        {
+                            return new SplitterDestination(ref _v1.Next);
+                        }
+                    }
+                    else
+                    {
+                        return new SplitterDestination(ref _v2.Next);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a new splitter destination wrapper for the version 1 splitter destination data.
+        /// </summary>
+        /// <param name="v1">Version 1 splitter destination data</param>
+        public SplitterDestination(ref SplitterDestinationVersion1 v1)
+        {
+            _v1 = ref v1;
+            _v2 = ref Unsafe.NullRef<SplitterDestinationVersion2>();
+        }
+
+        /// <summary>
+        /// Creates a new splitter destination wrapper for the version 2 splitter destination data.
+        /// </summary>
+        /// <param name="v2">Version 2 splitter destination data</param>
+        public SplitterDestination(ref SplitterDestinationVersion2 v2)
+        {
+
+            _v1 = ref Unsafe.NullRef<SplitterDestinationVersion1>();
+            _v2 = ref v2;
+        }
+
+        /// <summary>
+        /// Creates a new splitter destination wrapper for the splitter destination data.
+        /// </summary>
+        /// <param name="v1">Version 1 splitter destination data</param>
+        /// <param name="v2">Version 2 splitter destination data</param>
+        public unsafe SplitterDestination(SplitterDestinationVersion1* v1, SplitterDestinationVersion2* v2)
+        {
+            _v1 = ref Unsafe.AsRef<SplitterDestinationVersion1>(v1);
+            _v2 = ref Unsafe.AsRef<SplitterDestinationVersion2>(v2);
+        }
+
+        /// <summary>
+        /// Update the splitter destination data from user parameter.
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
-        public void Update(SplitterDestinationInParameter parameter)
+        /// <param name="isPrevVolumeResetSupported">Indicates that the audio renderer revision in use supports explicitly resetting the volume.</param>
+        public void Update<T>(in T parameter, bool isPrevVolumeResetSupported) where T : ISplitterDestinationInParameter
         {
-            Debug.Assert(Id == parameter.Id);
-
-            if (parameter.IsMagicValid() && Id == parameter.Id)
+            if (Unsafe.IsNullRef(ref _v2))
             {
-                DestinationId = parameter.DestinationId;
-
-                parameter.MixBufferVolume.CopyTo(MixBufferVolume);
-
-                if (!IsUsed && parameter.IsUsed)
-                {
-                    MixBufferVolume.CopyTo(PreviousMixBufferVolume);
-
-                    NeedToUpdateInternalState = false;
-                }
-
-                IsUsed = parameter.IsUsed;
+                _v1.Update(parameter, isPrevVolumeResetSupported);
+            }
+            else
+            {
+                _v2.Update(parameter, isPrevVolumeResetSupported);
             }
         }
 
@@ -118,12 +202,14 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         public void UpdateInternalState()
         {
-            if (IsUsed && NeedToUpdateInternalState)
+            if (Unsafe.IsNullRef(ref _v2))
             {
-                MixBufferVolume.CopyTo(PreviousMixBufferVolume);
+                _v1.UpdateInternalState();
+            }
+            else
+            {
+                _v2.UpdateInternalState();
             }
-
-            NeedToUpdateInternalState = false;
         }
 
         /// <summary>
@@ -131,16 +217,23 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         public void MarkAsNeedToUpdateInternalState()
         {
-            NeedToUpdateInternalState = true;
+            if (Unsafe.IsNullRef(ref _v2))
+            {
+                _v1.MarkAsNeedToUpdateInternalState();
+            }
+            else
+            {
+                _v2.MarkAsNeedToUpdateInternalState();
+            }
         }
 
         /// <summary>
-        /// Return true if the <see cref="SplitterDestination"/> is used and has a destination.
+        /// Return true if the splitter destination is used and has a destination.
         /// </summary>
-        /// <returns>True if the <see cref="SplitterDestination"/> is used and has a destination.</returns>
+        /// <returns>True if the splitter destination is used and has a destination.</returns>
         public readonly bool IsConfigured()
         {
-            return IsUsed && DestinationId != Constants.UnusedMixId;
+            return Unsafe.IsNullRef(ref _v2) ? _v1.IsConfigured() : _v2.IsConfigured();
         }
 
         /// <summary>
@@ -150,9 +243,17 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// <returns>The volume for the given destination.</returns>
         public float GetMixVolume(int destinationIndex)
         {
-            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);
+            return Unsafe.IsNullRef(ref _v2) ? _v1.GetMixVolume(destinationIndex) : _v2.GetMixVolume(destinationIndex);
+        }
 
-            return MixBufferVolume[destinationIndex];
+        /// <summary>
+        /// Get the previous volume for a given destination.
+        /// </summary>
+        /// <param name="destinationIndex">The destination index to use.</param>
+        /// <returns>The volume for the given destination.</returns>
+        public float GetMixVolumePrev(int destinationIndex)
+        {
+            return Unsafe.IsNullRef(ref _v2) ? _v1.GetMixVolumePrev(destinationIndex) : _v2.GetMixVolumePrev(destinationIndex);
         }
 
         /// <summary>
@@ -160,22 +261,33 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         public void ClearVolumes()
         {
-            MixBufferVolume.Clear();
-            PreviousMixBufferVolume.Clear();
+            if (Unsafe.IsNullRef(ref _v2))
+            {
+                _v1.ClearVolumes();
+            }
+            else
+            {
+                _v2.ClearVolumes();
+            }
         }
 
         /// <summary>
-        /// Link the next element to the given <see cref="SplitterDestination"/>.
+        /// Link the next element to the given splitter destination.
         /// </summary>
-        /// <param name="next">The given <see cref="SplitterDestination"/> to link.</param>
-        public void Link(ref SplitterDestination next)
+        /// <param name="next">The given splitter destination to link.</param>
+        public void Link(SplitterDestination next)
         {
-            unsafe
+            if (Unsafe.IsNullRef(ref _v2))
             {
-                fixed (SplitterDestination* nextPtr = &next)
-                {
-                    _next = nextPtr;
-                }
+                Debug.Assert(!Unsafe.IsNullRef(ref next._v1));
+
+                _v1.Link(ref next._v1);
+            }
+            else
+            {
+                Debug.Assert(!Unsafe.IsNullRef(ref next._v2));
+
+                _v2.Link(ref next._v2);
             }
         }
 
@@ -184,10 +296,74 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         public void Unlink()
         {
-            unsafe
+            if (Unsafe.IsNullRef(ref _v2))
             {
-                _next = null;
+                _v1.Unlink();
             }
+            else
+            {
+                _v2.Unlink();
+            }
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter is enabled.
+        /// </summary>
+        /// <returns>True if any biquad filter is enabled.</returns>
+        public bool IsBiquadFilterEnabled()
+        {
+            return !Unsafe.IsNullRef(ref _v2) && _v2.IsBiquadFilterEnabled();
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter was previously enabled.
+        /// </summary>
+        /// <returns>True if any biquad filter was previously enabled.</returns>
+        public bool IsBiquadFilterEnabledPrev()
+        {
+            return !Unsafe.IsNullRef(ref _v2) && _v2.IsBiquadFilterEnabledPrev();
+        }
+
+        /// <summary>
+        /// Gets the biquad filter parameters.
+        /// </summary>
+        /// <param name="index">Biquad filter index (0 or 1).</param>
+        /// <returns>Biquad filter parameters.</returns>
+        public ref BiquadFilterParameter GetBiquadFilterParameter(int index)
+        {
+            Debug.Assert(!Unsafe.IsNullRef(ref _v2));
+
+            return ref _v2.GetBiquadFilterParameter(index);
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter was previously enabled.
+        /// </summary>
+        /// <param name="index">Biquad filter index (0 or 1).</param>
+        public void UpdateBiquadFilterEnabledPrev(int index)
+        {
+            if (!Unsafe.IsNullRef(ref _v2))
+            {
+                _v2.UpdateBiquadFilterEnabledPrev(index);
+            }
+        }
+
+        /// <summary>
+        /// Get the reference for the version 1 splitter destination data, or null if version 2 is being used or the destination is null.
+        /// </summary>
+        /// <returns>Reference for the version 1 splitter destination data.</returns>
+        public ref SplitterDestinationVersion1 GetV1RefOrNull()
+        {
+            return ref _v1;
+        }
+
+        /// <summary>
+        /// Get the reference for the version 2 splitter destination data, or null if version 1 is being used or the destination is null.
+        /// </summary>
+        /// <returns>Reference for the version 2 splitter destination data.</returns>
+        public ref SplitterDestinationVersion2 GetV2RefOrNull()
+        {
+            return ref _v2;
         }
     }
 }

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

@@ -0,0 +1,208 @@
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Common.Utilities;
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Splitter
+{
+    /// <summary>
+    /// Server state for a splitter destination (version 1).
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0xE0, Pack = Alignment)]
+    public struct SplitterDestinationVersion1
+    {
+        public const int Alignment = 0x10;
+
+        /// <summary>
+        /// The unique id of this <see cref="SplitterDestinationVersion1"/>.
+        /// </summary>
+        public int Id;
+
+        /// <summary>
+        /// The mix to output the result of the splitter.
+        /// </summary>
+        public int DestinationId;
+
+        /// <summary>
+        /// Mix buffer volumes storage.
+        /// </summary>
+        private MixArray _mix;
+        private MixArray _previousMix;
+
+        /// <summary>
+        /// Pointer to the next linked element.
+        /// </summary>
+        private unsafe SplitterDestinationVersion1* _next;
+
+        /// <summary>
+        /// Set to true if in use.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsUsed;
+
+        /// <summary>
+        /// Set to true if the internal state need to be updated.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool NeedToUpdateInternalState;
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(float) * Constants.MixBufferCountMax, Pack = 1)]
+        private struct MixArray { }
+
+        /// <summary>
+        /// Mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mix);
+
+        /// <summary>
+        /// Previous mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> PreviousMixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _previousMix);
+
+        /// <summary>
+        /// Get the reference of the next element or null if not present.
+        /// </summary>
+        public readonly ref SplitterDestinationVersion1 Next
+        {
+            get
+            {
+                unsafe
+                {
+                    return ref Unsafe.AsRef<SplitterDestinationVersion1>(_next);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a new <see cref="SplitterDestinationVersion1"/>.
+        /// </summary>
+        /// <param name="id">The unique id of this <see cref="SplitterDestinationVersion1"/>.</param>
+        public SplitterDestinationVersion1(int id) : this()
+        {
+            Id = id;
+            DestinationId = Constants.UnusedMixId;
+
+            ClearVolumes();
+        }
+
+        /// <summary>
+        /// Update the <see cref="SplitterDestinationVersion1"/> from user parameter.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        /// <param name="isPrevVolumeResetSupported">Indicates that the audio renderer revision in use supports explicitly resetting the volume.</param>
+        public void Update<T>(in T parameter, bool isPrevVolumeResetSupported) where T : ISplitterDestinationInParameter
+        {
+            Debug.Assert(Id == parameter.Id);
+
+            if (parameter.IsMagicValid() && Id == parameter.Id)
+            {
+                DestinationId = parameter.DestinationId;
+
+                parameter.MixBufferVolume.CopyTo(MixBufferVolume);
+
+                bool resetPrevVolume = isPrevVolumeResetSupported ? parameter.ResetPrevVolume : !IsUsed && parameter.IsUsed;
+                if (resetPrevVolume)
+                {
+                    MixBufferVolume.CopyTo(PreviousMixBufferVolume);
+
+                    NeedToUpdateInternalState = false;
+                }
+
+                IsUsed = parameter.IsUsed;
+            }
+        }
+
+        /// <summary>
+        /// Update the internal state of the instance.
+        /// </summary>
+        public void UpdateInternalState()
+        {
+            if (IsUsed && NeedToUpdateInternalState)
+            {
+                MixBufferVolume.CopyTo(PreviousMixBufferVolume);
+            }
+
+            NeedToUpdateInternalState = false;
+        }
+
+        /// <summary>
+        /// Set the update internal state marker.
+        /// </summary>
+        public void MarkAsNeedToUpdateInternalState()
+        {
+            NeedToUpdateInternalState = true;
+        }
+
+        /// <summary>
+        /// Return true if the <see cref="SplitterDestinationVersion1"/> is used and has a destination.
+        /// </summary>
+        /// <returns>True if the <see cref="SplitterDestinationVersion1"/> is used and has a destination.</returns>
+        public readonly bool IsConfigured()
+        {
+            return IsUsed && DestinationId != Constants.UnusedMixId;
+        }
+
+        /// <summary>
+        /// Get the volume for a given destination.
+        /// </summary>
+        /// <param name="destinationIndex">The destination index to use.</param>
+        /// <returns>The volume for the given destination.</returns>
+        public float GetMixVolume(int destinationIndex)
+        {
+            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);
+
+            return MixBufferVolume[destinationIndex];
+        }
+
+        /// <summary>
+        /// Get the previous volume for a given destination.
+        /// </summary>
+        /// <param name="destinationIndex">The destination index to use.</param>
+        /// <returns>The volume for the given destination.</returns>
+        public float GetMixVolumePrev(int destinationIndex)
+        {
+            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);
+
+            return PreviousMixBufferVolume[destinationIndex];
+        }
+
+        /// <summary>
+        /// Clear the volumes.
+        /// </summary>
+        public void ClearVolumes()
+        {
+            MixBufferVolume.Clear();
+            PreviousMixBufferVolume.Clear();
+        }
+
+        /// <summary>
+        /// Link the next element to the given <see cref="SplitterDestinationVersion1"/>.
+        /// </summary>
+        /// <param name="next">The given <see cref="SplitterDestinationVersion1"/> to link.</param>
+        public void Link(ref SplitterDestinationVersion1 next)
+        {
+            unsafe
+            {
+                fixed (SplitterDestinationVersion1* nextPtr = &next)
+                {
+                    _next = nextPtr;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove the link to the next element.
+        /// </summary>
+        public void Unlink()
+        {
+            unsafe
+            {
+                _next = null;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,252 @@
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Splitter
+{
+    /// <summary>
+    /// Server state for a splitter destination (version 2).
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x110, Pack = Alignment)]
+    public struct SplitterDestinationVersion2
+    {
+        public const int Alignment = 0x10;
+
+        /// <summary>
+        /// The unique id of this <see cref="SplitterDestinationVersion2"/>.
+        /// </summary>
+        public int Id;
+
+        /// <summary>
+        /// The mix to output the result of the splitter.
+        /// </summary>
+        public int DestinationId;
+
+        /// <summary>
+        /// Mix buffer volumes storage.
+        /// </summary>
+        private MixArray _mix;
+        private MixArray _previousMix;
+
+        /// <summary>
+        /// Pointer to the next linked element.
+        /// </summary>
+        private unsafe SplitterDestinationVersion2* _next;
+
+        /// <summary>
+        /// Set to true if in use.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsUsed;
+
+        /// <summary>
+        /// Set to true if the internal state need to be updated.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool NeedToUpdateInternalState;
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(float) * Constants.MixBufferCountMax, Pack = 1)]
+        private struct MixArray { }
+
+        /// <summary>
+        /// Mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> MixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _mix);
+
+        /// <summary>
+        /// Previous mix buffer volumes.
+        /// </summary>
+        /// <remarks>Used when a splitter id is specified in the mix.</remarks>
+        public Span<float> PreviousMixBufferVolume => SpanHelpers.AsSpan<MixArray, float>(ref _previousMix);
+
+        /// <summary>
+        /// Get the reference of the next element or null if not present.
+        /// </summary>
+        public readonly ref SplitterDestinationVersion2 Next
+        {
+            get
+            {
+                unsafe
+                {
+                    return ref Unsafe.AsRef<SplitterDestinationVersion2>(_next);
+                }
+            }
+        }
+
+        private Array2<BiquadFilterParameter> _biquadFilters;
+
+        private Array2<bool> _isPreviousBiquadFilterEnabled;
+
+        /// <summary>
+        /// Create a new <see cref="SplitterDestinationVersion2"/>.
+        /// </summary>
+        /// <param name="id">The unique id of this <see cref="SplitterDestinationVersion2"/>.</param>
+        public SplitterDestinationVersion2(int id) : this()
+        {
+            Id = id;
+            DestinationId = Constants.UnusedMixId;
+
+            ClearVolumes();
+        }
+
+        /// <summary>
+        /// Update the <see cref="SplitterDestinationVersion2"/> from user parameter.
+        /// </summary>
+        /// <param name="parameter">The user parameter.</param>
+        /// <param name="isPrevVolumeResetSupported">Indicates that the audio renderer revision in use supports explicitly resetting the volume.</param>
+        public void Update<T>(in T parameter, bool isPrevVolumeResetSupported) where T : ISplitterDestinationInParameter
+        {
+            Debug.Assert(Id == parameter.Id);
+
+            if (parameter.IsMagicValid() && Id == parameter.Id)
+            {
+                DestinationId = parameter.DestinationId;
+
+                parameter.MixBufferVolume.CopyTo(MixBufferVolume);
+
+                _biquadFilters = parameter.BiquadFilters;
+
+                bool resetPrevVolume = isPrevVolumeResetSupported ? parameter.ResetPrevVolume : !IsUsed && parameter.IsUsed;
+                if (resetPrevVolume)
+                {
+                    MixBufferVolume.CopyTo(PreviousMixBufferVolume);
+
+                    NeedToUpdateInternalState = false;
+                }
+
+                IsUsed = parameter.IsUsed;
+            }
+        }
+
+        /// <summary>
+        /// Update the internal state of the instance.
+        /// </summary>
+        public void UpdateInternalState()
+        {
+            if (IsUsed && NeedToUpdateInternalState)
+            {
+                MixBufferVolume.CopyTo(PreviousMixBufferVolume);
+            }
+
+            NeedToUpdateInternalState = false;
+        }
+
+        /// <summary>
+        /// Set the update internal state marker.
+        /// </summary>
+        public void MarkAsNeedToUpdateInternalState()
+        {
+            NeedToUpdateInternalState = true;
+        }
+
+        /// <summary>
+        /// Return true if the <see cref="SplitterDestinationVersion2"/> is used and has a destination.
+        /// </summary>
+        /// <returns>True if the <see cref="SplitterDestinationVersion2"/> is used and has a destination.</returns>
+        public readonly bool IsConfigured()
+        {
+            return IsUsed && DestinationId != Constants.UnusedMixId;
+        }
+
+        /// <summary>
+        /// Get the volume for a given destination.
+        /// </summary>
+        /// <param name="destinationIndex">The destination index to use.</param>
+        /// <returns>The volume for the given destination.</returns>
+        public float GetMixVolume(int destinationIndex)
+        {
+            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);
+
+            return MixBufferVolume[destinationIndex];
+        }
+
+        /// <summary>
+        /// Get the previous volume for a given destination.
+        /// </summary>
+        /// <param name="destinationIndex">The destination index to use.</param>
+        /// <returns>The volume for the given destination.</returns>
+        public float GetMixVolumePrev(int destinationIndex)
+        {
+            Debug.Assert(destinationIndex >= 0 && destinationIndex < Constants.MixBufferCountMax);
+
+            return PreviousMixBufferVolume[destinationIndex];
+        }
+
+        /// <summary>
+        /// Clear the volumes.
+        /// </summary>
+        public void ClearVolumes()
+        {
+            MixBufferVolume.Clear();
+            PreviousMixBufferVolume.Clear();
+        }
+
+        /// <summary>
+        /// Link the next element to the given <see cref="SplitterDestinationVersion2"/>.
+        /// </summary>
+        /// <param name="next">The given <see cref="SplitterDestinationVersion2"/> to link.</param>
+        public void Link(ref SplitterDestinationVersion2 next)
+        {
+            unsafe
+            {
+                fixed (SplitterDestinationVersion2* nextPtr = &next)
+                {
+                    _next = nextPtr;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove the link to the next element.
+        /// </summary>
+        public void Unlink()
+        {
+            unsafe
+            {
+                _next = null;
+            }
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter is enabled.
+        /// </summary>
+        /// <returns>True if any biquad filter is enabled.</returns>
+        public bool IsBiquadFilterEnabled()
+        {
+            return _biquadFilters[0].Enable || _biquadFilters[1].Enable;
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter was previously enabled.
+        /// </summary>
+        /// <returns>True if any biquad filter was previously enabled.</returns>
+        public bool IsBiquadFilterEnabledPrev()
+        {
+            return _isPreviousBiquadFilterEnabled[0];
+        }
+
+        /// <summary>
+        /// Gets the biquad filter parameters.
+        /// </summary>
+        /// <param name="index">Biquad filter index (0 or 1).</param>
+        /// <returns>Biquad filter parameters.</returns>
+        public ref BiquadFilterParameter GetBiquadFilterParameter(int index)
+        {
+            return ref _biquadFilters[index];
+        }
+
+        /// <summary>
+        /// Checks if any biquad filter was previously enabled.
+        /// </summary>
+        /// <param name="index">Biquad filter index (0 or 1).</param>
+        public void UpdateBiquadFilterEnabledPrev(int index)
+        {
+            _isPreviousBiquadFilterEnabled[index] = _biquadFilters[index].Enable;
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
 using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Common.Extensions;
 using System;
 using System.Buffers;
 using System.Diagnostics;
@@ -14,6 +15,8 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
     {
         public const int Alignment = 0x10;
 
+        private delegate void SplitterDestinationAction(SplitterDestination destination, int index);
+
         /// <summary>
         /// The unique id of this <see cref="SplitterState"/>.
         /// </summary>
@@ -25,7 +28,7 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         public uint SampleRate;
 
         /// <summary>
-        /// Count of splitter destinations (<see cref="SplitterDestination"/>).
+        /// Count of splitter destinations.
         /// </summary>
         public int DestinationCount;
 
@@ -36,20 +39,25 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         public bool HasNewConnection;
 
         /// <summary>
-        /// Linked list of <see cref="SplitterDestination"/>.
+        /// Linked list of <see cref="SplitterDestinationVersion1"/>.
         /// </summary>
-        private unsafe SplitterDestination* _destinationsData;
+        private unsafe SplitterDestinationVersion1* _destinationDataV1;
 
         /// <summary>
-        /// Span to the first element of the linked list of <see cref="SplitterDestination"/>.
+        /// Linked list of <see cref="SplitterDestinationVersion2"/>.
         /// </summary>
-        public readonly Span<SplitterDestination> Destinations
+        private unsafe SplitterDestinationVersion2* _destinationDataV2;
+
+        /// <summary>
+        /// First element of the linked list of splitter destinations data.
+        /// </summary>
+        public readonly SplitterDestination Destination
         {
             get
             {
                 unsafe
                 {
-                    return (IntPtr)_destinationsData != IntPtr.Zero ? new Span<SplitterDestination>(_destinationsData, 1) : Span<SplitterDestination>.Empty;
+                    return new SplitterDestination(_destinationDataV1, _destinationDataV2);
                 }
             }
         }
@@ -63,20 +71,20 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
             Id = id;
         }
 
-        public readonly Span<SplitterDestination> GetData(int index)
+        public readonly SplitterDestination GetData(int index)
         {
             int i = 0;
 
-            Span<SplitterDestination> result = Destinations;
+            SplitterDestination result = Destination;
 
             while (i < index)
             {
-                if (result.IsEmpty)
+                if (result.IsNull)
                 {
                     break;
                 }
 
-                result = result[0].Next;
+                result = result.Next;
                 i++;
             }
 
@@ -92,25 +100,25 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         }
 
         /// <summary>
-        /// Utility function to apply a given <see cref="SpanAction{T, TArg}"/> to all <see cref="Destinations"/>.
+        /// Utility function to apply an action to all <see cref="Destination"/>.
         /// </summary>
         /// <param name="action">The action to execute on each elements.</param>
-        private readonly void ForEachDestination(SpanAction<SplitterDestination, int> action)
+        private readonly void ForEachDestination(SplitterDestinationAction action)
         {
-            Span<SplitterDestination> temp = Destinations;
+            SplitterDestination temp = Destination;
 
             int i = 0;
 
             while (true)
             {
-                if (temp.IsEmpty)
+                if (temp.IsNull)
                 {
                     break;
                 }
 
-                Span<SplitterDestination> next = temp[0].Next;
+                SplitterDestination next = temp.Next;
 
-                action.Invoke(temp, i++);
+                action(temp, i++);
 
                 temp = next;
             }
@@ -122,7 +130,7 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// <param name="context">The splitter context.</param>
         /// <param name="parameter">The user parameter.</param>
         /// <param name="input">The raw input data after the <paramref name="parameter"/>.</param>
-        public void Update(SplitterContext context, ref SplitterInParameter parameter, ReadOnlySpan<byte> input)
+        public void Update(SplitterContext context, in SplitterInParameter parameter, ref SequenceReader<byte> input)
         {
             ClearLinks();
 
@@ -139,23 +147,30 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
 
             if (destinationCount > 0)
             {
-                ReadOnlySpan<int> destinationIds = MemoryMarshal.Cast<byte, int>(input);
+                input.ReadLittleEndian(out int destinationId);
 
-                Memory<SplitterDestination> destination = context.GetDestinationMemory(destinationIds[0]);
+                SplitterDestination destination = context.GetDestination(destinationId);
 
-                SetDestination(ref destination.Span[0]);
+                SetDestination(destination);
 
                 DestinationCount = destinationCount;
 
                 for (int i = 1; i < destinationCount; i++)
                 {
-                    Memory<SplitterDestination> nextDestination = context.GetDestinationMemory(destinationIds[i]);
+                    input.ReadLittleEndian(out destinationId);
 
-                    destination.Span[0].Link(ref nextDestination.Span[0]);
+                    SplitterDestination nextDestination = context.GetDestination(destinationId);
+
+                    destination.Link(nextDestination);
                     destination = nextDestination;
                 }
             }
 
+            if (destinationCount < parameter.DestinationCount)
+            {
+                input.Advance((parameter.DestinationCount - destinationCount) * sizeof(int));
+            }
+
             Debug.Assert(parameter.Id == Id);
 
             if (parameter.Id == Id)
@@ -166,16 +181,21 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         }
 
         /// <summary>
-        /// Set the head of the linked list of <see cref="Destinations"/>.
+        /// Set the head of the linked list of <see cref="Destination"/>.
         /// </summary>
-        /// <param name="newValue">A reference to a <see cref="SplitterDestination"/>.</param>
-        public void SetDestination(ref SplitterDestination newValue)
+        /// <param name="newValue">New destination value.</param>
+        public void SetDestination(SplitterDestination newValue)
         {
             unsafe
             {
-                fixed (SplitterDestination* newValuePtr = &newValue)
+                fixed (SplitterDestinationVersion1* newValuePtr = &newValue.GetV1RefOrNull())
                 {
-                    _destinationsData = newValuePtr;
+                    _destinationDataV1 = newValuePtr;
+                }
+
+                fixed (SplitterDestinationVersion2* newValuePtr = &newValue.GetV2RefOrNull())
+                {
+                    _destinationDataV2 = newValuePtr;
                 }
             }
         }
@@ -185,19 +205,20 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         public readonly void UpdateInternalState()
         {
-            ForEachDestination((destination, _) => destination[0].UpdateInternalState());
+            ForEachDestination((destination, _) => destination.UpdateInternalState());
         }
 
         /// <summary>
-        /// Clear all links from the <see cref="Destinations"/>.
+        /// Clear all links from the <see cref="Destination"/>.
         /// </summary>
         public void ClearLinks()
         {
-            ForEachDestination((destination, _) => destination[0].Unlink());
+            ForEachDestination((destination, _) => destination.Unlink());
 
             unsafe
             {
-                _destinationsData = (SplitterDestination*)IntPtr.Zero;
+                _destinationDataV1 = null;
+                _destinationDataV2 = null;
             }
         }
 
@@ -211,7 +232,8 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
             {
                 unsafe
                 {
-                    splitter._destinationsData = (SplitterDestination*)IntPtr.Zero;
+                    splitter._destinationDataV1 = null;
+                    splitter._destinationDataV2 = null;
                 }
 
                 splitter.DestinationCount = 0;

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

@@ -9,41 +9,40 @@ using Ryujinx.Audio.Renderer.Server.Sink;
 using Ryujinx.Audio.Renderer.Server.Splitter;
 using Ryujinx.Audio.Renderer.Server.Voice;
 using Ryujinx.Audio.Renderer.Utils;
+using Ryujinx.Common.Extensions;
 using Ryujinx.Common.Logging;
 using System;
 using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using static Ryujinx.Audio.Renderer.Common.BehaviourParameter;
 
 namespace Ryujinx.Audio.Renderer.Server
 {
-    public class StateUpdater
+    public ref struct StateUpdater
     {
-        private readonly ReadOnlyMemory<byte> _inputOrigin;
+        private SequenceReader<byte> _inputReader;
+
         private readonly ReadOnlyMemory<byte> _outputOrigin;
-        private ReadOnlyMemory<byte> _input;
 
         private Memory<byte> _output;
         private readonly uint _processHandle;
         private BehaviourContext _behaviourContext;
 
-        private UpdateDataHeader _inputHeader;
+        private readonly ref readonly UpdateDataHeader _inputHeader;
         private readonly Memory<UpdateDataHeader> _outputHeader;
 
-        private ref UpdateDataHeader OutputHeader => ref _outputHeader.Span[0];
+        private readonly ref UpdateDataHeader OutputHeader => ref _outputHeader.Span[0];
 
-        public StateUpdater(ReadOnlyMemory<byte> input, Memory<byte> output, uint processHandle, BehaviourContext behaviourContext)
+        public StateUpdater(ReadOnlySequence<byte> input, Memory<byte> output, uint processHandle, BehaviourContext behaviourContext)
         {
-            _input = input;
-            _inputOrigin = _input;
+            _inputReader = new SequenceReader<byte>(input);
             _output = output;
             _outputOrigin = _output;
             _processHandle = processHandle;
             _behaviourContext = behaviourContext;
 
-            _inputHeader = SpanIOHelper.Read<UpdateDataHeader>(ref _input);
+            _inputHeader = ref _inputReader.GetRefOrRefToCopy<UpdateDataHeader>(out _);
 
             _outputHeader = SpanMemoryManager<UpdateDataHeader>.Cast(_output[..Unsafe.SizeOf<UpdateDataHeader>()]);
             OutputHeader.Initialize(_behaviourContext.UserRevision);
@@ -52,7 +51,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
         public ResultCode UpdateBehaviourContext()
         {
-            BehaviourParameter parameter = SpanIOHelper.Read<BehaviourParameter>(ref _input);
+            ref readonly BehaviourParameter parameter = ref _inputReader.GetRefOrRefToCopy<BehaviourParameter>(out _);
 
             if (!BehaviourContext.CheckValidRevision(parameter.UserRevision) || parameter.UserRevision != _behaviourContext.UserRevision)
             {
@@ -81,11 +80,11 @@ namespace Ryujinx.Audio.Renderer.Server
 
             foreach (ref MemoryPoolState memoryPool in memoryPools)
             {
-                MemoryPoolInParameter parameter = SpanIOHelper.Read<MemoryPoolInParameter>(ref _input);
+                ref readonly MemoryPoolInParameter parameter = ref _inputReader.GetRefOrRefToCopy<MemoryPoolInParameter>(out _);
 
                 ref MemoryPoolOutStatus outStatus = ref SpanIOHelper.GetWriteRef<MemoryPoolOutStatus>(ref _output)[0];
 
-                PoolMapper.UpdateResult updateResult = mapper.Update(ref memoryPool, ref parameter, ref outStatus);
+                PoolMapper.UpdateResult updateResult = mapper.Update(ref memoryPool, in parameter, ref outStatus);
 
                 if (updateResult != PoolMapper.UpdateResult.Success &&
                     updateResult != PoolMapper.UpdateResult.MapError &&
@@ -115,7 +114,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             for (int i = 0; i < context.GetCount(); i++)
             {
-                VoiceChannelResourceInParameter parameter = SpanIOHelper.Read<VoiceChannelResourceInParameter>(ref _input);
+                ref readonly VoiceChannelResourceInParameter parameter = ref _inputReader.GetRefOrRefToCopy<VoiceChannelResourceInParameter>(out _);
 
                 ref VoiceChannelResource resource = ref context.GetChannelResource(i);
 
@@ -127,7 +126,7 @@ namespace Ryujinx.Audio.Renderer.Server
             return ResultCode.Success;
         }
 
-        public ResultCode UpdateVoices(VoiceContext context, Memory<MemoryPoolState> memoryPools)
+        public ResultCode UpdateVoices(VoiceContext context, PoolMapper mapper)
         {
             if (context.GetCount() * Unsafe.SizeOf<VoiceInParameter>() != _inputHeader.VoicesSize)
             {
@@ -136,11 +135,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             int initialOutputSize = _output.Length;
 
-            ReadOnlySpan<VoiceInParameter> parameters = MemoryMarshal.Cast<byte, VoiceInParameter>(_input[..(int)_inputHeader.VoicesSize].Span);
-
-            _input = _input[(int)_inputHeader.VoicesSize..];
-
-            PoolMapper mapper = new(_processHandle, memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
+            long initialInputConsumed = _inputReader.Consumed;
 
             // First make everything not in use.
             for (int i = 0; i < context.GetCount(); i++)
@@ -157,7 +152,7 @@ namespace Ryujinx.Audio.Renderer.Server
             // Start processing
             for (int i = 0; i < context.GetCount(); i++)
             {
-                VoiceInParameter parameter = parameters[i];
+                ref readonly VoiceInParameter parameter = ref _inputReader.GetRefOrRefToCopy<VoiceInParameter>(out _);
 
                 voiceUpdateStates.Fill(Memory<VoiceUpdateState>.Empty);
 
@@ -181,14 +176,14 @@ namespace Ryujinx.Audio.Renderer.Server
                         currentVoiceState.Initialize();
                     }
 
-                    currentVoiceState.UpdateParameters(out ErrorInfo updateParameterError, ref parameter, ref mapper, ref _behaviourContext);
+                    currentVoiceState.UpdateParameters(out ErrorInfo updateParameterError, in parameter, mapper, ref _behaviourContext);
 
                     if (updateParameterError.ErrorCode != ResultCode.Success)
                     {
                         _behaviourContext.AppendError(ref updateParameterError);
                     }
 
-                    currentVoiceState.UpdateWaveBuffers(out ErrorInfo[] waveBufferUpdateErrorInfos, ref parameter, voiceUpdateStates, ref mapper, ref _behaviourContext);
+                    currentVoiceState.UpdateWaveBuffers(out ErrorInfo[] waveBufferUpdateErrorInfos, in parameter, voiceUpdateStates, mapper, ref _behaviourContext);
 
                     foreach (ref ErrorInfo errorInfo in waveBufferUpdateErrorInfos.AsSpan())
                     {
@@ -198,7 +193,7 @@ namespace Ryujinx.Audio.Renderer.Server
                         }
                     }
 
-                    currentVoiceState.WriteOutStatus(ref outStatus, ref parameter, voiceUpdateStates);
+                    currentVoiceState.WriteOutStatus(ref outStatus, in parameter, voiceUpdateStates);
                 }
             }
 
@@ -211,10 +206,12 @@ namespace Ryujinx.Audio.Renderer.Server
 
             Debug.Assert((initialOutputSize - currentOutputSize) == OutputHeader.VoicesSize);
 
+            _inputReader.SetConsumed(initialInputConsumed + _inputHeader.VoicesSize);
+
             return ResultCode.Success;
         }
 
-        private static void ResetEffect<T>(ref BaseEffect effect, ref T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
+        private static void ResetEffect<T>(ref BaseEffect effect, in T parameter, PoolMapper mapper) where T : unmanaged, IEffectInParameter
         {
             effect.ForceUnmapBuffers(mapper);
 
@@ -234,17 +231,17 @@ namespace Ryujinx.Audio.Renderer.Server
             };
         }
 
-        public ResultCode UpdateEffects(EffectContext context, bool isAudioRendererActive, Memory<MemoryPoolState> memoryPools)
+        public ResultCode UpdateEffects(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
         {
             if (_behaviourContext.IsEffectInfoVersion2Supported())
             {
-                return UpdateEffectsVersion2(context, isAudioRendererActive, memoryPools);
+                return UpdateEffectsVersion2(context, isAudioRendererActive, mapper);
             }
 
-            return UpdateEffectsVersion1(context, isAudioRendererActive, memoryPools);
+            return UpdateEffectsVersion1(context, isAudioRendererActive, mapper);
         }
 
-        public ResultCode UpdateEffectsVersion2(EffectContext context, bool isAudioRendererActive, Memory<MemoryPoolState> memoryPools)
+        public ResultCode UpdateEffectsVersion2(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
         {
             if (context.GetCount() * Unsafe.SizeOf<EffectInParameterVersion2>() != _inputHeader.EffectsSize)
             {
@@ -253,26 +250,22 @@ namespace Ryujinx.Audio.Renderer.Server
 
             int initialOutputSize = _output.Length;
 
-            ReadOnlySpan<EffectInParameterVersion2> parameters = MemoryMarshal.Cast<byte, EffectInParameterVersion2>(_input[..(int)_inputHeader.EffectsSize].Span);
-
-            _input = _input[(int)_inputHeader.EffectsSize..];
-
-            PoolMapper mapper = new(_processHandle, memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
+            long initialInputConsumed = _inputReader.Consumed;
 
             for (int i = 0; i < context.GetCount(); i++)
             {
-                EffectInParameterVersion2 parameter = parameters[i];
+                ref readonly EffectInParameterVersion2 parameter = ref _inputReader.GetRefOrRefToCopy<EffectInParameterVersion2>(out _);
 
                 ref EffectOutStatusVersion2 outStatus = ref SpanIOHelper.GetWriteRef<EffectOutStatusVersion2>(ref _output)[0];
 
                 ref BaseEffect effect = ref context.GetEffect(i);
 
-                if (!effect.IsTypeValid(ref parameter))
+                if (!effect.IsTypeValid(in parameter))
                 {
-                    ResetEffect(ref effect, ref parameter, mapper);
+                    ResetEffect(ref effect, in parameter, mapper);
                 }
 
-                effect.Update(out ErrorInfo updateErrorInfo, ref parameter, mapper);
+                effect.Update(out ErrorInfo updateErrorInfo, in parameter, mapper);
 
                 if (updateErrorInfo.ErrorCode != ResultCode.Success)
                 {
@@ -297,10 +290,12 @@ namespace Ryujinx.Audio.Renderer.Server
 
             Debug.Assert((initialOutputSize - currentOutputSize) == OutputHeader.EffectsSize);
 
+            _inputReader.SetConsumed(initialInputConsumed + _inputHeader.EffectsSize);
+
             return ResultCode.Success;
         }
 
-        public ResultCode UpdateEffectsVersion1(EffectContext context, bool isAudioRendererActive, Memory<MemoryPoolState> memoryPools)
+        public ResultCode UpdateEffectsVersion1(EffectContext context, bool isAudioRendererActive, PoolMapper mapper)
         {
             if (context.GetCount() * Unsafe.SizeOf<EffectInParameterVersion1>() != _inputHeader.EffectsSize)
             {
@@ -309,26 +304,22 @@ namespace Ryujinx.Audio.Renderer.Server
 
             int initialOutputSize = _output.Length;
 
-            ReadOnlySpan<EffectInParameterVersion1> parameters = MemoryMarshal.Cast<byte, EffectInParameterVersion1>(_input[..(int)_inputHeader.EffectsSize].Span);
-
-            _input = _input[(int)_inputHeader.EffectsSize..];
-
-            PoolMapper mapper = new(_processHandle, memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
+            long initialInputConsumed = _inputReader.Consumed;
 
             for (int i = 0; i < context.GetCount(); i++)
             {
-                EffectInParameterVersion1 parameter = parameters[i];
+                ref readonly EffectInParameterVersion1 parameter = ref _inputReader.GetRefOrRefToCopy<EffectInParameterVersion1>(out _);
 
                 ref EffectOutStatusVersion1 outStatus = ref SpanIOHelper.GetWriteRef<EffectOutStatusVersion1>(ref _output)[0];
 
                 ref BaseEffect effect = ref context.GetEffect(i);
 
-                if (!effect.IsTypeValid(ref parameter))
+                if (!effect.IsTypeValid(in parameter))
                 {
-                    ResetEffect(ref effect, ref parameter, mapper);
+                    ResetEffect(ref effect, in parameter, mapper);
                 }
 
-                effect.Update(out ErrorInfo updateErrorInfo, ref parameter, mapper);
+                effect.Update(out ErrorInfo updateErrorInfo, in parameter, mapper);
 
                 if (updateErrorInfo.ErrorCode != ResultCode.Success)
                 {
@@ -345,38 +336,40 @@ namespace Ryujinx.Audio.Renderer.Server
 
             Debug.Assert((initialOutputSize - currentOutputSize) == OutputHeader.EffectsSize);
 
+            _inputReader.SetConsumed(initialInputConsumed + _inputHeader.EffectsSize);
+
             return ResultCode.Success;
         }
 
         public ResultCode UpdateSplitter(SplitterContext context)
         {
-            if (context.Update(_input.Span, out int consumedSize))
+            if (context.Update(ref _inputReader))
             {
-                _input = _input[consumedSize..];
-
                 return ResultCode.Success;
             }
 
             return ResultCode.InvalidUpdateInfo;
         }
 
-        private static bool CheckMixParametersValidity(MixContext mixContext, uint mixBufferCount, uint inputMixCount, ReadOnlySpan<MixParameter> parameters)
+        private static bool CheckMixParametersValidity(MixContext mixContext, uint mixBufferCount, uint inputMixCount, SequenceReader<byte> parameters)
         {
             uint maxMixStateCount = mixContext.GetCount();
             uint totalRequiredMixBufferCount = 0;
 
             for (int i = 0; i < inputMixCount; i++)
             {
-                if (parameters[i].IsUsed)
+                ref readonly MixParameter parameter = ref parameters.GetRefOrRefToCopy<MixParameter>(out _);
+
+                if (parameter.IsUsed)
                 {
-                    if (parameters[i].DestinationMixId != Constants.UnusedMixId &&
-                        parameters[i].DestinationMixId > maxMixStateCount &&
-                        parameters[i].MixId != Constants.FinalMixId)
+                    if (parameter.DestinationMixId != Constants.UnusedMixId &&
+                        parameter.DestinationMixId > maxMixStateCount &&
+                        parameter.MixId != Constants.FinalMixId)
                     {
                         return true;
                     }
 
-                    totalRequiredMixBufferCount += parameters[i].BufferCount;
+                    totalRequiredMixBufferCount += parameter.BufferCount;
                 }
             }
 
@@ -391,7 +384,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
             if (_behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported())
             {
-                MixInParameterDirtyOnlyUpdate parameter = MemoryMarshal.Cast<byte, MixInParameterDirtyOnlyUpdate>(_input.Span)[0];
+                ref readonly MixInParameterDirtyOnlyUpdate parameter = ref _inputReader.GetRefOrRefToCopy<MixInParameterDirtyOnlyUpdate>(out _);
 
                 mixCount = parameter.MixCount;
 
@@ -411,25 +404,20 @@ namespace Ryujinx.Audio.Renderer.Server
                 return ResultCode.InvalidUpdateInfo;
             }
 
-            if (_behaviourContext.IsMixInParameterDirtyOnlyUpdateSupported())
-            {
-                _input = _input[Unsafe.SizeOf<MixInParameterDirtyOnlyUpdate>()..];
-            }
+            long initialInputConsumed = _inputReader.Consumed;
 
-            ReadOnlySpan<MixParameter> parameters = MemoryMarshal.Cast<byte, MixParameter>(_input.Span[..(int)inputMixSize]);
+            int parameterCount = (int)inputMixSize / Unsafe.SizeOf<MixParameter>();
 
-            _input = _input[(int)inputMixSize..];
-
-            if (CheckMixParametersValidity(mixContext, mixBufferCount, mixCount, parameters))
+            if (CheckMixParametersValidity(mixContext, mixBufferCount, mixCount, _inputReader))
             {
                 return ResultCode.InvalidUpdateInfo;
             }
 
             bool isMixContextDirty = false;
 
-            for (int i = 0; i < parameters.Length; i++)
+            for (int i = 0; i < parameterCount; i++)
             {
-                MixParameter parameter = parameters[i];
+                ref readonly MixParameter parameter = ref _inputReader.GetRefOrRefToCopy<MixParameter>(out _);
 
                 int mixId = i;
 
@@ -454,7 +442,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
                 if (mix.IsUsed)
                 {
-                    isMixContextDirty |= mix.Update(mixContext.EdgeMatrix, ref parameter, effectContext, splitterContext, _behaviourContext);
+                    isMixContextDirty |= mix.Update(mixContext.EdgeMatrix, in parameter, effectContext, splitterContext, _behaviourContext);
                 }
             }
 
@@ -473,10 +461,12 @@ namespace Ryujinx.Audio.Renderer.Server
                 }
             }
 
+            _inputReader.SetConsumed(initialInputConsumed + inputMixSize);
+
             return ResultCode.Success;
         }
 
-        private static void ResetSink(ref BaseSink sink, ref SinkInParameter parameter)
+        private static void ResetSink(ref BaseSink sink, in SinkInParameter parameter)
         {
             sink.CleanUp();
 
@@ -489,10 +479,8 @@ namespace Ryujinx.Audio.Renderer.Server
             };
         }
 
-        public ResultCode UpdateSinks(SinkContext context, Memory<MemoryPoolState> memoryPools)
+        public ResultCode UpdateSinks(SinkContext context, PoolMapper mapper)
         {
-            PoolMapper mapper = new(_processHandle, memoryPools, _behaviourContext.IsMemoryPoolForceMappingEnabled());
-
             if (context.GetCount() * Unsafe.SizeOf<SinkInParameter>() != _inputHeader.SinksSize)
             {
                 return ResultCode.InvalidUpdateInfo;
@@ -500,22 +488,20 @@ namespace Ryujinx.Audio.Renderer.Server
 
             int initialOutputSize = _output.Length;
 
-            ReadOnlySpan<SinkInParameter> parameters = MemoryMarshal.Cast<byte, SinkInParameter>(_input[..(int)_inputHeader.SinksSize].Span);
-
-            _input = _input[(int)_inputHeader.SinksSize..];
+            long initialInputConsumed = _inputReader.Consumed;
 
             for (int i = 0; i < context.GetCount(); i++)
             {
-                SinkInParameter parameter = parameters[i];
+                ref readonly SinkInParameter parameter = ref _inputReader.GetRefOrRefToCopy<SinkInParameter>(out _);
                 ref SinkOutStatus outStatus = ref SpanIOHelper.GetWriteRef<SinkOutStatus>(ref _output)[0];
                 ref BaseSink sink = ref context.GetSink(i);
 
-                if (!sink.IsTypeValid(ref parameter))
+                if (!sink.IsTypeValid(in parameter))
                 {
-                    ResetSink(ref sink, ref parameter);
+                    ResetSink(ref sink, in parameter);
                 }
 
-                sink.Update(out ErrorInfo updateErrorInfo, ref parameter, ref outStatus, mapper);
+                sink.Update(out ErrorInfo updateErrorInfo, in parameter, ref outStatus, mapper);
 
                 if (updateErrorInfo.ErrorCode != ResultCode.Success)
                 {
@@ -530,6 +516,8 @@ namespace Ryujinx.Audio.Renderer.Server
 
             Debug.Assert((initialOutputSize - currentOutputSize) == OutputHeader.SinksSize);
 
+            _inputReader.SetConsumed(initialInputConsumed + _inputHeader.SinksSize);
+
             return ResultCode.Success;
         }
 
@@ -540,7 +528,7 @@ namespace Ryujinx.Audio.Renderer.Server
                 return ResultCode.InvalidUpdateInfo;
             }
 
-            PerformanceInParameter parameter = SpanIOHelper.Read<PerformanceInParameter>(ref _input);
+            ref readonly PerformanceInParameter parameter = ref _inputReader.GetRefOrRefToCopy<PerformanceInParameter>(out _);
 
             ref PerformanceOutStatus outStatus = ref SpanIOHelper.GetWriteRef<PerformanceOutStatus>(ref _output)[0];
 
@@ -585,9 +573,9 @@ namespace Ryujinx.Audio.Renderer.Server
             return ResultCode.Success;
         }
 
-        public ResultCode CheckConsumedSize()
+        public readonly ResultCode CheckConsumedSize()
         {
-            int consumedInputSize = _inputOrigin.Length - _input.Length;
+            long consumedInputSize = _inputReader.Consumed;
             int consumedOutputSize = _outputOrigin.Length - _output.Length;
 
             if (consumedInputSize != _inputHeader.TotalSize)

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

@@ -254,7 +254,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// </summary>
         /// <param name="parameter">The user parameter.</param>
         /// <returns>Return true, if the server voice information needs to be updated.</returns>
-        private readonly bool ShouldUpdateParameters(ref VoiceInParameter parameter)
+        private readonly bool ShouldUpdateParameters(in VoiceInParameter parameter)
         {
             if (DataSourceStateAddressInfo.CpuAddress == parameter.DataSourceStateAddress)
             {
@@ -273,7 +273,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="parameter">The user parameter.</param>
         /// <param name="poolMapper">The mapper to use.</param>
         /// <param name="behaviourContext">The behaviour context.</param>
-        public void UpdateParameters(out ErrorInfo outErrorInfo, ref VoiceInParameter parameter, ref PoolMapper poolMapper, ref BehaviourContext behaviourContext)
+        public void UpdateParameters(out ErrorInfo outErrorInfo, in VoiceInParameter parameter, PoolMapper poolMapper, ref BehaviourContext behaviourContext)
         {
             InUse = parameter.InUse;
             Id = parameter.Id;
@@ -326,7 +326,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 VoiceDropFlag = false;
             }
 
-            if (ShouldUpdateParameters(ref parameter))
+            if (ShouldUpdateParameters(in parameter))
             {
                 DataSourceStateUnmapped = !poolMapper.TryAttachBuffer(out outErrorInfo, ref DataSourceStateAddressInfo, parameter.DataSourceStateAddress, parameter.DataSourceStateSize);
             }
@@ -380,7 +380,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="outStatus">The given user output.</param>
         /// <param name="parameter">The user parameter.</param>
         /// <param name="voiceUpdateStates">The voice states associated to the <see cref="VoiceState"/>.</param>
-        public void WriteOutStatus(ref VoiceOutStatus outStatus, ref VoiceInParameter parameter, ReadOnlySpan<Memory<VoiceUpdateState>> voiceUpdateStates)
+        public void WriteOutStatus(ref VoiceOutStatus outStatus, in VoiceInParameter parameter, ReadOnlySpan<Memory<VoiceUpdateState>> voiceUpdateStates)
         {
 #if DEBUG
             // Sanity check in debug mode of the internal state
@@ -426,7 +426,12 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="voiceUpdateStates">The voice states associated to the <see cref="VoiceState"/>.</param>
         /// <param name="mapper">The mapper to use.</param>
         /// <param name="behaviourContext">The behaviour context.</param>
-        public void UpdateWaveBuffers(out ErrorInfo[] errorInfos, ref VoiceInParameter parameter, ReadOnlySpan<Memory<VoiceUpdateState>> voiceUpdateStates, ref PoolMapper mapper, ref BehaviourContext behaviourContext)
+        public void UpdateWaveBuffers(
+            out ErrorInfo[] errorInfos,
+            in VoiceInParameter parameter,
+            ReadOnlySpan<Memory<VoiceUpdateState>> voiceUpdateStates,
+            PoolMapper mapper,
+            ref BehaviourContext behaviourContext)
         {
             errorInfos = new ErrorInfo[Constants.VoiceWaveBufferCount * 2];
 
@@ -444,7 +449,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
 
             for (int i = 0; i < Constants.VoiceWaveBufferCount; i++)
             {
-                UpdateWaveBuffer(errorInfos.AsSpan(i * 2, 2), ref WaveBuffers[i], ref parameter.WaveBuffers[i], parameter.SampleFormat, voiceUpdateState.IsWaveBufferValid[i], ref mapper, ref behaviourContext);
+                UpdateWaveBuffer(errorInfos.AsSpan(i * 2, 2), ref WaveBuffers[i], ref parameter.WaveBuffers[i], parameter.SampleFormat, voiceUpdateState.IsWaveBufferValid[i], mapper, ref behaviourContext);
             }
         }
 
@@ -458,7 +463,14 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="isValid">If set to true, the server side wavebuffer is considered valid.</param>
         /// <param name="mapper">The mapper to use.</param>
         /// <param name="behaviourContext">The behaviour context.</param>
-        private void UpdateWaveBuffer(Span<ErrorInfo> errorInfos, ref WaveBuffer waveBuffer, ref WaveBufferInternal inputWaveBuffer, SampleFormat sampleFormat, bool isValid, ref PoolMapper mapper, ref BehaviourContext behaviourContext)
+        private void UpdateWaveBuffer(
+            Span<ErrorInfo> errorInfos,
+            ref WaveBuffer waveBuffer,
+            ref WaveBufferInternal inputWaveBuffer,
+            SampleFormat sampleFormat,
+            bool isValid,
+            PoolMapper mapper,
+            ref BehaviourContext behaviourContext)
         {
             if (!isValid && waveBuffer.IsSendToAudioProcessor && waveBuffer.BufferAddressInfo.CpuAddress != 0)
             {

src/Ryujinx.Common/Configuration/Hid/KeyboardHotkeys.cs

@@ -1,7 +1,5 @@
 namespace Ryujinx.Common.Configuration.Hid
 {
-    // NOTE: Please don't change this to struct.
-    //       This breaks Avalonia's TwoWay binding, which makes us unable to save new KeyboardHotkeys.
     public class KeyboardHotkeys
     {
         public Key ToggleVsync { get; set; }

src/Ryujinx.Common/Extensions/SequenceReaderExtensions.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Common.Extensions
+{
+    public static class SequenceReaderExtensions
+    {
+        /// <summary>
+        /// Dumps the entire <see cref="SequenceReader{byte}"/> to a file, restoring its previous location afterward.
+        /// Useful for debugging purposes.
+        /// </summary>
+        /// <param name="reader">The <see cref="SequenceReader{Byte}"/> to write to a file</param>
+        /// <param name="fileFullName">The path and name of the file to create and dump to</param>
+        public static void DumpToFile(this ref SequenceReader<byte> reader, string fileFullName)
+        {
+            var initialConsumed = reader.Consumed;
+
+            reader.Rewind(initialConsumed);
+
+            using (var fileStream = System.IO.File.Create(fileFullName, 4096, System.IO.FileOptions.None))
+            {
+                while (reader.End == false)
+                {
+                    var span = reader.CurrentSpan;
+                    fileStream.Write(span);
+                    reader.Advance(span.Length);
+                }
+            }
+
+            reader.SetConsumed(initialConsumed);
+        }
+
+        /// <summary>
+        /// Returns a reference to the desired value. This ref should always be used. The argument passed in <paramref name="copyDestinationIfRequiredDoNotUse"/> should never be used, as this is only used for storage if the value
+        /// must be copied from multiple <see cref="ReadOnlyMemory{Byte}"/> segments held by the <see cref="SequenceReader{Byte}"/>.
+        /// </summary>
+        /// <typeparam name="T">Type to get</typeparam>
+        /// <param name="reader">The <see cref="SequenceReader{Byte}"/> to read from</param>
+        /// <param name="copyDestinationIfRequiredDoNotUse">A location used as storage if (and only if) the value to be read spans multiple <see cref="ReadOnlyMemory{Byte}"/> segments</param>
+        /// <returns>A reference to the desired value, either directly to memory in the <see cref="SequenceReader{Byte}"/>, or to <paramref name="copyDestinationIfRequiredDoNotUse"/> if it has been used for copying the value in to</returns>
+        /// <remarks>
+        /// DO NOT use <paramref name="copyDestinationIfRequiredDoNotUse"/> after calling this method, as it will only
+        /// contain a value if the value couldn't be referenced directly because it spans multiple <see cref="ReadOnlyMemory{Byte}"/> segments.
+        /// To discourage use, it is recommended to call this method like the following:
+        /// <c>
+        ///     ref readonly MyStruct value = ref sequenceReader.GetRefOrRefToCopy{MyStruct}(out _);
+        /// </c>
+        /// </remarks>
+        /// <exception cref="ArgumentOutOfRangeException">The <see cref="SequenceReader{Byte}"/> does not contain enough data to read a value of type <typeparamref name="T"/></exception>
+        public static ref readonly T GetRefOrRefToCopy<T>(this scoped ref SequenceReader<byte> reader, out T copyDestinationIfRequiredDoNotUse) where T : unmanaged
+        {
+            int lengthRequired = Unsafe.SizeOf<T>();
+
+            ReadOnlySpan<byte> span = reader.UnreadSpan;
+            if (lengthRequired <= span.Length)
+            {
+                reader.Advance(lengthRequired);
+
+                copyDestinationIfRequiredDoNotUse = default;
+
+                ReadOnlySpan<T> spanOfT = MemoryMarshal.Cast<byte, T>(span);
+
+                return ref spanOfT[0];
+            }
+            else
+            {
+                copyDestinationIfRequiredDoNotUse = default;
+
+                Span<T> valueSpan = MemoryMarshal.CreateSpan(ref copyDestinationIfRequiredDoNotUse, 1);
+
+                Span<byte> valueBytesSpan = MemoryMarshal.AsBytes(valueSpan);
+
+                if (!reader.TryCopyTo(valueBytesSpan))
+                {
+                    throw new ArgumentOutOfRangeException(nameof(reader), "The sequence is not long enough to read the desired value.");
+                }
+
+                reader.Advance(lengthRequired);
+
+                return ref valueSpan[0];
+            }
+        }
+
+        /// <summary>
+        /// Reads an <see cref="int"/> as little endian.
+        /// </summary>
+        /// <param name="reader">The <see cref="SequenceReader{Byte}"/> to read from</param>
+        /// <param name="value">A location to receive the read value</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if there wasn't enough data for an <see cref="int"/></exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ReadLittleEndian(this ref SequenceReader<byte> reader, out int value)
+        {
+            if (!reader.TryReadLittleEndian(out value))
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "The sequence is not long enough to read the desired value.");
+            }
+        }
+
+        /// <summary>
+        /// Reads the desired unmanaged value by copying it to the specified <paramref name="value"/>.
+        /// </summary>
+        /// <typeparam name="T">Type to read</typeparam>
+        /// <param name="reader">The <see cref="SequenceReader{Byte}"/> to read from</param>
+        /// <param name="value">The target that will receive the read value</param>
+        /// <exception cref="ArgumentOutOfRangeException">The <see cref="SequenceReader{Byte}"/> does not contain enough data to read a value of type <typeparamref name="T"/></exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ReadUnmanaged<T>(this ref SequenceReader<byte> reader, out T value) where T : unmanaged
+        {
+            if (!reader.TryReadUnmanaged(out value))
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "The sequence is not long enough to read the desired value.");
+            }
+        }
+
+        /// <summary>
+        /// Sets the reader's position as bytes consumed.
+        /// </summary>
+        /// <param name="reader">The <see cref="SequenceReader{Byte}"/> to set the position</param>
+        /// <param name="consumed">The number of bytes consumed</param>
+        public static void SetConsumed(ref this SequenceReader<byte> reader, long consumed)
+        {
+            reader.Rewind(reader.Consumed);
+            reader.Advance(consumed);
+        }
+
+        /// <summary>
+        /// Try to read the given type out of the buffer if possible. Warning: this is dangerous to use with arbitrary
+        /// structs - see remarks for full details.
+        /// </summary>
+        /// <typeparam name="T">Type to read</typeparam>
+        /// <remarks>
+        /// IMPORTANT: The read is a straight copy of bits. If a struct depends on specific state of it's members to
+        /// behave correctly this can lead to exceptions, etc. If reading endian specific integers, use the explicit
+        /// overloads such as <see cref="SequenceReader{T}.TryReadLittleEndian"/>
+        /// </remarks>
+        /// <returns>
+        /// True if successful. <paramref name="value"/> will be default if failed (due to lack of space).
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe bool TryReadUnmanaged<T>(ref this SequenceReader<byte> reader, out T value) where T : unmanaged
+        {
+            ReadOnlySpan<byte> span = reader.UnreadSpan;
+
+            if (span.Length < sizeof(T))
+            {
+                return TryReadUnmanagedMultiSegment(ref reader, out value);
+            }
+
+            value = Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(span));
+
+            reader.Advance(sizeof(T));
+
+            return true;
+        }
+
+        private static unsafe bool TryReadUnmanagedMultiSegment<T>(ref SequenceReader<byte> reader, out T value) where T : unmanaged
+        {
+            Debug.Assert(reader.UnreadSpan.Length < sizeof(T));
+
+            // Not enough data in the current segment, try to peek for the data we need.
+            T buffer = default;
+
+            Span<byte> tempSpan = new Span<byte>(&buffer, sizeof(T));
+
+            if (!reader.TryCopyTo(tempSpan))
+            {
+                value = default;
+                return false;
+            }
+
+            value = Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(tempSpan));
+
+            reader.Advance(sizeof(T));
+
+            return true;
+        }
+    }
+}

src/Ryujinx.Common/GraphicsDriver/DriverUtilities.cs

@@ -1,13 +1,33 @@
+using Ryujinx.Common.Utilities;
 using System;
 
 namespace Ryujinx.Common.GraphicsDriver
 {
     public static class DriverUtilities
     {
+        private static void AddMesaFlags(string envVar, string newFlags)
+        {
+            string existingFlags = Environment.GetEnvironmentVariable(envVar);
+
+            string flags = existingFlags == null ? newFlags : $"{existingFlags},{newFlags}";
+
+            OsUtils.SetEnvironmentVariableNoCaching(envVar, flags);
+        }
+
+        public static void InitDriverConfig(bool oglThreading)
+        {
+            if (OperatingSystem.IsLinux())
+            {
+                AddMesaFlags("RADV_DEBUG", "nodcc");
+            }
+
+            ToggleOGLThreading(oglThreading);
+        }
+
         public static void ToggleOGLThreading(bool enabled)
         {
-            Environment.SetEnvironmentVariable("mesa_glthread", enabled.ToString().ToLower());
-            Environment.SetEnvironmentVariable("__GL_THREADED_OPTIMIZATIONS", enabled ? "1" : "0");
+            OsUtils.SetEnvironmentVariableNoCaching("mesa_glthread", enabled.ToString().ToLower());
+            OsUtils.SetEnvironmentVariableNoCaching("__GL_THREADED_OPTIMIZATIONS", enabled ? "1" : "0");
 
             try
             {

src/Ryujinx.Common/Memory/ByteMemoryPool.ByteMemoryPoolBuffer.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Buffers;
-using System.Threading;
-
-namespace Ryujinx.Common.Memory
-{
-    public sealed partial class ByteMemoryPool
-    {
-        /// <summary>
-        /// Represents a <see cref="IMemoryOwner{Byte}"/> that wraps an array rented from
-        /// <see cref="ArrayPool{Byte}.Shared"/> and exposes it as <see cref="Memory{Byte}"/>
-        /// with a length of the requested size.
-        /// </summary>
-        private sealed class ByteMemoryPoolBuffer : IMemoryOwner<byte>
-        {
-            private byte[] _array;
-            private readonly int _length;
-
-            public ByteMemoryPoolBuffer(int length)
-            {
-                _array = ArrayPool<byte>.Shared.Rent(length);
-                _length = length;
-            }
-
-            /// <summary>
-            /// Returns a <see cref="Memory{Byte}"/> belonging to this owner.
-            /// </summary>
-            public Memory<byte> Memory
-            {
-                get
-                {
-                    byte[] array = _array;
-
-                    ObjectDisposedException.ThrowIf(array is null, this);
-
-                    return new Memory<byte>(array, 0, _length);
-                }
-            }
-
-            public void Dispose()
-            {
-                var array = Interlocked.Exchange(ref _array, null);
-
-                if (array != null)
-                {
-                    ArrayPool<byte>.Shared.Return(array);
-                }
-            }
-        }
-    }
-}

src/Ryujinx.Common/Memory/ByteMemoryPool.cs

@@ -1,108 +0,0 @@
-using System;
-using System.Buffers;
-
-namespace Ryujinx.Common.Memory
-{
-    /// <summary>
-    /// Provides a pool of re-usable byte array instances.
-    /// </summary>
-    public sealed partial class ByteMemoryPool
-    {
-        private static readonly ByteMemoryPool _shared = new();
-
-        /// <summary>
-        /// Constructs a <see cref="ByteMemoryPool"/> instance. Private to force access through
-        /// the <see cref="ByteMemoryPool.Shared"/> instance.
-        /// </summary>
-        private ByteMemoryPool()
-        {
-            // No implementation
-        }
-
-        /// <summary>
-        /// Retrieves a shared <see cref="ByteMemoryPool"/> instance.
-        /// </summary>
-        public static ByteMemoryPool Shared => _shared;
-
-        /// <summary>
-        /// Returns the maximum buffer size supported by this pool.
-        /// </summary>
-        public static int MaxBufferSize => Array.MaxLength;
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer may contain data from a prior use.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> Rent(long length)
-            => RentImpl(checked((int)length));
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer may contain data from a prior use.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> Rent(ulong length)
-            => RentImpl(checked((int)length));
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer may contain data from a prior use.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> Rent(int length)
-            => RentImpl(length);
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer's contents are cleared (set to all 0s) before returning.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> RentCleared(long length)
-            => RentCleared(checked((int)length));
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer's contents are cleared (set to all 0s) before returning.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> RentCleared(ulong length)
-            => RentCleared(checked((int)length));
-
-        /// <summary>
-        /// Rents a byte memory buffer from <see cref="ArrayPool{Byte}.Shared"/>.
-        /// The buffer's contents are cleared (set to all 0s) before returning.
-        /// </summary>
-        /// <param name="length">The buffer's required length in bytes</param>
-        /// <returns>A <see cref="IMemoryOwner{Byte}"/> wrapping the rented memory</returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static IMemoryOwner<byte> RentCleared(int length)
-        {
-            var buffer = RentImpl(length);
-
-            buffer.Memory.Span.Clear();
-
-            return buffer;
-        }
-
-        private static ByteMemoryPoolBuffer RentImpl(int length)
-        {
-            if ((uint)length > Array.MaxLength)
-            {
-                throw new ArgumentOutOfRangeException(nameof(length), length, null);
-            }
-
-            return new ByteMemoryPoolBuffer(length);
-        }
-    }
-}

src/Ryujinx.Common/Memory/MemoryOwner.cs

@@ -0,0 +1,140 @@
+#nullable enable
+using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Ryujinx.Common.Memory
+{
+    /// <summary>
+    /// An <see cref="IMemoryOwner{T}"/> implementation with an embedded length and fast <see cref="Span{T}"/>
+    /// accessor, with memory allocated from <seealso cref="ArrayPool{T}.Shared"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of item to store.</typeparam>
+    public sealed class MemoryOwner<T> : IMemoryOwner<T>
+    {
+        private readonly int _length;
+        private T[]? _array;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MemoryOwner{T}"/> class with the specified parameters.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        private MemoryOwner(int length)
+        {
+            _length = length;
+            _array = ArrayPool<T>.Shared.Rent(length);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="MemoryOwner{T}"/> instance with the specified length.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        /// <returns>A <see cref="MemoryOwner{T}"/> instance of the requested length</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="length"/> is not valid</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MemoryOwner<T> Rent(int length) => new(length);
+
+        /// <summary>
+        /// Creates a new <see cref="MemoryOwner{T}"/> instance with the specified length and the content cleared.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        /// <returns>A <see cref="MemoryOwner{T}"/> instance of the requested length and the content cleared</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="length"/> is not valid</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MemoryOwner<T> RentCleared(int length)
+        {
+            MemoryOwner<T> result = new(length);
+
+            result._array.AsSpan(0, length).Clear();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="MemoryOwner{T}"/> instance with the content copied from the specified buffer.
+        /// </summary>
+        /// <param name="buffer">The buffer to copy</param>
+        /// <returns>A <see cref="MemoryOwner{T}"/> instance with the same length and content as <paramref name="buffer"/></returns>
+        public static MemoryOwner<T> RentCopy(ReadOnlySpan<T> buffer)
+        {
+            MemoryOwner<T> result = new(buffer.Length);
+
+            buffer.CopyTo(result._array);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the number of items in the current instance.
+        /// </summary>
+        public int Length
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _length;
+        }
+
+        /// <inheritdoc/>
+        public Memory<T> Memory
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                T[]? array = _array;
+
+                if (array is null)
+                {
+                    ThrowObjectDisposedException();
+                }
+
+                return new(array, 0, _length);
+            }
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Span{T}"/> wrapping the memory belonging to the current instance.
+        /// </summary>
+        /// <remarks>
+        /// Uses a trick made possible by the .NET 6+ runtime array layout.
+        /// </remarks>
+        public Span<T> Span
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                T[]? array = _array;
+
+                if (array is null)
+                {
+                    ThrowObjectDisposedException();
+                }
+
+                ref T firstElementRef = ref MemoryMarshal.GetArrayDataReference(array);
+
+                return MemoryMarshal.CreateSpan(ref firstElementRef, _length);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            T[]? array = Interlocked.Exchange(ref _array, null);
+
+            if (array is not null)
+            {
+                ArrayPool<T>.Shared.Return(array, RuntimeHelpers.IsReferenceOrContainsReferences<T>());
+            }
+        }
+
+        /// <summary>
+        /// Throws an <see cref="ObjectDisposedException"/> when <see cref="_array"/> is <see langword="null"/>.
+        /// </summary>
+        [DoesNotReturn]
+        private static void ThrowObjectDisposedException()
+        {
+            throw new ObjectDisposedException(nameof(MemoryOwner<T>), "The buffer has already been disposed.");
+        }
+    }
+}

src/Ryujinx.Common/Memory/SpanOrArray.cs

@@ -1,89 +0,0 @@
-using System;
-
-namespace Ryujinx.Common.Memory
-{
-    /// <summary>
-    /// A struct that can represent both a Span and Array.
-    /// This is useful to keep the Array representation when possible to avoid copies.
-    /// </summary>
-    /// <typeparam name="T">Element Type</typeparam>
-    public readonly ref struct SpanOrArray<T> where T : unmanaged
-    {
-        public readonly T[] Array;
-        public readonly ReadOnlySpan<T> Span;
-
-        /// <summary>
-        /// Create a new SpanOrArray from an array.
-        /// </summary>
-        /// <param name="array">Array to store</param>
-        public SpanOrArray(T[] array)
-        {
-            Array = array;
-            Span = ReadOnlySpan<T>.Empty;
-        }
-
-        /// <summary>
-        /// Create a new SpanOrArray from a readonly span.
-        /// </summary>
-        /// <param name="array">Span to store</param>
-        public SpanOrArray(ReadOnlySpan<T> span)
-        {
-            Array = null;
-            Span = span;
-        }
-
-        /// <summary>
-        /// Return the contained array, or convert the span if necessary.
-        /// </summary>
-        /// <returns>An array containing the data</returns>
-        public T[] ToArray()
-        {
-            return Array ?? Span.ToArray();
-        }
-
-        /// <summary>
-        /// Return a ReadOnlySpan from either the array or ReadOnlySpan.
-        /// </summary>
-        /// <returns>A ReadOnlySpan containing the data</returns>
-        public ReadOnlySpan<T> AsSpan()
-        {
-            return Array ?? Span;
-        }
-
-        /// <summary>
-        /// Cast an array to a SpanOrArray.
-        /// </summary>
-        /// <param name="array">Source array</param>
-        public static implicit operator SpanOrArray<T>(T[] array)
-        {
-            return new SpanOrArray<T>(array);
-        }
-
-        /// <summary>
-        /// Cast a ReadOnlySpan to a SpanOrArray.
-        /// </summary>
-        /// <param name="span">Source ReadOnlySpan</param>
-        public static implicit operator SpanOrArray<T>(ReadOnlySpan<T> span)
-        {
-            return new SpanOrArray<T>(span);
-        }
-
-        /// <summary>
-        /// Cast a Span to a SpanOrArray.
-        /// </summary>
-        /// <param name="span">Source Span</param>
-        public static implicit operator SpanOrArray<T>(Span<T> span)
-        {
-            return new SpanOrArray<T>(span);
-        }
-
-        /// <summary>
-        /// Cast a SpanOrArray to a ReadOnlySpan
-        /// </summary>
-        /// <param name="spanOrArray">Source SpanOrArray</param>
-        public static implicit operator ReadOnlySpan<T>(SpanOrArray<T> spanOrArray)
-        {
-            return spanOrArray.AsSpan();
-        }
-    }
-}

src/Ryujinx.Common/Memory/SpanOwner.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Common.Memory
+{
+    /// <summary>
+    /// A stack-only type that rents a buffer of a specified length from <seealso cref="ArrayPool{T}.Shared"/>.
+    /// It does not implement <see cref="IDisposable"/> to avoid being boxed, but should still be disposed. This
+    /// is easy since C# 8, which allows use of C# `using` constructs on any type that has a public Dispose() method.
+    /// To keep this type simple, fast, and read-only, it does not check or guard against multiple disposals.
+    /// For all these reasons, all usage should be with a `using` block or statement.
+    /// </summary>
+    /// <typeparam name="T">The type of item to store.</typeparam>
+    public readonly ref struct SpanOwner<T>
+    {
+        private readonly int _length;
+        private readonly T[] _array;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpanOwner{T}"/> struct with the specified parameters.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        private SpanOwner(int length)
+        {
+            _length = length;
+            _array = ArrayPool<T>.Shared.Rent(length);
+        }
+
+        /// <summary>
+        /// Gets an empty <see cref="SpanOwner{T}"/> instance.
+        /// </summary>
+        public static SpanOwner<T> Empty
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => new(0);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="SpanOwner{T}"/> instance with the specified length.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        /// <returns>A <see cref="SpanOwner{T}"/> instance of the requested length</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="length"/> is not valid</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SpanOwner<T> Rent(int length) => new(length);
+
+        /// <summary>
+        /// Creates a new <see cref="SpanOwner{T}"/> instance with the length and the content cleared.
+        /// </summary>
+        /// <param name="length">The length of the new memory buffer to use</param>
+        /// <returns>A <see cref="SpanOwner{T}"/> instance of the requested length and the content cleared</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="length"/> is not valid</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static SpanOwner<T> RentCleared(int length)
+        {
+            SpanOwner<T> result = new(length);
+
+            result._array.AsSpan(0, length).Clear();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="SpanOwner{T}"/> instance with the content copied from the specified buffer.
+        /// </summary>
+        /// <param name="buffer">The buffer to copy</param>
+        /// <returns>A <see cref="SpanOwner{T}"/> instance with the same length and content as <paramref name="buffer"/></returns>
+        public static SpanOwner<T> RentCopy(ReadOnlySpan<T> buffer)
+        {
+            SpanOwner<T> result = new(buffer.Length);
+
+            buffer.CopyTo(result._array);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the number of items in the current instance
+        /// </summary>
+        public int Length
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _length;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Span{T}"/> wrapping the memory belonging to the current instance.
+        /// </summary>
+        /// <remarks>
+        /// Uses a trick made possible by the .NET 6+ runtime array layout.
+        /// </remarks>
+        public Span<T> Span
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                ref T firstElementRef = ref MemoryMarshal.GetArrayDataReference(_array);
+
+                return MemoryMarshal.CreateSpan(ref firstElementRef, _length);
+            }
+        }
+
+        /// <summary>
+        /// Implements the duck-typed <see cref="IDisposable.Dispose"/> method.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            ArrayPool<T>.Shared.Return(_array, RuntimeHelpers.IsReferenceOrContainsReferences<T>());
+        }
+    }
+}

src/Ryujinx.Common/Utilities/EmbeddedResources.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Memory;
 using Ryujinx.Common.Utilities;
 using System;
 using System.IO;
@@ -41,6 +42,22 @@ namespace Ryujinx.Common
             return StreamUtils.StreamToBytes(stream);
         }
 
+        public static MemoryOwner<byte> ReadFileToRentedMemory(string filename)
+        {
+            var (assembly, path) = ResolveManifestPath(filename);
+
+            return ReadFileToRentedMemory(assembly, path);
+        }
+
+        public static MemoryOwner<byte> ReadFileToRentedMemory(Assembly assembly, string filename)
+        {
+            using var stream = GetStream(assembly, filename);
+
+            return stream is null
+                ? null
+                : StreamUtils.StreamToRentedMemory(stream);
+        }
+
         public async static Task<byte[]> ReadAsync(Assembly assembly, string filename)
         {
             using var stream = GetStream(assembly, filename);

src/Ryujinx.Common/Utilities/OsUtils.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Common.Utilities
+{
+    public partial class OsUtils
+    {
+        [LibraryImport("libc", SetLastError = true)]
+        private static partial int setenv([MarshalAs(UnmanagedType.LPStr)] string name, [MarshalAs(UnmanagedType.LPStr)] string value, int overwrite);
+
+        public static void SetEnvironmentVariableNoCaching(string key, string value)
+        {
+            // Set the value in the cached environment variables, too.
+            Environment.SetEnvironmentVariable(key, value);
+
+            if (!OperatingSystem.IsWindows())
+            {
+                int res = setenv(key, value, 1);
+                Debug.Assert(res != -1);
+            }
+        }
+    }
+}

src/Ryujinx.Common/Utilities/StreamUtils.cs

@@ -1,3 +1,4 @@
+using Microsoft.IO;
 using Ryujinx.Common.Memory;
 using System.IO;
 using System.Threading;
@@ -9,12 +10,50 @@ namespace Ryujinx.Common.Utilities
     {
         public static byte[] StreamToBytes(Stream input)
         {
-            using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
+            using RecyclableMemoryStream output = StreamToRecyclableMemoryStream(input);
 
+            return output.ToArray();
+        }
 
-            input.CopyTo(stream);
+        public static MemoryOwner<byte> StreamToRentedMemory(Stream input)
+        {
+            if (input is MemoryStream inputMemoryStream)
+            {
+                return MemoryStreamToRentedMemory(inputMemoryStream);
+            }
+            else if (input.CanSeek)
+            {
+                long bytesExpected = input.Length;
 
-            return stream.ToArray();
+                MemoryOwner<byte> ownedMemory = MemoryOwner<byte>.Rent(checked((int)bytesExpected));
+
+                var destSpan = ownedMemory.Span;
+
+                int totalBytesRead = 0;
+
+                while (totalBytesRead < bytesExpected)
+                {
+                    int bytesRead = input.Read(destSpan[totalBytesRead..]);
+
+                    if (bytesRead == 0)
+                    {
+                        ownedMemory.Dispose();
+
+                        throw new IOException($"Tried reading {bytesExpected} but the stream closed after reading {totalBytesRead}.");
+                    }
+
+                    totalBytesRead += bytesRead;
+                }
+
+                return ownedMemory;
+            }
+            else
+            {
+                // If input is (non-seekable) then copy twice: first into a RecyclableMemoryStream, then to a rented IMemoryOwner<byte>.
+                using RecyclableMemoryStream output = StreamToRecyclableMemoryStream(input);
+
+                return MemoryStreamToRentedMemory(output);
+            }
         }
 
         public static async Task<byte[]> StreamToBytesAsync(Stream input, CancellationToken cancellationToken = default)
@@ -25,5 +64,26 @@ namespace Ryujinx.Common.Utilities
 
             return stream.ToArray();
         }
+
+        private static MemoryOwner<byte> MemoryStreamToRentedMemory(MemoryStream input)
+        {
+            input.Position = 0;
+
+            MemoryOwner<byte> ownedMemory = MemoryOwner<byte>.Rent(checked((int)input.Length));
+
+            // Discard the return value because we assume reading a MemoryStream always succeeds completely.
+            _ = input.Read(ownedMemory.Span);
+
+            return ownedMemory;
+        }
+
+        private static RecyclableMemoryStream StreamToRecyclableMemoryStream(Stream input)
+        {
+            RecyclableMemoryStream stream = MemoryStreamManager.Shared.GetStream();
+
+            input.CopyTo(stream);
+
+            return stream;
+        }
     }
 }

src/Ryujinx.Cpu/AddressSpace.cs

@@ -1,5 +1,3 @@
-using Ryujinx.Common;
-using Ryujinx.Common.Collections;
 using Ryujinx.Memory;
 using System;
 
@@ -7,175 +5,23 @@ namespace Ryujinx.Cpu
 {
     public class AddressSpace : IDisposable
     {
-        private const int DefaultBlockAlignment = 1 << 20;
-
-        private enum MappingType : byte
-        {
-            None,
-            Private,
-            Shared,
-        }
-
-        private class Mapping : IntrusiveRedBlackTreeNode<Mapping>, IComparable<Mapping>
-        {
-            public ulong Address { get; private set; }
-            public ulong Size { get; private set; }
-            public ulong EndAddress => Address + Size;
-            public MappingType Type { get; private set; }
-
-            public Mapping(ulong address, ulong size, MappingType type)
-            {
-                Address = address;
-                Size = size;
-                Type = type;
-            }
-
-            public Mapping Split(ulong splitAddress)
-            {
-                ulong leftSize = splitAddress - Address;
-                ulong rightSize = EndAddress - splitAddress;
-
-                Mapping left = new(Address, leftSize, Type);
-
-                Address = splitAddress;
-                Size = rightSize;
-
-                return left;
-            }
-
-            public void UpdateState(MappingType newType)
-            {
-                Type = newType;
-            }
-
-            public void Extend(ulong sizeDelta)
-            {
-                Size += sizeDelta;
-            }
-
-            public int CompareTo(Mapping other)
-            {
-                if (Address < other.Address)
-                {
-                    return -1;
-                }
-                else if (Address <= other.EndAddress - 1UL)
-                {
-                    return 0;
-                }
-                else
-                {
-                    return 1;
-                }
-            }
-        }
-
-        private class PrivateMapping : IntrusiveRedBlackTreeNode<PrivateMapping>, IComparable<PrivateMapping>
-        {
-            public ulong Address { get; private set; }
-            public ulong Size { get; private set; }
-            public ulong EndAddress => Address + Size;
-            public PrivateMemoryAllocation PrivateAllocation { get; private set; }
-
-            public PrivateMapping(ulong address, ulong size, PrivateMemoryAllocation privateAllocation)
-            {
-                Address = address;
-                Size = size;
-                PrivateAllocation = privateAllocation;
-            }
-
-            public PrivateMapping Split(ulong splitAddress)
-            {
-                ulong leftSize = splitAddress - Address;
-                ulong rightSize = EndAddress - splitAddress;
-
-                (var leftAllocation, PrivateAllocation) = PrivateAllocation.Split(leftSize);
-
-                PrivateMapping left = new(Address, leftSize, leftAllocation);
-
-                Address = splitAddress;
-                Size = rightSize;
-
-                return left;
-            }
-
-            public void Map(MemoryBlock baseBlock, MemoryBlock mirrorBlock, PrivateMemoryAllocation newAllocation)
-            {
-                baseBlock.MapView(newAllocation.Memory, newAllocation.Offset, Address, Size);
-                mirrorBlock.MapView(newAllocation.Memory, newAllocation.Offset, Address, Size);
-                PrivateAllocation = newAllocation;
-            }
-
-            public void Unmap(MemoryBlock baseBlock, MemoryBlock mirrorBlock)
-            {
-                if (PrivateAllocation.IsValid)
-                {
-                    baseBlock.UnmapView(PrivateAllocation.Memory, Address, Size);
-                    mirrorBlock.UnmapView(PrivateAllocation.Memory, Address, Size);
-                    PrivateAllocation.Dispose();
-                }
-
-                PrivateAllocation = default;
-            }
-
-            public void Extend(ulong sizeDelta)
-            {
-                Size += sizeDelta;
-            }
-
-            public int CompareTo(PrivateMapping other)
-            {
-                if (Address < other.Address)
-                {
-                    return -1;
-                }
-                else if (Address <= other.EndAddress - 1UL)
-                {
-                    return 0;
-                }
-                else
-                {
-                    return 1;
-                }
-            }
-        }
-
         private readonly MemoryBlock _backingMemory;
-        private readonly PrivateMemoryAllocator _privateMemoryAllocator;
-        private readonly IntrusiveRedBlackTree<Mapping> _mappingTree;
-        private readonly IntrusiveRedBlackTree<PrivateMapping> _privateTree;
-
-        private readonly object _treeLock;
-
-        private readonly bool _supports4KBPages;
 
         public MemoryBlock Base { get; }
         public MemoryBlock Mirror { get; }
 
         public ulong AddressSpaceSize { get; }
 
-        public AddressSpace(MemoryBlock backingMemory, MemoryBlock baseMemory, MemoryBlock mirrorMemory, ulong addressSpaceSize, bool supports4KBPages)
+        public AddressSpace(MemoryBlock backingMemory, MemoryBlock baseMemory, MemoryBlock mirrorMemory, ulong addressSpaceSize)
         {
-            if (!supports4KBPages)
-            {
-                _privateMemoryAllocator = new PrivateMemoryAllocator(DefaultBlockAlignment, MemoryAllocationFlags.Mirrorable | MemoryAllocationFlags.NoMap);
-                _mappingTree = new IntrusiveRedBlackTree<Mapping>();
-                _privateTree = new IntrusiveRedBlackTree<PrivateMapping>();
-                _treeLock = new object();
-
-                _mappingTree.Add(new Mapping(0UL, addressSpaceSize, MappingType.None));
-                _privateTree.Add(new PrivateMapping(0UL, addressSpaceSize, default));
-            }
-
             _backingMemory = backingMemory;
-            _supports4KBPages = supports4KBPages;
 
             Base = baseMemory;
             Mirror = mirrorMemory;
             AddressSpaceSize = addressSpaceSize;
         }
 
-        public static bool TryCreate(MemoryBlock backingMemory, ulong asSize, bool supports4KBPages, out AddressSpace addressSpace)
+        public static bool TryCreate(MemoryBlock backingMemory, ulong asSize, out AddressSpace addressSpace)
         {
             addressSpace = null;
 
@@ -193,7 +39,7 @@ namespace Ryujinx.Cpu
                 {
                     baseMemory = new MemoryBlock(addressSpaceSize, AsFlags);
                     mirrorMemory = new MemoryBlock(addressSpaceSize, AsFlags);
-                    addressSpace = new AddressSpace(backingMemory, baseMemory, mirrorMemory, addressSpaceSize, supports4KBPages);
+                    addressSpace = new AddressSpace(backingMemory, baseMemory, mirrorMemory, addressSpaceSize);
 
                     break;
                 }
@@ -209,289 +55,20 @@ namespace Ryujinx.Cpu
 
         public void Map(ulong va, ulong pa, ulong size, MemoryMapFlags flags)
         {
-            if (_supports4KBPages)
-            {
-                Base.MapView(_backingMemory, pa, va, size);
-                Mirror.MapView(_backingMemory, pa, va, size);
-
-                return;
-            }
-
-            lock (_treeLock)
-            {
-                ulong alignment = MemoryBlock.GetPageSize();
-                bool isAligned = ((va | pa | size) & (alignment - 1)) == 0;
-
-                if (flags.HasFlag(MemoryMapFlags.Private) && !isAligned)
-                {
-                    Update(va, pa, size, MappingType.Private);
-                }
-                else
-                {
-                    // The update method assumes that shared mappings are already aligned.
-
-                    if (!flags.HasFlag(MemoryMapFlags.Private))
-                    {
-                        if ((va & (alignment - 1)) != (pa & (alignment - 1)))
-                        {
-                            throw new InvalidMemoryRegionException($"Virtual address 0x{va:X} and physical address 0x{pa:X} are misaligned and can't be aligned.");
-                        }
-
-                        ulong endAddress = va + size;
-                        va = BitUtils.AlignDown(va, alignment);
-                        pa = BitUtils.AlignDown(pa, alignment);
-                        size = BitUtils.AlignUp(endAddress, alignment) - va;
-                    }
-
-                    Update(va, pa, size, MappingType.Shared);
-                }
-            }
+            Base.MapView(_backingMemory, pa, va, size);
+            Mirror.MapView(_backingMemory, pa, va, size);
         }
 
         public void Unmap(ulong va, ulong size)
         {
-            if (_supports4KBPages)
-            {
-                Base.UnmapView(_backingMemory, va, size);
-                Mirror.UnmapView(_backingMemory, va, size);
-
-                return;
-            }
-
-            lock (_treeLock)
-            {
-                Update(va, 0UL, size, MappingType.None);
-            }
-        }
-
-        private void Update(ulong va, ulong pa, ulong size, MappingType type)
-        {
-            Mapping map = _mappingTree.GetNode(new Mapping(va, 1UL, MappingType.None));
-
-            Update(map, va, pa, size, type);
-        }
-
-        private Mapping Update(Mapping map, ulong va, ulong pa, ulong size, MappingType type)
-        {
-            ulong endAddress = va + size;
-
-            for (; map != null; map = map.Successor)
-            {
-                if (map.Address < va)
-                {
-                    _mappingTree.Add(map.Split(va));
-                }
-
-                if (map.EndAddress > endAddress)
-                {
-                    Mapping newMap = map.Split(endAddress);
-                    _mappingTree.Add(newMap);
-                    map = newMap;
-                }
-
-                switch (type)
-                {
-                    case MappingType.None:
-                        if (map.Type == MappingType.Shared)
-                        {
-                            ulong startOffset = map.Address - va;
-                            ulong mapVa = va + startOffset;
-                            ulong mapSize = Math.Min(size - startOffset, map.Size);
-                            ulong mapEndAddress = mapVa + mapSize;
-                            ulong alignment = MemoryBlock.GetPageSize();
-
-                            mapVa = BitUtils.AlignDown(mapVa, alignment);
-                            mapEndAddress = BitUtils.AlignUp(mapEndAddress, alignment);
-
-                            mapSize = mapEndAddress - mapVa;
-
-                            Base.UnmapView(_backingMemory, mapVa, mapSize);
-                            Mirror.UnmapView(_backingMemory, mapVa, mapSize);
-                        }
-                        else
-                        {
-                            UnmapPrivate(va, size);
-                        }
-                        break;
-                    case MappingType.Private:
-                        if (map.Type == MappingType.Shared)
-                        {
-                            throw new InvalidMemoryRegionException($"Private mapping request at 0x{va:X} with size 0x{size:X} overlaps shared mapping at 0x{map.Address:X} with size 0x{map.Size:X}.");
-                        }
-                        else
-                        {
-                            MapPrivate(va, size);
-                        }
-                        break;
-                    case MappingType.Shared:
-                        if (map.Type != MappingType.None)
-                        {
-                            throw new InvalidMemoryRegionException($"Shared mapping request at 0x{va:X} with size 0x{size:X} overlaps mapping at 0x{map.Address:X} with size 0x{map.Size:X}.");
-                        }
-                        else
-                        {
-                            ulong startOffset = map.Address - va;
-                            ulong mapPa = pa + startOffset;
-                            ulong mapVa = va + startOffset;
-                            ulong mapSize = Math.Min(size - startOffset, map.Size);
-
-                            Base.MapView(_backingMemory, mapPa, mapVa, mapSize);
-                            Mirror.MapView(_backingMemory, mapPa, mapVa, mapSize);
-                        }
-                        break;
-                }
-
-                map.UpdateState(type);
-                map = TryCoalesce(map);
-
-                if (map.EndAddress >= endAddress)
-                {
-                    break;
-                }
-            }
-
-            return map;
-        }
-
-        private Mapping TryCoalesce(Mapping map)
-        {
-            Mapping previousMap = map.Predecessor;
-            Mapping nextMap = map.Successor;
-
-            if (previousMap != null && CanCoalesce(previousMap, map))
-            {
-                previousMap.Extend(map.Size);
-                _mappingTree.Remove(map);
-                map = previousMap;
-            }
-
-            if (nextMap != null && CanCoalesce(map, nextMap))
-            {
-                map.Extend(nextMap.Size);
-                _mappingTree.Remove(nextMap);
-            }
-
-            return map;
-        }
-
-        private static bool CanCoalesce(Mapping left, Mapping right)
-        {
-            return left.Type == right.Type;
-        }
-
-        private void MapPrivate(ulong va, ulong size)
-        {
-            ulong endAddress = va + size;
-
-            ulong alignment = MemoryBlock.GetPageSize();
-
-            // Expand the range outwards based on page size to ensure that at least the requested region is mapped.
-            ulong vaAligned = BitUtils.AlignDown(va, alignment);
-            ulong endAddressAligned = BitUtils.AlignUp(endAddress, alignment);
-
-            PrivateMapping map = _privateTree.GetNode(new PrivateMapping(va, 1UL, default));
-
-            for (; map != null; map = map.Successor)
-            {
-                if (!map.PrivateAllocation.IsValid)
-                {
-                    if (map.Address < vaAligned)
-                    {
-                        _privateTree.Add(map.Split(vaAligned));
-                    }
-
-                    if (map.EndAddress > endAddressAligned)
-                    {
-                        PrivateMapping newMap = map.Split(endAddressAligned);
-                        _privateTree.Add(newMap);
-                        map = newMap;
-                    }
-
-                    map.Map(Base, Mirror, _privateMemoryAllocator.Allocate(map.Size, MemoryBlock.GetPageSize()));
-                }
-
-                if (map.EndAddress >= endAddressAligned)
-                {
-                    break;
-                }
-            }
-        }
-
-        private void UnmapPrivate(ulong va, ulong size)
-        {
-            ulong endAddress = va + size;
-
-            ulong alignment = MemoryBlock.GetPageSize();
-
-            // Shrink the range inwards based on page size to ensure we won't unmap memory that might be still in use.
-            ulong vaAligned = BitUtils.AlignUp(va, alignment);
-            ulong endAddressAligned = BitUtils.AlignDown(endAddress, alignment);
-
-            if (endAddressAligned <= vaAligned)
-            {
-                return;
-            }
-
-            PrivateMapping map = _privateTree.GetNode(new PrivateMapping(va, 1UL, default));
-
-            for (; map != null; map = map.Successor)
-            {
-                if (map.PrivateAllocation.IsValid)
-                {
-                    if (map.Address < vaAligned)
-                    {
-                        _privateTree.Add(map.Split(vaAligned));
-                    }
-
-                    if (map.EndAddress > endAddressAligned)
-                    {
-                        PrivateMapping newMap = map.Split(endAddressAligned);
-                        _privateTree.Add(newMap);
-                        map = newMap;
-                    }
-
-                    map.Unmap(Base, Mirror);
-                    map = TryCoalesce(map);
-                }
-
-                if (map.EndAddress >= endAddressAligned)
-                {
-                    break;
-                }
-            }
-        }
-
-        private PrivateMapping TryCoalesce(PrivateMapping map)
-        {
-            PrivateMapping previousMap = map.Predecessor;
-            PrivateMapping nextMap = map.Successor;
-
-            if (previousMap != null && CanCoalesce(previousMap, map))
-            {
-                previousMap.Extend(map.Size);
-                _privateTree.Remove(map);
-                map = previousMap;
-            }
-
-            if (nextMap != null && CanCoalesce(map, nextMap))
-            {
-                map.Extend(nextMap.Size);
-                _privateTree.Remove(nextMap);
-            }
-
-            return map;
-        }
-
-        private static bool CanCoalesce(PrivateMapping left, PrivateMapping right)
-        {
-            return !left.PrivateAllocation.IsValid && !right.PrivateAllocation.IsValid;
+            Base.UnmapView(_backingMemory, va, size);
+            Mirror.UnmapView(_backingMemory, va, size);
         }
 
         public void Dispose()
         {
             GC.SuppressFinalize(this);
 
-            _privateMemoryAllocator?.Dispose();
             Base.Dispose();
             Mirror.Dispose();
         }

src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs

@@ -3,10 +3,10 @@ using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 
 namespace Ryujinx.Cpu.AppleHv
@@ -15,7 +15,7 @@ namespace Ryujinx.Cpu.AppleHv
     /// Represents a CPU memory manager which maps guest virtual memory directly onto the Hypervisor page table.
     /// </summary>
     [SupportedOSPlatform("macos")]
-    public class HvMemoryManager : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public sealed class HvMemoryManager : VirtualMemoryManagerRefCountedBase, IMemoryManager, IVirtualMemoryManagerTracked
     {
         private readonly InvalidAccessHandler _invalidAccessHandler;
 
@@ -28,7 +28,7 @@ namespace Ryujinx.Cpu.AppleHv
 
         private readonly ManagedPageFlags _pages;
 
-        public bool Supports4KBPages => true;
+        public bool UsesPrivateAllocations => false;
 
         public int AddressSpaceBits { get; }
 
@@ -96,12 +96,6 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-        /// <inheritdoc/>
-        public void MapForeign(ulong va, nuint hostPointer, ulong size)
-        {
-            throw new NotSupportedException();
-        }
-
         /// <inheritdoc/>
         public void Unmap(ulong va, ulong size)
         {
@@ -126,20 +120,11 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-        /// <inheritdoc/>
-        public T Read<T>(ulong va) where T : unmanaged
-        {
-            return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
-        }
-
-        /// <inheritdoc/>
-        public T ReadTracked<T>(ulong va) where T : unmanaged
+        public override T ReadTracked<T>(ulong va)
         {
             try
             {
-                SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
-
-                return Read<T>(va);
+                return base.ReadTracked<T>(va);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -152,7 +137,6 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-        /// <inheritdoc/>
         public override void Read(ulong va, Span<byte> data)
         {
             try
@@ -168,101 +152,11 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-        /// <inheritdoc/>
-        public void Write<T>(ulong va, T value) where T : unmanaged
-        {
-            Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
-        }
-
-        /// <inheritdoc/>
-        public void Write(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            SignalMemoryTracking(va, (ulong)data.Length, true);
-
-            WriteImpl(va, data);
-        }
-
-        /// <inheritdoc/>
-        public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            WriteImpl(va, data);
-        }
-
-        /// <inheritdoc/>
-        public bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return false;
-            }
-
-            SignalMemoryTracking(va, (ulong)data.Length, false);
-
-            if (IsContiguousAndMapped(va, data.Length))
-            {
-                var target = _backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length);
-
-                bool changed = !data.SequenceEqual(target);
-
-                if (changed)
-                {
-                    data.CopyTo(target);
-                }
-
-                return changed;
-            }
-            else
-            {
-                WriteImpl(va, data);
-
-                return true;
-            }
-        }
-
-        private void WriteImpl(ulong va, ReadOnlySpan<byte> data)
+        public override void Write(ulong va, ReadOnlySpan<byte> data)
         {
             try
             {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                if (IsContiguousAndMapped(va, data.Length))
-                {
-                    data.CopyTo(_backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length));
-                }
-                else
-                {
-                    int offset = 0, size;
-
-                    if ((va & PageMask) != 0)
-                    {
-                        ulong pa = GetPhysicalAddressChecked(va);
-
-                        size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
-
-                        data[..size].CopyTo(_backingMemory.GetSpan(pa, size));
-
-                        offset += size;
-                    }
-
-                    for (; offset < data.Length; offset += size)
-                    {
-                        ulong pa = GetPhysicalAddressChecked(va + (ulong)offset);
-
-                        size = Math.Min(data.Length - offset, PageSize);
-
-                        data.Slice(offset, size).CopyTo(_backingMemory.GetSpan(pa, size));
-                    }
-                }
+                base.Write(va, data);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -273,61 +167,38 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-        /// <inheritdoc/>
-        public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
+        public override void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
         {
-            if (size == 0)
+            try
             {
-                return ReadOnlySpan<byte>.Empty;
+                base.WriteUntracked(va, data);
             }
-
-            if (tracked)
+            catch (InvalidMemoryRegionException)
             {
-                SignalMemoryTracking(va, (ulong)size, false);
-            }
-
-            if (IsContiguousAndMapped(va, size))
-            {
-                return _backingMemory.GetSpan(GetPhysicalAddressInternal(va), size);
-            }
-            else
-            {
-                Span<byte> data = new byte[size];
-
-                base.Read(va, data);
-
-                return data;
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
             }
         }
 
-        /// <inheritdoc/>
-        public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
+        public override ReadOnlySequence<byte> GetReadOnlySequence(ulong va, int size, bool tracked = false)
         {
-            if (size == 0)
+            try
             {
-                return new WritableRegion(null, va, Memory<byte>.Empty);
+                return base.GetReadOnlySequence(va, size, tracked);
             }
-
-            if (tracked)
+            catch (InvalidMemoryRegionException)
             {
-                SignalMemoryTracking(va, (ulong)size, true);
-            }
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
 
-            if (IsContiguousAndMapped(va, size))
-            {
-                return new WritableRegion(null, va, _backingMemory.GetMemory(GetPhysicalAddressInternal(va), size));
-            }
-            else
-            {
-                Memory<byte> memory = new byte[size];
-
-                base.Read(va, memory.Span);
-
-                return new WritableRegion(this, va, memory);
+                return ReadOnlySequence<byte>.Empty;
             }
         }
 
-        /// <inheritdoc/>
         public ref T GetRef<T>(ulong va) where T : unmanaged
         {
             if (!IsContiguous(va, Unsafe.SizeOf<T>()))
@@ -340,9 +211,8 @@ namespace Ryujinx.Cpu.AppleHv
             return ref _backingMemory.GetRef<T>(GetPhysicalAddressChecked(va));
         }
 
-        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool IsMapped(ulong va)
+        public override bool IsMapped(ulong va)
         {
             return ValidateAddress(va) && _pages.IsMapped(va);
         }
@@ -355,39 +225,6 @@ namespace Ryujinx.Cpu.AppleHv
             return _pages.IsRangeMapped(va, size);
         }
 
-        private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsContiguous(ulong va, int size)
-        {
-            if (!ValidateAddress(va) || !ValidateAddressAndSize(va, (ulong)size))
-            {
-                return false;
-            }
-
-            int pages = GetPagesCount(va, (uint)size, out va);
-
-            for (int page = 0; page < pages - 1; page++)
-            {
-                if (!ValidateAddress(va + PageSize))
-                {
-                    return false;
-                }
-
-                if (GetPhysicalAddressInternal(va) + PageSize != GetPhysicalAddressInternal(va + PageSize))
-                {
-                    return false;
-                }
-
-                va += PageSize;
-            }
-
-            return true;
-        }
-
         /// <inheritdoc/>
         public IEnumerable<HostMemoryRange> GetHostRegions(ulong va, ulong size)
         {
@@ -464,11 +301,10 @@ namespace Ryujinx.Cpu.AppleHv
             return regions;
         }
 
-        /// <inheritdoc/>
         /// <remarks>
         /// This function also validates that the given range is both valid and mapped, and will throw if it is not.
         /// </remarks>
-        public void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
+        public override void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
         {
             AssertValidAddressAndSize(va, size);
 
@@ -481,24 +317,6 @@ namespace Ryujinx.Cpu.AppleHv
             _pages.SignalMemoryTracking(Tracking, va, size, write, exemptId);
         }
 
-        /// <summary>
-        /// Computes the number of pages in a virtual address range.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range</param>
-        /// <param name="startVa">The virtual address of the beginning of the first page</param>
-        /// <remarks>This function does not differentiate between allocated and unallocated pages.</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetPagesCount(ulong va, ulong size, out ulong startVa)
-        {
-            // WARNING: Always check if ulong does not overflow during the operations.
-            startVa = va & ~(ulong)PageMask;
-            ulong vaSpan = (va - startVa + size + PageMask) & ~(ulong)PageMask;
-
-            return (int)(vaSpan / PageSize);
-        }
-
-        /// <inheritdoc/>
         public void Reprotect(ulong va, ulong size, MemoryPermission protection)
         {
             // TODO
@@ -535,7 +353,7 @@ namespace Ryujinx.Cpu.AppleHv
             return Tracking.BeginSmartGranularTracking(address, size, granularity, id);
         }
 
-        private ulong GetPhysicalAddressChecked(ulong va)
+        private nuint GetPhysicalAddressChecked(ulong va)
         {
             if (!IsMapped(va))
             {
@@ -545,9 +363,9 @@ namespace Ryujinx.Cpu.AppleHv
             return GetPhysicalAddressInternal(va);
         }
 
-        private ulong GetPhysicalAddressInternal(ulong va)
+        private nuint GetPhysicalAddressInternal(ulong va)
         {
-            return _pageTable.Read(va) + (va & PageMask);
+            return (nuint)(_pageTable.Read(va) + (va & PageMask));
         }
 
         /// <summary>
@@ -558,10 +376,17 @@ namespace Ryujinx.Cpu.AppleHv
             _addressSpace.Dispose();
         }
 
-        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+        protected override Memory<byte> GetPhysicalAddressMemory(nuint pa, int size)
+            => _backingMemory.GetMemory(pa, size);
+
+        protected override Span<byte> GetPhysicalAddressSpan(nuint pa, int size)
             => _backingMemory.GetSpan(pa, size);
 
-        protected override ulong TranslateVirtualAddressForRead(ulong va)
+        protected override nuint TranslateVirtualAddressChecked(ulong va)
             => GetPhysicalAddressChecked(va);
+
+        protected override nuint TranslateVirtualAddressUnchecked(ulong va)
+            => GetPhysicalAddressInternal(va);
+
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManager.cs

@@ -3,6 +3,7 @@ using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
@@ -14,7 +15,7 @@ namespace Ryujinx.Cpu.Jit
     /// <summary>
     /// Represents a CPU memory manager.
     /// </summary>
-    public sealed class MemoryManager : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public sealed class MemoryManager : VirtualMemoryManagerRefCountedBase, IMemoryManager, IVirtualMemoryManagerTracked
     {
         private const int PteSize = 8;
 
@@ -24,7 +25,7 @@ namespace Ryujinx.Cpu.Jit
         private readonly InvalidAccessHandler _invalidAccessHandler;
 
         /// <inheritdoc/>
-        public bool Supports4KBPages => true;
+        public bool UsesPrivateAllocations => false;
 
         /// <summary>
         /// Address space width in bits.
@@ -97,12 +98,6 @@ namespace Ryujinx.Cpu.Jit
             Tracking.Map(oVa, size);
         }
 
-        /// <inheritdoc/>
-        public void MapForeign(ulong va, nuint hostPointer, ulong size)
-        {
-            throw new NotSupportedException();
-        }
-
         /// <inheritdoc/>
         public void Unmap(ulong va, ulong size)
         {
@@ -128,20 +123,11 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public T Read<T>(ulong va) where T : unmanaged
-        {
-            return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
-        }
-
-        /// <inheritdoc/>
-        public T ReadTracked<T>(ulong va) where T : unmanaged
+        public override T ReadTracked<T>(ulong va)
         {
             try
             {
-                SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
-
-                return Read<T>(va);
+                return base.ReadTracked<T>(va);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -190,117 +176,11 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public void Write<T>(ulong va, T value) where T : unmanaged
-        {
-            Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
-        }
-
-        /// <inheritdoc/>
-        public void Write(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            SignalMemoryTracking(va, (ulong)data.Length, true);
-
-            WriteImpl(va, data);
-        }
-
-        /// <inheritdoc/>
-        public void WriteGuest<T>(ulong va, T value) where T : unmanaged
-        {
-            Span<byte> data = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1));
-
-            SignalMemoryTrackingImpl(va, (ulong)data.Length, true, true);
-
-            WriteImpl(va, data);
-        }
-
-        /// <inheritdoc/>
-        public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            WriteImpl(va, data);
-        }
-
-        /// <inheritdoc/>
-        public bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return false;
-            }
-
-            SignalMemoryTracking(va, (ulong)data.Length, false);
-
-            if (IsContiguousAndMapped(va, data.Length))
-            {
-                var target = _backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length);
-
-                bool changed = !data.SequenceEqual(target);
-
-                if (changed)
-                {
-                    data.CopyTo(target);
-                }
-
-                return changed;
-            }
-            else
-            {
-                WriteImpl(va, data);
-
-                return true;
-            }
-        }
-
-        /// <summary>
-        /// Writes data to CPU mapped memory.
-        /// </summary>
-        /// <param name="va">Virtual address to write the data into</param>
-        /// <param name="data">Data to be written</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void WriteImpl(ulong va, ReadOnlySpan<byte> data)
+        public override void Write(ulong va, ReadOnlySpan<byte> data)
         {
             try
             {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                if (IsContiguousAndMapped(va, data.Length))
-                {
-                    data.CopyTo(_backingMemory.GetSpan(GetPhysicalAddressInternal(va), data.Length));
-                }
-                else
-                {
-                    int offset = 0, size;
-
-                    if ((va & PageMask) != 0)
-                    {
-                        ulong pa = GetPhysicalAddressInternal(va);
-
-                        size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
-
-                        data[..size].CopyTo(_backingMemory.GetSpan(pa, size));
-
-                        offset += size;
-                    }
-
-                    for (; offset < data.Length; offset += size)
-                    {
-                        ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
-
-                        size = Math.Min(data.Length - offset, PageSize);
-
-                        data.Slice(offset, size).CopyTo(_backingMemory.GetSpan(pa, size));
-                    }
-                }
+                base.Write(va, data);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -312,60 +192,47 @@ namespace Ryujinx.Cpu.Jit
         }
 
         /// <inheritdoc/>
-        public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
+        public void WriteGuest<T>(ulong va, T value) where T : unmanaged
         {
-            if (size == 0)
+            Span<byte> data = MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1));
+
+            SignalMemoryTrackingImpl(va, (ulong)data.Length, true, true);
+
+            Write(va, data);
+        }
+
+        public override void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
+        {
+            try
             {
-                return ReadOnlySpan<byte>.Empty;
+                base.WriteUntracked(va, data);
             }
-
-            if (tracked)
+            catch (InvalidMemoryRegionException)
             {
-                SignalMemoryTracking(va, (ulong)size, false);
-            }
-
-            if (IsContiguousAndMapped(va, size))
-            {
-                return _backingMemory.GetSpan(GetPhysicalAddressInternal(va), size);
-            }
-            else
-            {
-                Span<byte> data = new byte[size];
-
-                base.Read(va, data);
-
-                return data;
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
             }
         }
 
-        /// <inheritdoc/>
-        public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
+        public override ReadOnlySequence<byte> GetReadOnlySequence(ulong va, int size, bool tracked = false)
         {
-            if (size == 0)
+            try
             {
-                return new WritableRegion(null, va, Memory<byte>.Empty);
+                return base.GetReadOnlySequence(va, size, tracked);
             }
-
-            if (IsContiguousAndMapped(va, size))
+            catch (InvalidMemoryRegionException)
             {
-                if (tracked)
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
                 {
-                    SignalMemoryTracking(va, (ulong)size, true);
+                    throw;
                 }
 
-                return new WritableRegion(null, va, _backingMemory.GetMemory(GetPhysicalAddressInternal(va), size));
-            }
-            else
-            {
-                Memory<byte> memory = new byte[size];
-
-                GetSpan(va, size).CopyTo(memory.Span);
-
-                return new WritableRegion(this, va, memory, tracked);
+                return ReadOnlySequence<byte>.Empty;
             }
         }
 
-        /// <inheritdoc/>
         public ref T GetRef<T>(ulong va) where T : unmanaged
         {
             if (!IsContiguous(va, Unsafe.SizeOf<T>()))
@@ -378,56 +245,6 @@ namespace Ryujinx.Cpu.Jit
             return ref _backingMemory.GetRef<T>(GetPhysicalAddressInternal(va));
         }
 
-        /// <summary>
-        /// Computes the number of pages in a virtual address range.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range</param>
-        /// <param name="startVa">The virtual address of the beginning of the first page</param>
-        /// <remarks>This function does not differentiate between allocated and unallocated pages.</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetPagesCount(ulong va, uint size, out ulong startVa)
-        {
-            // WARNING: Always check if ulong does not overflow during the operations.
-            startVa = va & ~(ulong)PageMask;
-            ulong vaSpan = (va - startVa + size + PageMask) & ~(ulong)PageMask;
-
-            return (int)(vaSpan / PageSize);
-        }
-
-        private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsContiguous(ulong va, int size)
-        {
-            if (!ValidateAddress(va) || !ValidateAddressAndSize(va, (ulong)size))
-            {
-                return false;
-            }
-
-            int pages = GetPagesCount(va, (uint)size, out va);
-
-            for (int page = 0; page < pages - 1; page++)
-            {
-                if (!ValidateAddress(va + PageSize))
-                {
-                    return false;
-                }
-
-                if (GetPhysicalAddressInternal(va) + PageSize != GetPhysicalAddressInternal(va + PageSize))
-                {
-                    return false;
-                }
-
-                va += PageSize;
-            }
-
-            return true;
-        }
-
         /// <inheritdoc/>
         public IEnumerable<HostMemoryRange> GetHostRegions(ulong va, ulong size)
         {
@@ -532,9 +349,8 @@ namespace Ryujinx.Cpu.Jit
             return true;
         }
 
-        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool IsMapped(ulong va)
+        public override bool IsMapped(ulong va)
         {
             if (!ValidateAddress(va))
             {
@@ -544,9 +360,9 @@ namespace Ryujinx.Cpu.Jit
             return _pageTable.Read<ulong>((va / PageSize) * PteSize) != 0;
         }
 
-        private ulong GetPhysicalAddressInternal(ulong va)
+        private nuint GetPhysicalAddressInternal(ulong va)
         {
-            return PteToPa(_pageTable.Read<ulong>((va / PageSize) * PteSize) & ~(0xffffUL << 48)) + (va & PageMask);
+            return (nuint)(PteToPa(_pageTable.Read<ulong>((va / PageSize) * PteSize) & ~(0xffffUL << 48)) + (va & PageMask));
         }
 
         /// <inheritdoc/>
@@ -643,9 +459,7 @@ namespace Ryujinx.Cpu.Jit
                 {
                     ref long pageRef = ref _pageTable.GetRef<long>(pageStart * PteSize);
 
-                    long pte;
-
-                    pte = Volatile.Read(ref pageRef);
+                    long pte = Volatile.Read(ref pageRef);
 
                     if ((pte & tag) != 0)
                     {
@@ -663,7 +477,7 @@ namespace Ryujinx.Cpu.Jit
         }
 
         /// <inheritdoc/>
-        public void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
+        public override void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
         {
             SignalMemoryTrackingImpl(va, size, write, false, precise, exemptId);
         }
@@ -683,10 +497,16 @@ namespace Ryujinx.Cpu.Jit
         /// </summary>
         protected override void Destroy() => _pageTable.Dispose();
 
-        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+        protected override Memory<byte> GetPhysicalAddressMemory(nuint pa, int size)
+            => _backingMemory.GetMemory(pa, size);
+
+        protected override Span<byte> GetPhysicalAddressSpan(nuint pa, int size)
             => _backingMemory.GetSpan(pa, size);
 
-        protected override ulong TranslateVirtualAddressForRead(ulong va)
+        protected override nuint TranslateVirtualAddressChecked(ulong va)
+            => GetPhysicalAddressInternal(va);
+
+        protected override nuint TranslateVirtualAddressUnchecked(ulong va)
             => GetPhysicalAddressInternal(va);
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManagerHostMapped.cs

@@ -3,6 +3,7 @@ using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
@@ -12,7 +13,7 @@ namespace Ryujinx.Cpu.Jit
     /// <summary>
     /// Represents a CPU memory manager which maps guest virtual memory directly onto a host virtual region.
     /// </summary>
-    public sealed class MemoryManagerHostMapped : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public sealed class MemoryManagerHostMapped : VirtualMemoryManagerRefCountedBase, IMemoryManager, IVirtualMemoryManagerTracked
     {
         private readonly InvalidAccessHandler _invalidAccessHandler;
         private readonly bool _unsafeMode;
@@ -26,7 +27,7 @@ namespace Ryujinx.Cpu.Jit
         private readonly ManagedPageFlags _pages;
 
         /// <inheritdoc/>
-        public bool Supports4KBPages => MemoryBlock.GetPageSize() == PageSize;
+        public bool UsesPrivateAllocations => false;
 
         public int AddressSpaceBits { get; }
 
@@ -96,12 +97,6 @@ namespace Ryujinx.Cpu.Jit
             Tracking.Map(va, size);
         }
 
-        /// <inheritdoc/>
-        public void MapForeign(ulong va, nuint hostPointer, ulong size)
-        {
-            throw new NotSupportedException();
-        }
-
         /// <inheritdoc/>
         public void Unmap(ulong va, ulong size)
         {
@@ -138,8 +133,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public T Read<T>(ulong va) where T : unmanaged
+        public override T Read<T>(ulong va)
         {
             try
             {
@@ -158,14 +152,11 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public T ReadTracked<T>(ulong va) where T : unmanaged
+        public override T ReadTracked<T>(ulong va)
         {
             try
             {
-                SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
-
-                return Read<T>(va);
+                return base.ReadTracked<T>(va);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -178,7 +169,6 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
         public override void Read(ulong va, Span<byte> data)
         {
             try
@@ -196,9 +186,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-
-        /// <inheritdoc/>
-        public void Write<T>(ulong va, T value) where T : unmanaged
+        public override void Write<T>(ulong va, T value)
         {
             try
             {
@@ -215,8 +203,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public void Write(ulong va, ReadOnlySpan<byte> data)
+        public override void Write(ulong va, ReadOnlySpan<byte> data)
         {
             try
             {
@@ -233,8 +220,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
+        public override void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
         {
             try
             {
@@ -251,8 +237,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
+        public override bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
         {
             try
             {
@@ -279,8 +264,21 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        /// <inheritdoc/>
-        public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
+        public override ReadOnlySequence<byte> GetReadOnlySequence(ulong va, int size, bool tracked = false)
+        {
+            if (tracked)
+            {
+                SignalMemoryTracking(va, (ulong)size, write: false);
+            }
+            else
+            {
+                AssertMapped(va, (ulong)size);
+            }
+
+            return new ReadOnlySequence<byte>(_addressSpace.Mirror.GetMemory(va, size));
+        }
+
+        public override ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
         {
             if (tracked)
             {
@@ -294,8 +292,7 @@ namespace Ryujinx.Cpu.Jit
             return _addressSpace.Mirror.GetSpan(va, size);
         }
 
-        /// <inheritdoc/>
-        public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
+        public override WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
         {
             if (tracked)
             {
@@ -309,7 +306,6 @@ namespace Ryujinx.Cpu.Jit
             return _addressSpace.Mirror.GetWritableRegion(va, size);
         }
 
-        /// <inheritdoc/>
         public ref T GetRef<T>(ulong va) where T : unmanaged
         {
             SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), true);
@@ -317,9 +313,8 @@ namespace Ryujinx.Cpu.Jit
             return ref _addressSpace.Mirror.GetRef<T>(va);
         }
 
-        /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool IsMapped(ulong va)
+        public override bool IsMapped(ulong va)
         {
             return ValidateAddress(va) && _pages.IsMapped(va);
         }
@@ -390,11 +385,10 @@ namespace Ryujinx.Cpu.Jit
             return _pageTable.Read(va) + (va & PageMask);
         }
 
-        /// <inheritdoc/>
         /// <remarks>
         /// This function also validates that the given range is both valid and mapped, and will throw if it is not.
         /// </remarks>
-        public void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
+        public override void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
         {
             AssertValidAddressAndSize(va, size);
 
@@ -407,23 +401,6 @@ namespace Ryujinx.Cpu.Jit
             _pages.SignalMemoryTracking(Tracking, va, size, write, exemptId);
         }
 
-        /// <summary>
-        /// Computes the number of pages in a virtual address range.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range</param>
-        /// <param name="startVa">The virtual address of the beginning of the first page</param>
-        /// <remarks>This function does not differentiate between allocated and unallocated pages.</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetPagesCount(ulong va, ulong size, out ulong startVa)
-        {
-            // WARNING: Always check if ulong does not overflow during the operations.
-            startVa = va & ~(ulong)PageMask;
-            ulong vaSpan = (va - startVa + size + PageMask) & ~(ulong)PageMask;
-
-            return (int)(vaSpan / PageSize);
-        }
-
         /// <inheritdoc/>
         public void Reprotect(ulong va, ulong size, MemoryPermission protection)
         {
@@ -470,10 +447,16 @@ namespace Ryujinx.Cpu.Jit
             _memoryEh.Dispose();
         }
 
-        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+        protected override Memory<byte> GetPhysicalAddressMemory(nuint pa, int size)
+            => _addressSpace.Mirror.GetMemory(pa, size);
+
+        protected override Span<byte> GetPhysicalAddressSpan(nuint pa, int size)
             => _addressSpace.Mirror.GetSpan(pa, size);
 
-        protected override ulong TranslateVirtualAddressForRead(ulong va)
-            => va;
+        protected override nuint TranslateVirtualAddressChecked(ulong va)
+            => (nuint)GetPhysicalAddressChecked(va);
+
+        protected override nuint TranslateVirtualAddressUnchecked(ulong va)
+            => (nuint)GetPhysicalAddressInternal(va);
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManagerHostTracked.cs

@@ -1,21 +1,22 @@
 using ARMeilleure.Memory;
+using Ryujinx.Common.Memory;
 using Ryujinx.Cpu.Jit.HostTracked;
 using Ryujinx.Cpu.Signal;
 using Ryujinx.Memory;
 using Ryujinx.Memory.Range;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 
 namespace Ryujinx.Cpu.Jit
 {
     /// <summary>
     /// Represents a CPU memory manager which maps guest virtual memory directly onto a host virtual region.
     /// </summary>
-    public sealed class MemoryManagerHostTracked : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IWritableBlock, IMemoryManager, IVirtualMemoryManagerTracked
+    public sealed class MemoryManagerHostTracked : VirtualMemoryManagerRefCountedBase, IMemoryManager, IVirtualMemoryManagerTracked
     {
         private readonly InvalidAccessHandler _invalidAccessHandler;
         private readonly bool _unsafeMode;
@@ -34,7 +35,7 @@ namespace Ryujinx.Cpu.Jit
         protected override ulong AddressSpaceSize { get; }
 
         /// <inheritdoc/>
-        public bool Supports4KBPages => false;
+        public bool UsesPrivateAllocations => true;
 
         public IntPtr PageTablePointer => _nativePageTable.PageTablePointer;
 
@@ -84,6 +85,70 @@ namespace Ryujinx.Cpu.Jit
             _addressSpace = new(Tracking, backingMemory, _nativePageTable, useProtectionMirrors);
         }
 
+        public override ReadOnlySequence<byte> GetReadOnlySequence(ulong va, int size, bool tracked = false)
+        {
+            if (size == 0)
+            {
+                return ReadOnlySequence<byte>.Empty;
+            }
+
+            try
+            {
+                if (tracked)
+                {
+                    SignalMemoryTracking(va, (ulong)size, false);
+                }
+                else
+                {
+                    AssertValidAddressAndSize(va, (ulong)size);
+                }
+
+                ulong endVa = va + (ulong)size;
+                int offset = 0;
+
+                BytesReadOnlySequenceSegment first = null, last = null;
+
+                while (va < endVa)
+                {
+                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(size - offset));
+
+                    Memory<byte> physicalMemory = memory.GetMemory(rangeOffset, (int)copySize);
+
+                    if (first is null)
+                    {
+                        first = last = new BytesReadOnlySequenceSegment(physicalMemory);
+                    }
+                    else
+                    {
+                        if (last.IsContiguousWith(physicalMemory, out nuint contiguousStart, out int contiguousSize))
+                        {
+                            Memory<byte> contiguousPhysicalMemory = new NativeMemoryManager<byte>(contiguousStart, contiguousSize).Memory;
+
+                            last.Replace(contiguousPhysicalMemory);
+                        }
+                        else
+                        {
+                            last = last.Append(physicalMemory);
+                        }
+                    }
+
+                    va += copySize;
+                    offset += (int)copySize;
+                }
+
+                return new ReadOnlySequence<byte>(first, 0, last, (int)(size - last.RunningIndex));
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+
+                return ReadOnlySequence<byte>.Empty;
+            }
+        }
+
         /// <inheritdoc/>
         public void Map(ulong va, ulong pa, ulong size, MemoryMapFlags flags)
         {
@@ -100,12 +165,6 @@ namespace Ryujinx.Cpu.Jit
             Tracking.Map(va, size);
         }
 
-        /// <inheritdoc/>
-        public void MapForeign(ulong va, nuint hostPointer, ulong size)
-        {
-            throw new NotSupportedException();
-        }
-
         /// <inheritdoc/>
         public void Unmap(ulong va, ulong size)
         {
@@ -120,18 +179,11 @@ namespace Ryujinx.Cpu.Jit
             _nativePageTable.Unmap(va, size);
         }
 
-        public T Read<T>(ulong va) where T : unmanaged
-        {
-            return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
-        }
-
-        public T ReadTracked<T>(ulong va) where T : unmanaged
+        public override T ReadTracked<T>(ulong va)
         {
             try
             {
-                SignalMemoryTracking(va, (ulong)Unsafe.SizeOf<T>(), false);
-
-                return Read<T>(va);
+                return base.ReadTracked<T>(va);
             }
             catch (InvalidMemoryRegionException)
             {
@@ -145,38 +197,39 @@ namespace Ryujinx.Cpu.Jit
         }
 
         public override void Read(ulong va, Span<byte> data)
-        {
-            ReadImpl(va, data);
-        }
-
-        public void Write<T>(ulong va, T value) where T : unmanaged
-        {
-            Write(va, MemoryMarshal.Cast<T, byte>(MemoryMarshal.CreateSpan(ref value, 1)));
-        }
-
-        public void Write(ulong va, ReadOnlySpan<byte> data)
         {
             if (data.Length == 0)
             {
                 return;
             }
 
-            SignalMemoryTracking(va, (ulong)data.Length, true);
-
-            WriteImpl(va, data);
-        }
-
-        public void WriteUntracked(ulong va, ReadOnlySpan<byte> data)
-        {
-            if (data.Length == 0)
+            try
             {
-                return;
-            }
+                AssertValidAddressAndSize(va, (ulong)data.Length);
 
-            WriteImpl(va, data);
+                ulong endVa = va + (ulong)data.Length;
+                int offset = 0;
+
+                while (va < endVa)
+                {
+                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(data.Length - offset));
+
+                    memory.GetSpan(rangeOffset, (int)copySize).CopyTo(data.Slice(offset, (int)copySize));
+
+                    va += copySize;
+                    offset += (int)copySize;
+                }
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+            }
         }
 
-        public bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
+        public override bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data)
         {
             if (data.Length == 0)
             {
@@ -206,35 +259,7 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-        private void WriteImpl(ulong va, ReadOnlySpan<byte> data)
-        {
-            try
-            {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                ulong endVa = va + (ulong)data.Length;
-                int offset = 0;
-
-                while (va < endVa)
-                {
-                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(data.Length - offset));
-
-                    data.Slice(offset, (int)copySize).CopyTo(memory.GetSpan(rangeOffset, (int)copySize));
-
-                    va += copySize;
-                    offset += (int)copySize;
-                }
-            }
-            catch (InvalidMemoryRegionException)
-            {
-                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
-                {
-                    throw;
-                }
-            }
-        }
-
-        public ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
+        public override ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false)
         {
             if (size == 0)
             {
@@ -254,13 +279,13 @@ namespace Ryujinx.Cpu.Jit
             {
                 Span<byte> data = new byte[size];
 
-                ReadImpl(va, data);
+                Read(va, data);
 
                 return data;
             }
         }
 
-        public WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
+        public override WritableRegion GetWritableRegion(ulong va, int size, bool tracked = false)
         {
             if (size == 0)
             {
@@ -278,11 +303,11 @@ namespace Ryujinx.Cpu.Jit
             }
             else
             {
-                Memory<byte> memory = new byte[size];
+                MemoryOwner<byte> memoryOwner = MemoryOwner<byte>.Rent(size);
 
-                ReadImpl(va, memory.Span);
+                Read(va, memoryOwner.Span);
 
-                return new WritableRegion(this, va, memory);
+                return new WritableRegion(this, va, memoryOwner);
             }
         }
 
@@ -299,7 +324,7 @@ namespace Ryujinx.Cpu.Jit
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool IsMapped(ulong va)
+        public override bool IsMapped(ulong va)
         {
             return ValidateAddress(va) && _pages.IsMapped(va);
         }
@@ -311,8 +336,6 @@ namespace Ryujinx.Cpu.Jit
             return _pages.IsRangeMapped(va, size);
         }
 
-        private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
-
         private bool TryGetVirtualContiguous(ulong va, int size, out MemoryBlock memory, out ulong offset)
         {
             if (_addressSpace.HasAnyPrivateAllocation(va, (ulong)size, out PrivateRange range))
@@ -491,44 +514,11 @@ namespace Ryujinx.Cpu.Jit
             return regions;
         }
 
-        private void ReadImpl(ulong va, Span<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            try
-            {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                ulong endVa = va + (ulong)data.Length;
-                int offset = 0;
-
-                while (va < endVa)
-                {
-                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(data.Length - offset));
-
-                    memory.GetSpan(rangeOffset, (int)copySize).CopyTo(data.Slice(offset, (int)copySize));
-
-                    va += copySize;
-                    offset += (int)copySize;
-                }
-            }
-            catch (InvalidMemoryRegionException)
-            {
-                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
-                {
-                    throw;
-                }
-            }
-        }
-
         /// <inheritdoc/>
         /// <remarks>
         /// This function also validates that the given range is both valid and mapped, and will throw if it is not.
         /// </remarks>
-        public void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
+        public override void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null)
         {
             AssertValidAddressAndSize(va, size);
 
@@ -543,23 +533,6 @@ namespace Ryujinx.Cpu.Jit
             _pages.SignalMemoryTracking(Tracking, va, size, write, exemptId);
         }
 
-        /// <summary>
-        /// Computes the number of pages in a virtual address range.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range</param>
-        /// <param name="startVa">The virtual address of the beginning of the first page</param>
-        /// <remarks>This function does not differentiate between allocated and unallocated pages.</remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private int GetPagesCount(ulong va, ulong size, out ulong startVa)
-        {
-            // WARNING: Always check if ulong does not overflow during the operations.
-            startVa = va & ~(ulong)PageMask;
-            ulong vaSpan = (va - startVa + size + PageMask) & ~(ulong)PageMask;
-
-            return (int)(vaSpan / PageSize);
-        }
-
         public RegionHandle BeginTracking(ulong address, ulong size, int id, RegionFlags flags = RegionFlags.None)
         {
             return Tracking.BeginTracking(address, size, id, flags);
@@ -618,10 +591,44 @@ namespace Ryujinx.Cpu.Jit
             _nativePageTable.Dispose();
         }
 
-        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+        protected override Memory<byte> GetPhysicalAddressMemory(nuint pa, int size)
+            => _backingMemory.GetMemory(pa, size);
+
+        protected override Span<byte> GetPhysicalAddressSpan(nuint pa, int size)
             => _backingMemory.GetSpan(pa, size);
 
-        protected override ulong TranslateVirtualAddressForRead(ulong va)
-            => GetPhysicalAddressInternal(va);
+        protected override void WriteImpl(ulong va, ReadOnlySpan<byte> data)
+        {
+            try
+            {
+                AssertValidAddressAndSize(va, (ulong)data.Length);
+
+                ulong endVa = va + (ulong)data.Length;
+                int offset = 0;
+
+                while (va < endVa)
+                {
+                    (MemoryBlock memory, ulong rangeOffset, ulong copySize) = GetMemoryOffsetAndSize(va, (ulong)(data.Length - offset));
+
+                    data.Slice(offset, (int)copySize).CopyTo(memory.GetSpan(rangeOffset, (int)copySize));
+
+                    va += copySize;
+                    offset += (int)copySize;
+                }
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+            }
+        }
+
+        protected override nuint TranslateVirtualAddressChecked(ulong va)
+            => (nuint)GetPhysicalAddressChecked(va);
+
+        protected override nuint TranslateVirtualAddressUnchecked(ulong va)
+            => (nuint)GetPhysicalAddressInternal(va);
     }
 }

src/Ryujinx.Cpu/LightningJit/Arm32/Target/Arm64/InstEmitMove.cs

@@ -1,6 +1,5 @@
 using Ryujinx.Cpu.LightningJit.CodeGen;
 using Ryujinx.Cpu.LightningJit.CodeGen.Arm64;
-using System.Diagnostics;
 
 namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
 {

src/Ryujinx.Cpu/LightningJit/Arm32/Target/Arm64/InstEmitSaturate.cs

@@ -114,7 +114,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
             InstEmitCommon.EmitUnsigned16BitPair(context, rd, rn, rm, (d, n, m) =>
             {
                 context.Arm64Assembler.Add(d, n, m);
-                EmitSaturateUnsignedRange(context, d, 16);
+                EmitSaturateUqadd(context, d, 16);
             });
         }
 
@@ -123,7 +123,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
             InstEmitCommon.EmitUnsigned8BitPair(context, rd, rn, rm, (d, n, m) =>
             {
                 context.Arm64Assembler.Add(d, n, m);
-                EmitSaturateUnsignedRange(context, d, 8);
+                EmitSaturateUqadd(context, d, 8);
             });
         }
 
@@ -140,7 +140,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
                     context.Arm64Assembler.Add(d, n, m);
                 }
 
-                EmitSaturateUnsignedRange(context, d, 16);
+                EmitSaturateUq(context, d, 16, e == 0);
             });
         }
 
@@ -157,25 +157,25 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
                     context.Arm64Assembler.Sub(d, n, m);
                 }
 
-                EmitSaturateUnsignedRange(context, d, 16);
+                EmitSaturateUq(context, d, 16, e != 0);
             });
         }
 
         public static void Uqsub16(CodeGenContext context, uint rd, uint rn, uint rm)
         {
-            InstEmitCommon.EmitSigned16BitPair(context, rd, rn, rm, (d, n, m) =>
+            InstEmitCommon.EmitUnsigned16BitPair(context, rd, rn, rm, (d, n, m) =>
             {
                 context.Arm64Assembler.Sub(d, n, m);
-                EmitSaturateUnsignedRange(context, d, 16);
+                EmitSaturateUqsub(context, d, 16);
             });
         }
 
         public static void Uqsub8(CodeGenContext context, uint rd, uint rn, uint rm)
         {
-            InstEmitCommon.EmitSigned8BitPair(context, rd, rn, rm, (d, n, m) =>
+            InstEmitCommon.EmitUnsigned8BitPair(context, rd, rn, rm, (d, n, m) =>
             {
                 context.Arm64Assembler.Sub(d, n, m);
-                EmitSaturateUnsignedRange(context, d, 8);
+                EmitSaturateUqsub(context, d, 8);
             });
         }
 
@@ -358,7 +358,17 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
             }
         }
 
-        private static void EmitSaturateUnsignedRange(CodeGenContext context, Operand value, uint saturateTo)
+        private static void EmitSaturateUqadd(CodeGenContext context, Operand value, uint saturateTo)
+        {
+            EmitSaturateUq(context, value, saturateTo, isSub: false);
+        }
+
+        private static void EmitSaturateUqsub(CodeGenContext context, Operand value, uint saturateTo)
+        {
+            EmitSaturateUq(context, value, saturateTo, isSub: true);
+        }
+
+        private static void EmitSaturateUq(CodeGenContext context, Operand value, uint saturateTo, bool isSub)
         {
             Debug.Assert(saturateTo <= 32);
 
@@ -379,7 +389,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
                 return;
             }
 
-            context.Arm64Assembler.Lsr(tempRegister.Operand, value, InstEmitCommon.Const(32 - (int)saturateTo));
+            context.Arm64Assembler.Lsr(tempRegister.Operand, value, InstEmitCommon.Const((int)saturateTo));
 
             int branchIndex = context.CodeWriter.InstructionPointer;
 
@@ -387,7 +397,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
             context.Arm64Assembler.Cbz(tempRegister.Operand, 0);
 
             // Saturate.
-            context.Arm64Assembler.Mov(value, uint.MaxValue >> (32 - (int)saturateTo));
+            context.Arm64Assembler.Mov(value, isSub ? 0u : uint.MaxValue >> (32 - (int)saturateTo));
 
             int delta = context.CodeWriter.InstructionPointer - branchIndex;
             context.CodeWriter.WriteInstructionAt(branchIndex, context.CodeWriter.ReadInstructionAt(branchIndex) | (uint)((delta & 0x7ffff) << 5));

src/Ryujinx.Cpu/VirtualMemoryManagerRefCountedBase.cs

@@ -1,13 +1,10 @@
 using Ryujinx.Memory;
 using System.Diagnostics;
-using System.Numerics;
 using System.Threading;
 
 namespace Ryujinx.Cpu
 {
-    public abstract class VirtualMemoryManagerRefCountedBase<TVirtual, TPhysical> : VirtualMemoryManagerBase<TVirtual, TPhysical>, IRefCounted
-        where TVirtual : IBinaryInteger<TVirtual>
-        where TPhysical : IBinaryInteger<TPhysical>
+    public abstract class VirtualMemoryManagerRefCountedBase : VirtualMemoryManagerBase, IRefCounted
     {
         private int _referenceCount;