doc: update documentation for Shared property in Switch class (ryubing/ryujinx!137)

See merge request ryubing/ryujinx!137

.github/workflows/canary.yml

@@ -106,47 +106,45 @@ jobs:
           gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/canary --command=UploadGenericPackage "Ryubing-Canary|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-canary-${{ steps.version_info.outputs.build_version }}-${{ matrix.platform.zip_os_name }}.tar.gz"
         shell: bash
 
-        # If anyone wants to look into why appimagetool randomly errors with exit code 8, that would be cool
+      - name: Build AppImage (Linux)
+        if: matrix.platform.os == 'ubuntu-latest'
+        run: |
+          BUILD_VERSION="${{ steps.version_info.outputs.build_version }}"
+          PLATFORM_NAME="${{ matrix.platform.name }}"
 
-#      - name: Build AppImage (Linux)
+          sudo apt install -y zsync desktop-file-utils appstream
-#        if: matrix.platform.os == 'ubuntu-latest'
+
-#        run: |
+          mkdir -p tools
-#          BUILD_VERSION="${{ steps.version_info.outputs.build_version }}"
+          export PATH="$PATH:$(readlink -f tools)"
-#          PLATFORM_NAME="${{ matrix.platform.name }}"
+
-#
+          # Setup appimagetool
-#          sudo apt install -y zsync desktop-file-utils appstream
+          wget -q -O tools/appimagetool "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
-#
+          chmod +x tools/appimagetool
-#          mkdir -p tools
+          chmod +x distribution/linux/appimage/build-appimage.sh
-#          export PATH="$PATH:$(readlink -f tools)"
+
-#
+          # Explicitly set $ARCH for appimagetool ($ARCH_NAME is for the file name)
-#          # Setup appimagetool
+          if [ "$PLATFORM_NAME" = "linux-x64" ]; then
-#          wget -q -O tools/appimagetool "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
+            ARCH_NAME=x64
-#          chmod +x tools/appimagetool
+            export ARCH=x86_64
-#          chmod +x distribution/linux/appimage/build-appimage.sh
+          elif [ "$PLATFORM_NAME" = "linux-arm64" ]; then
-#
+            ARCH_NAME=arm64
-#          # Explicitly set $ARCH for appimagetool ($ARCH_NAME is for the file name)
+            export ARCH=aarch64
-#          if [ "$PLATFORM_NAME" = "linux-x64" ]; then
+          else
-#            ARCH_NAME=x64
+            echo "Unexpected PLATFORM_NAME "$PLATFORM_NAME""
-#            export ARCH=x86_64
+            exit 1
-#          elif [ "$PLATFORM_NAME" = "linux-arm64" ]; then
+          fi
-#            ARCH_NAME=arm64
+
-#            export ARCH=aarch64
+          export UFLAG="gh-releases-zsync|${{ secrets.RC_OWNER }}${{ secrets.RC_CANARY_NAME }}|latest|*-$ARCH_NAME.AppImage.zsync"
-#          else
+          BUILDDIR=publish OUTDIR=publish_appimage distribution/linux/appimage/build-appimage.sh
-#            echo "Unexpected PLATFORM_NAME "$PLATFORM_NAME""
+
-#            exit 1
+          pushd publish_appimage
-#          fi
+          mv Ryujinx.AppImage ../release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage
-#
+          mv Ryujinx.AppImage.zsync ../release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync
-#          export UFLAG="gh-releases-zsync|${{ secrets.RC_OWNER }}${{ secrets.RC_CANARY_NAME }}|latest|*-$ARCH_NAME.AppImage.zsync"
+          popd
-#          BUILDDIR=publish OUTDIR=publish_appimage distribution/linux/appimage/build-appimage.sh
+          
-#
+          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/canary --command=UploadGenericPackage "Ryubing-Canary|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage"
-#          pushd publish_appimage
+          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/canary --command=UploadGenericPackage "Ryubing-Canary|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync"
-#          mv Ryujinx.AppImage ../release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage
+        shell: bash
-#          mv Ryujinx.AppImage.zsync ../release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync
-#          popd
-#          
-#          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/canary --command=UploadGenericPackage "Ryubing-Canary|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage"
-#          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/canary --command=UploadGenericPackage "Ryubing-Canary|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-canary-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync"
-#        shell: bash
 
   macos_release:
     name: Release MacOS universal

.github/workflows/release.yml

@@ -97,47 +97,45 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      # If anyone wants to look into why appimagetool randomly errors with exit code 8, that would be cool
+      - name: Build AppImage (Linux)
+        if: matrix.platform.os == 'ubuntu-latest'
+        run: |
+          BUILD_VERSION="${{ steps.version_info.outputs.build_version }}"
+          PLATFORM_NAME="${{ matrix.platform.name }}"
 
-#      - name: Build AppImage (Linux)
+          sudo apt install -y zsync desktop-file-utils appstream
-#        if: matrix.platform.os == 'ubuntu-latest'
+
-#        run: |
+          mkdir -p tools
-#          BUILD_VERSION="${{ steps.version_info.outputs.build_version }}"
+          export PATH="$PATH:$(readlink -f tools)"
-#          PLATFORM_NAME="${{ matrix.platform.name }}"
+
-#
+          # Setup appimagetool
-#          sudo apt install -y zsync desktop-file-utils appstream
+          wget -q -O tools/appimagetool "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
-#
+          chmod +x tools/appimagetool
-#          mkdir -p tools
+          chmod +x distribution/linux/appimage/build-appimage.sh
-#          export PATH="$PATH:$(readlink -f tools)"
+
-#
+          # Explicitly set $ARCH for appimagetool ($ARCH_NAME is for the file name)
-#          # Setup appimagetool
+          if [ "$PLATFORM_NAME" = "linux-x64" ]; then
-#          wget -q -O tools/appimagetool "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage"
+            ARCH_NAME=x64
-#          chmod +x tools/appimagetool
+            export ARCH=x86_64
-#          chmod +x distribution/linux/appimage/build-appimage.sh
+          elif [ "$PLATFORM_NAME" = "linux-arm64" ]; then
-#
+            ARCH_NAME=arm64
-#          # Explicitly set $ARCH for appimagetool ($ARCH_NAME is for the file name)
+            export ARCH=aarch64
-#          if [ "$PLATFORM_NAME" = "linux-x64" ]; then
+          else
-#            ARCH_NAME=x64
+            echo "Unexpected PLATFORM_NAME "$PLATFORM_NAME""
-#            export ARCH=x86_64
+            exit 1
-#          elif [ "$PLATFORM_NAME" = "linux-arm64" ]; then
+          fi
-#            ARCH_NAME=arm64
+
-#            export ARCH=aarch64
+          export UFLAG="gh-releases-zsync|${{ github.repository_owner }}|${{ github.event.repository.name }}|latest|*-$ARCH_NAME.AppImage.zsync"
-#          else
+          BUILDDIR=publish OUTDIR=publish_appimage distribution/linux/appimage/build-appimage.sh
-#            echo "Unexpected PLATFORM_NAME "$PLATFORM_NAME""
+
-#            exit 1
+          pushd publish_appimage
-#          fi
+          mv Ryujinx.AppImage ../release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage
-#
+          mv Ryujinx.AppImage.zsync ../release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync
-#          export UFLAG="gh-releases-zsync|${{ github.repository_owner }}|${{ github.event.repository.name }}|latest|*-$ARCH_NAME.AppImage.zsync"
+          popd
-#          BUILDDIR=publish OUTDIR=publish_appimage distribution/linux/appimage/build-appimage.sh
+          
-#
+          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/ryujinx --command=UploadGenericPackage "Ryubing|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage"
-#          pushd publish_appimage
+          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/ryujinx --command=UploadGenericPackage "Ryubing|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync"
-#          mv Ryujinx.AppImage ../release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage
+        shell: bash
-#          mv Ryujinx.AppImage.zsync ../release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync
-#          popd
-#          
-#          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/ryujinx --command=UploadGenericPackage "Ryubing|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage"
-#          gli --access-token=${{ secrets.GITLAB_TOKEN }} --project=ryubing/ryujinx --command=UploadGenericPackage "Ryubing|${{ steps.version_info.outputs.build_version }}|release_output/ryujinx-$BUILD_VERSION-$ARCH_NAME.AppImage.zsync"
-#        shell: bash
 
   macos_release:
     name: Release MacOS universal

BuildAndPushLibraries.sh

@@ -1,18 +0,0 @@
-function pub {
-  dotnet publish -c release
-}
-
-function package {
-  cd src/$1
-  pub
-  mv bin/Release/$1.1.0.0.nupkg ../../pkgs/$1.1.0.0.nupkg
-  cd ../../
-}
-
-rm -rf pkgs
-mkdir pkgs
-
-package ARMeilleure
-package Ryujinx.Memory
-
-dotnet nuget push pkgs/*.nupkg --source RyubingPkgs

CHANGELOG.md

@@ -21,8 +21,8 @@ Additionally, 1.2.74 & 75 were fixes for uploading Windows build artifacts.
 
 1.2.76 fixes a rare crash on startup.
 
-## [1.2.72](<https://github.com/GreemDev/Ryujinx/releases/tag/1.2.72>) - 2024-11-03
+## [1.2.72](<https://git.ryujinx.app/ryubing/ryujinx/-/tags/1.2.72>) - 2024-11-03
-PRs [#163](<https://github.com/GreemDev/Ryujinx/pull/163>), [#164](<https://github.com/GreemDev/Ryujinx/pull/164>), [#139](<https://github.com/GreemDev/Ryujinx/pull/139>)
+PRs [#163](<https://web.archive.org/web/20241123015123/https://github.com/GreemDev/Ryujinx/pull/163>), [#164](<https://web.archive.org/web/20250307192526/https://github.com/Ryubing/Ryujinx/pull/164>), [#139](<https://web.archive.org/web/20250306123457/https://github.com/Ryubing/Ryujinx/pull/139>)
 ### HLE:
  - Add DebugMouse HID device.
    - Fixes "Clock Tower Rewind" crashing while loading.
@@ -32,7 +32,7 @@ PRs [#163](<https://github.com/GreemDev/Ryujinx/pull/163>), [#164](<https://gith
 ### misc:
  - Update macOS distribution .icns.
 
-## [1.2.69](<https://github.com/GreemDev/Ryujinx/releases/tag/1.2.69>) - 2024-11-01
+## [1.2.69](<https://git.ryujinx.app/ryubing/ryujinx/-/tags/1.2.69>) - 2024-11-01
 ### Infra:
   - Compile the native libraries into the Ryujinx executable.
   - Remove `libarmeilleure-jitsupport.dylib` from Windows & Linux releases (dylibs are macOS-only)
@@ -42,8 +42,8 @@ PRs [#163](<https://github.com/GreemDev/Ryujinx/pull/163>), [#164](<https://gith
   - Replace "" with `string.Empty`.
   - Code cleanups & simplifications.
 
-## [1.2.67](<https://github.com/GreemDev/Ryujinx/releases/tag/1.2.67>) - 2024-11-01
+## [1.2.67](<https://git.ryujinx.app/ryubing/ryujinx/-/tags/1.2.67>) - 2024-11-01
-PRs [#36](<https://github.com/GreemDev/Ryujinx/pull/36>), [#135](<https://github.com/GreemDev/Ryujinx/pull/135>)
+PRs [#36](<https://web.archive.org/web/20250306215917/https://github.com/Ryubing/Ryujinx/pull/36>), [#135](<https://web.archive.org/web/20241122135125/https://github.com/GreemDev/Ryujinx/pull/135>)
 
 ### GUI:
   - Set UseFloatingWatermark to false when watermark is empty
@@ -54,8 +54,8 @@ PRs [#36](<https://github.com/GreemDev/Ryujinx/pull/36>), [#135](<https://github
   - Fix homebrew loading.
 
 
-## [1.2.64](https://github.com/GreemDev/Ryujinx/releases/tag/1.2.64) - 2024-10-30
+## [1.2.64](https://git.ryujinx.app/ryubing/ryujinx/-/tags/1.2.64) - 2024-10-30
-PRs [#92](https://github.com/GreemDev/Ryujinx/pull/92), [#96](https://github.com/GreemDev/Ryujinx/pull/96), [#97](https://github.com/GreemDev/Ryujinx/pull/97),  [#101](https://github.com/GreemDev/Ryujinx/pull/101), [#103](https://github.com/GreemDev/Ryujinx/pull/103)
+PRs [#92](https://web.archive.org/web/20241118052724/https://github.com/GreemDev/Ryujinx/pull/92), ~~[#96](https://github.com/GreemDev/Ryujinx/pull/96)~~, ~~[#97](https://github.com/GreemDev/Ryujinx/pull/97)~~,  [#101](https://web.archive.org/web/20250306223605/https://github.com/Ryubing/Ryujinx/pull/101), ~~[#103](https://github.com/GreemDev/Ryujinx/pull/103)~~
 ### GUI:
 - Option to show classic-style title bar. Requires restart of emulator to take effect.
   - This is only relevant on Windows. Other Operating Systems default to this being on and not being changeable, because the custom (current) title bar only works on Windows in the first place.
@@ -71,14 +71,14 @@ PRs [#92](https://github.com/GreemDev/Ryujinx/pull/92), [#96](https://github.com
 
 ## 1.2.59 - 2024-10-27
 
-PRs [#88](https://github.com/GreemDev/Ryujinx/pull/88), [#87](https://github.com/GreemDev/Ryujinx/pull/87)
+PRs ~~[#88](https://github.com/GreemDev/Ryujinx/pull/88), [#87](https://github.com/GreemDev/Ryujinx/pull/87)~~
 ### i18n:
 - fr_FR:
   - Add missing translations for new features & fix a couple wrong ones.
   - Fix Ignore Missing Services / Ignore Applet tooltip.
 
 ## 1.2.57 - 2024-10-27
-PRs [#60](https://github.com/GreemDev/Ryujinx/pull/60), [#42](https://github.com/GreemDev/Ryujinx/pull/42)
+PRs ~~[#60](https://github.com/GreemDev/Ryujinx/pull/60)~~, [#42](https://web.archive.org/web/20241126203614/https://github.com/GreemDev/Ryujinx/pull/42)
 ### GUI:
 - Automatically remove invalid DLC & updates as part of autoload.
 - Added Thai translation for Ignore Applet hover tooltip.
@@ -104,7 +104,7 @@ PRs [#60](https://github.com/GreemDev/Ryujinx/pull/60), [#42](https://github.com
 - Code cleanup.
 
 ## 1.2.44 - 2024-10-25
-PR [#59](https://github.com/GreemDev/Ryujinx/pull/59)
+PR [#59](https://web.archive.org/web/20241125060420/https://github.com/GreemDev/Ryujinx/pull/59)
 ### GUI:
 - Add descriptions for "ignoring applet" translated into other languages.
 
@@ -117,9 +117,9 @@ NOTE: The translation isn't referenced in the code yet, it will be in the next u
 ## 1.2.42 - 2024-10-24
 Sources:
 
-Init function: https://github.com/MutantAura/Ryujinx/commit/9cef4ceba40d66492ff775af793ff70e6e7551a9
+Init function: [archive of github.com/MutantAura/Ryujinx/commit/9cef4ceba40d66492ff775af793ff70e6e7551a9](https://web.archive.org/web/20241122193401/https://github.com/MutantAura/Ryujinx/commit/9cef4ceba40d66492ff775af793ff70e6e7551a9)
 
-Shader counter: https://github.com/MutantAura/Ryujinx/commit/67b873645fd593e83d042a77bf7ab12e5ec97357
+Shader counter: ~~https://github.com/MutantAura/Ryujinx/commit/67b873645fd593e83d042a77bf7ab12e5ec97357~~ Original commit has been lost
 
 Thanks MutantAura :D
 ### GUI:
@@ -127,14 +127,14 @@ Thanks MutantAura :D
 - Remove graphics backend / GPU name event logic in favor of a single init function.
 
 ## 1.2.41 - 2024-10-24
-PR [#54](https://github.com/GreemDev/Ryujinx/pull/54)
+PR ~~[#54](https://github.com/GreemDev/Ryujinx/pull/54)~~
 
 Thanks Whitescatz!
 ### i18n:
 - th_TH (Thai): Added missing translations, reduce transliterated words, fix grammar.
 
 ## 1.2.40 - 2024-10-23
-PR [#40](https://github.com/GreemDev/Ryujinx/pull/40)
+PR ~~[#40](https://github.com/GreemDev/Ryujinx/pull/40)~~
 
 Thanks Вова С!
 ### GUI:
@@ -148,30 +148,30 @@ Thanks Вова С!
   - Should prevent crashing on config loads in some circumstances.
 
 ## 1.2.38 - 2024-10-23
-PR [#51](https://github.com/GreemDev/Ryujinx/pull/51)
+PR [#51](https://web.archive.org/web/20241127022413/https://github.com/GreemDev/Ryujinx/pull/51)
 ### i18n:
 - zh_CH (Simplified Chinese): Add some missing translations.
 
 ## 1.2.37 - 2024-10-23
-PR [#37](https://github.com/GreemDev/Ryujinx/pull/37)
+PR [#37](https://web.archive.org/web/20241123010103/https://github.com/GreemDev/Ryujinx/pull/37)
 
 Thanks Last Breath!
 ### GUI: 
 - Set the default controller to the Pro Controller.
 
 ## 1.2.36 - 2024-10-21
-PR [#30](https://github.com/GreemDev/Ryujinx/pull/30)
+PR ~~[#30](https://github.com/GreemDev/Ryujinx/pull/30)~~
 ### GUI:
 - Fix repeated dialog popup notifying you of new updates when there aren't any, while having a bundled update inside an XCI and an external update file.
 
 ## 1.2.35 - 2024-10-21
-PR [#32](https://github.com/GreemDev/Ryujinx/pull/32)
+PR [#32](https://web.archive.org/web/20241127010942/https://github.com/GreemDev/Ryujinx/pull/32)
 ### GUI:
 - Replace "expand DRAM" option with a DRAM size dropdown.
   - Allows for using mods which require a ridiculous amount of memory to allocate from.
 
 ## 1.2.34 - 2024-10-21
-PR [#29](https://github.com/GreemDev/Ryujinx/pull/29)
+PR [#29](https://web.archive.org/web/20241125093029/https://github.com/GreemDev/Ryujinx/pull/29)
 ### GUI:
 - Fix duplicate controller names when 2 controllers of the same type are connected.
 ### INPUT:
@@ -248,7 +248,7 @@ Added Low-power PPTC mode strings to the translation files.
 ## 1.2.1-1.2.19 - 2024-10-08 - 2024-10-11
 ### GUI/INFRA/MISC:
 - Remove GTK UI.
-- Autoload DLC/Updates from dir ([#12](https://github.com/GreemDev/Ryujinx/pull/12)).
+- Autoload DLC/Updates from dir ([#12](https://web.archive.org/web/20241127004005/https://github.com/GreemDev/Ryujinx/pull/12)).
 - Changed executable icon to rainbow logo.
 - Extract Data > Logo now also extracts the square thumbnail you see for the game in the UI. 
 - The "use random UUID hack" checkbox in the Amiibo screen now remembers its last state when you reopen the window in a given session.

distribution/linux/appimage/build-appimage.sh

@@ -23,7 +23,7 @@ chmod +x AppDir/AppRun AppDir/usr/bin/Ryujinx*
 
 mkdir -p "$OUTDIR"
 
-appimagetool --comp zstd --mksquashfs-opt -Xcompression-level --mksquashfs-opt 21 \
+appimagetool -n --comp zstd --mksquashfs-opt -Xcompression-level --mksquashfs-opt 21 \
     -u "$UFLAG" \
     AppDir "$OUTDIR"/Ryujinx.AppImage
 

docs/compatibility.csv

@@ -1440,6 +1440,7 @@
 0100C2700E338000,"Heroland",,playable,2020-08-05 15:35:39
 01007AC00E012000,"HexaGravity",,playable,2021-05-28 13:47:48
 01004E800F03C000,"Hidden",slow,ingame,2022-10-05 10:56:53
+0100C1101EE5A000,"High on Life",,menus,2025-08-26 19:11:00
 0100F6A00A684000,"Higurashi no Naku Koro ni Hō",audio,ingame,2021-09-18 14:40:28
 0100F8D0129F4000,"Himehibi 1 gakki - Princess Days",crash,nothing,2021-11-03 08:34:19
 0100F3D008436000,"Hiragana Pixel Party",,playable,2021-01-14 08:36:50

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

@@ -26,12 +26,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
             ReadOnlySpan<float> inputBuffer,
             uint sampleCount)
         {
-            float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+            Span<short> numeratorSpan = parameter.Numerator.AsSpan();
-            float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+            Span<short> denominatorSpan = parameter.Denominator.AsSpan();
-            float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
             
-            float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+            float a0 = FixedPointHelper.ToFloat(numeratorSpan[0], FixedPointPrecisionForParameter);
-            float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+            float a1 = FixedPointHelper.ToFloat(numeratorSpan[1], FixedPointPrecisionForParameter);
+            float a2 = FixedPointHelper.ToFloat(numeratorSpan[2], FixedPointPrecisionForParameter);
+
+            float b1 = FixedPointHelper.ToFloat(denominatorSpan[0], FixedPointPrecisionForParameter);
+            float b2 = FixedPointHelper.ToFloat(denominatorSpan[1], FixedPointPrecisionForParameter);
 
             for (int i = 0; i < sampleCount; i++)
             {
@@ -64,12 +67,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
             uint sampleCount,
             float volume)
         {
-            float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+            Span<short> numeratorSpan = parameter.Numerator.AsSpan();
-            float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+            Span<short> denominatorSpan = parameter.Denominator.AsSpan();
-            float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
             
-            float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+            float a0 = FixedPointHelper.ToFloat(numeratorSpan[0], FixedPointPrecisionForParameter);
-            float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+            float a1 = FixedPointHelper.ToFloat(numeratorSpan[1], FixedPointPrecisionForParameter);
+            float a2 = FixedPointHelper.ToFloat(numeratorSpan[2], FixedPointPrecisionForParameter);
+
+            float b1 = FixedPointHelper.ToFloat(denominatorSpan[0], FixedPointPrecisionForParameter);
+            float b2 = FixedPointHelper.ToFloat(denominatorSpan[1], FixedPointPrecisionForParameter);
 
             for (int i = 0; i < sampleCount; i++)
             {
@@ -107,12 +113,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
             float volume,
             float ramp)
         {
-            float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+            Span<short> numeratorSpan = parameter.Numerator.AsSpan();
-            float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+            Span<short> denominatorSpan = parameter.Denominator.AsSpan();
-            float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
             
-            float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+            float a0 = FixedPointHelper.ToFloat(numeratorSpan[0], FixedPointPrecisionForParameter);
-            float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+            float a1 = FixedPointHelper.ToFloat(numeratorSpan[1], FixedPointPrecisionForParameter);
+            float a2 = FixedPointHelper.ToFloat(numeratorSpan[2], FixedPointPrecisionForParameter);
+
+            float b1 = FixedPointHelper.ToFloat(denominatorSpan[0], FixedPointPrecisionForParameter);
+            float b2 = FixedPointHelper.ToFloat(denominatorSpan[1], FixedPointPrecisionForParameter);
 
             float mixState = 0f;
 
@@ -158,12 +167,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
 
                 ref BiquadFilterState state = ref states[stageIndex];
                 
-                float a0 = FixedPointHelper.ToFloat(parameter.Numerator[0], FixedPointPrecisionForParameter);
+                Span<short> numeratorSpan = parameter.Numerator.AsSpan();
-                float a1 = FixedPointHelper.ToFloat(parameter.Numerator[1], FixedPointPrecisionForParameter);
+                Span<short> denominatorSpan = parameter.Denominator.AsSpan();
-                float a2 = FixedPointHelper.ToFloat(parameter.Numerator[2], FixedPointPrecisionForParameter);
 
-                float b1 = FixedPointHelper.ToFloat(parameter.Denominator[0], FixedPointPrecisionForParameter);
+                float a0 = FixedPointHelper.ToFloat(numeratorSpan[0], FixedPointPrecisionForParameter);
-                float b2 = FixedPointHelper.ToFloat(parameter.Denominator[1], FixedPointPrecisionForParameter);
+                float a1 = FixedPointHelper.ToFloat(numeratorSpan[1], FixedPointPrecisionForParameter);
+                float a2 = FixedPointHelper.ToFloat(numeratorSpan[2], FixedPointPrecisionForParameter);
+
+                float b1 = FixedPointHelper.ToFloat(denominatorSpan[0], FixedPointPrecisionForParameter);
+                float b2 = FixedPointHelper.ToFloat(denominatorSpan[1], FixedPointPrecisionForParameter);
 
                 for (int i = 0; i < sampleCount; i++)
                 {
@@ -201,19 +213,25 @@ namespace Ryujinx.Audio.Renderer.Dsp
             uint sampleCount,
             float volume)
         {
-            float a00 = FixedPointHelper.ToFloat(parameter0.Numerator[0], FixedPointPrecisionForParameter);
+            Span<short> numerator0Span = parameter0.Numerator.AsSpan();
-            float a10 = FixedPointHelper.ToFloat(parameter0.Numerator[1], FixedPointPrecisionForParameter);
+            Span<short> numerator1Span = parameter1.Numerator.AsSpan();
-            float a20 = FixedPointHelper.ToFloat(parameter0.Numerator[2], FixedPointPrecisionForParameter);
+            Span<short> denominator0Span = parameter0.Denominator.AsSpan();
+            Span<short> denominator1Span = parameter1.Denominator.AsSpan();
             
-            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 a00 = FixedPointHelper.ToFloat(numerator0Span[0], FixedPointPrecisionForParameter);
-            float a11 = FixedPointHelper.ToFloat(parameter1.Numerator[1], FixedPointPrecisionForParameter);
+            float a10 = FixedPointHelper.ToFloat(numerator0Span[1], FixedPointPrecisionForParameter);
-            float a21 = FixedPointHelper.ToFloat(parameter1.Numerator[2], FixedPointPrecisionForParameter);
+            float a20 = FixedPointHelper.ToFloat(numerator0Span[2], FixedPointPrecisionForParameter);
 
-            float b11 = FixedPointHelper.ToFloat(parameter1.Denominator[0], FixedPointPrecisionForParameter);
+            float b10 = FixedPointHelper.ToFloat(denominator0Span[0], FixedPointPrecisionForParameter);
-            float b21 = FixedPointHelper.ToFloat(parameter1.Denominator[1], FixedPointPrecisionForParameter);
+            float b20 = FixedPointHelper.ToFloat(denominator0Span[1], FixedPointPrecisionForParameter);
+
+            float a01 = FixedPointHelper.ToFloat(numerator1Span[0], FixedPointPrecisionForParameter);
+            float a11 = FixedPointHelper.ToFloat(numerator1Span[1], FixedPointPrecisionForParameter);
+            float a21 = FixedPointHelper.ToFloat(numerator1Span[2], FixedPointPrecisionForParameter);
+
+            float b11 = FixedPointHelper.ToFloat(denominator1Span[0], FixedPointPrecisionForParameter);
+            float b21 = FixedPointHelper.ToFloat(denominator1Span[1], FixedPointPrecisionForParameter);
 
             for (int i = 0; i < sampleCount; i++)
             {
@@ -261,19 +279,24 @@ namespace Ryujinx.Audio.Renderer.Dsp
             float volume,
             float ramp)
         {
-            float a00 = FixedPointHelper.ToFloat(parameter0.Numerator[0], FixedPointPrecisionForParameter);
+            Span<short> numerator0Span = parameter0.Numerator.AsSpan();
-            float a10 = FixedPointHelper.ToFloat(parameter0.Numerator[1], FixedPointPrecisionForParameter);
+            Span<short> numerator1Span = parameter1.Numerator.AsSpan();
-            float a20 = FixedPointHelper.ToFloat(parameter0.Numerator[2], FixedPointPrecisionForParameter);
+            Span<short> denominator0Span = parameter0.Denominator.AsSpan();
+            Span<short> denominator1Span = parameter1.Denominator.AsSpan();
             
-            float b10 = FixedPointHelper.ToFloat(parameter0.Denominator[0], FixedPointPrecisionForParameter);
+            float a00 = FixedPointHelper.ToFloat(numerator0Span[0], FixedPointPrecisionForParameter);
-            float b20 = FixedPointHelper.ToFloat(parameter0.Denominator[1], FixedPointPrecisionForParameter);
+            float a10 = FixedPointHelper.ToFloat(numerator0Span[1], FixedPointPrecisionForParameter);
+            float a20 = FixedPointHelper.ToFloat(numerator0Span[2], FixedPointPrecisionForParameter);
 
-            float a01 = FixedPointHelper.ToFloat(parameter1.Numerator[0], FixedPointPrecisionForParameter);
+            float b10 = FixedPointHelper.ToFloat(denominator0Span[0], FixedPointPrecisionForParameter);
-            float a11 = FixedPointHelper.ToFloat(parameter1.Numerator[1], FixedPointPrecisionForParameter);
+            float b20 = FixedPointHelper.ToFloat(denominator0Span[1], FixedPointPrecisionForParameter);
-            float a21 = FixedPointHelper.ToFloat(parameter1.Numerator[2], FixedPointPrecisionForParameter);
 
-            float b11 = FixedPointHelper.ToFloat(parameter1.Denominator[0], FixedPointPrecisionForParameter);
+            float a01 = FixedPointHelper.ToFloat(numerator1Span[0], FixedPointPrecisionForParameter);
-            float b21 = FixedPointHelper.ToFloat(parameter1.Denominator[1], FixedPointPrecisionForParameter);
+            float a11 = FixedPointHelper.ToFloat(numerator1Span[1], FixedPointPrecisionForParameter);
+            float a21 = FixedPointHelper.ToFloat(numerator1Span[2], FixedPointPrecisionForParameter);
+
+            float b11 = FixedPointHelper.ToFloat(denominator1Span[0], FixedPointPrecisionForParameter);
+            float b21 = FixedPointHelper.ToFloat(denominator1Span[1], FixedPointPrecisionForParameter);
 
             float mixState = 0f;
 

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

@@ -40,11 +40,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             SampleRate = serverState.SampleRate;
             Pitch = serverState.Pitch;
             
+            Span<Server.Voice.WaveBuffer> waveBufferSpan = serverState.WaveBuffers.AsSpan();
+
             WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
 
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
-                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref serverState.WaveBuffers[i];
+                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
 
                 WaveBuffers[i] = voiceWaveBuffer.ToCommon(1);
             }

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

@@ -1,5 +1,6 @@
 using Ryujinx.Audio.Renderer.Parameter.Sink;
 using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
 using System.Diagnostics;
 
 namespace Ryujinx.Audio.Renderer.Dsp.Command
@@ -29,9 +30,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             Input = new ushort[Constants.ChannelCountMax];
             InputCount = parameter.InputCount;
             
+            Span<byte> inputSpan = parameter.Input.AsSpan();
+
             for (int i = 0; i < InputCount; i++)
             {
-                Input[i] = (ushort)(bufferOffset + parameter.Input[i]);
+                Input[i] = (ushort)(bufferOffset + inputSpan[i]);
             }
 
             CircularBuffer = circularBufferAddressInfo.GetReference(true);

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

@@ -43,10 +43,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = _parameter.Input.AsSpan();
+            Span<byte> outputSpan = _parameter.Output.AsSpan();
+
             for (int i = 0; i < _parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
         }
 
@@ -172,9 +175,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                         statistics.MinimumGain = MathF.Min(statistics.MinimumGain, compressionGain * state.OutputGain);
                         statistics.MaximumMean = MathF.Max(statistics.MaximumMean, mean);
                         
+                        Span<float> lastSamplesSpan = statistics.LastSamples.AsSpan();
+
                         for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
                         {
-                            statistics.LastSamples[channelIndex] = MathF.Abs(channelInput[channelIndex] * (1f / 32768f));
+                            lastSamplesSpan[channelIndex] = MathF.Abs(channelInput[channelIndex] * (1f / 32768f));
                         }
                     }
                 }

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

@@ -53,11 +53,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             SampleRate = serverState.SampleRate;
             Pitch = serverState.Pitch;
             
+            Span<Server.Voice.WaveBuffer> waveBufferSpan = serverState.WaveBuffers.AsSpan();
+
             WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
 
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
-                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref serverState.WaveBuffers[i];
+                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
 
                 WaveBuffers[i] = voiceWaveBuffer.ToCommon(2);
             }

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

@@ -43,10 +43,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = Parameter.Input.AsSpan();
+            Span<byte> outputSpan = Parameter.Output.AsSpan();
+
             for (int i = 0; i < Parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
 
             DataSourceHelper.RemapLegacyChannelEffectMappingToChannelResourceMapping(newEffectChannelMappingSupported, InputBufferIndices, Parameter.ChannelCount);

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

@@ -42,14 +42,15 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             ref VoiceUpdateState state = ref State.Span[0];
 
             Span<float> depopBuffer = DepopBuffer.Span;
+            Span<float> lastSamplesSpan = state.LastSamples.AsSpan();
 
             for (int i = 0; i < MixBufferCount; i++)
             {
-                if (state.LastSamples[i] != 0)
+                if (lastSamplesSpan[i] != 0)
                 {
-                    depopBuffer[OutputBufferIndices[i]] += state.LastSamples[i];
+                    depopBuffer[OutputBufferIndices[i]] += lastSamplesSpan[i];
 
-                    state.LastSamples[i] = 0;
+                    lastSamplesSpan[i] = 0;
                 }
             }
         }

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

@@ -35,9 +35,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputCount = sink.Parameter.InputCount;
             InputBufferIndices = new ushort[InputCount];
             
+            Span<byte> inputSpan = sink.Parameter.Input.AsSpan();
+
             for (int i = 0; i < Math.Min(InputCount, Constants.ChannelCountMax); i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + sink.Parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
             }
 
             if (sink.UpsamplerState != null)

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

@@ -38,10 +38,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = _parameter.Input.AsSpan();
+            Span<byte> outputSpan = _parameter.Output.AsSpan();
+
             for (int i = 0; i < _parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
         }
 

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

@@ -49,10 +49,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = _parameter.Input.AsSpan();
+            Span<byte> outputSpan = _parameter.Output.AsSpan();
+
             for (int i = 0; i < _parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
         }
 
@@ -150,8 +153,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                         {
                             ref LimiterStatistics statistics = ref MemoryMarshal.Cast<byte, LimiterStatistics>(ResultState.Span[0].SpecificData)[0];
 
-                            statistics.InputMax[channelIndex] = Math.Max(statistics.InputMax[channelIndex], sampleInputMax);
+                            Span<float> inputMaxSpan = statistics.InputMax.AsSpan();
-                            statistics.CompressionGainMin[channelIndex] = Math.Min(statistics.CompressionGainMin[channelIndex], compressionGain);
+                            Span<float> compressionGainMinSpan = statistics.CompressionGainMin.AsSpan();
+                            
+                            inputMaxSpan[channelIndex] = Math.Max(inputMaxSpan[channelIndex], sampleInputMax);
+                            compressionGainMinSpan[channelIndex] = Math.Min(compressionGainMinSpan[channelIndex], compressionGain);
                         }
                     }
                 }

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

@@ -79,6 +79,10 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
         public void Process(CommandList context)
         {
+            ref VoiceUpdateState state = ref State.Span[0];
+            
+            Span<float> lastSamplesSpan = state.LastSamples.AsSpan();
+            
             for (int i = 0; i < MixBufferCount; i++)
             {
                 ReadOnlySpan<float> inputBuffer = context.GetBuffer(InputBufferIndices[i]);
@@ -87,15 +91,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                 float volume0 = Volume0[i];
                 float volume1 = Volume1[i];
 
-                ref VoiceUpdateState state = ref State.Span[0];
-
                 if (volume0 != 0 || volume1 != 0)
                 {
-                    state.LastSamples[i] = ProcessMixRampGrouped(outputBuffer, inputBuffer, volume0, volume1, (int)context.SampleCount);
+                    lastSamplesSpan[i] = ProcessMixRampGrouped(outputBuffer, inputBuffer, volume0, volume1, (int)context.SampleCount);
                 }
                 else
                 {
-                    state.LastSamples[i] = 0;
+                    lastSamplesSpan[i] = 0;
                 }
             }
         }

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

@@ -43,9 +43,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
             
+            Span<Server.Voice.WaveBuffer> waveBufferSpan = serverState.WaveBuffers.AsSpan();
+
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
-                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref serverState.WaveBuffers[i];
+                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
 
                 WaveBuffers[i] = voiceWaveBuffer.ToCommon(1);
             }

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

@@ -43,9 +43,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
             WaveBuffers = new WaveBuffer[Constants.VoiceWaveBufferCount];
             
+            Span<Server.Voice.WaveBuffer> waveBufferSpan = serverState.WaveBuffers.AsSpan();
+
             for (int i = 0; i < WaveBuffers.Length; i++)
             {
-                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref serverState.WaveBuffers[i];
+                ref Server.Voice.WaveBuffer voiceWaveBuffer = ref waveBufferSpan[i];
 
                 WaveBuffers[i] = voiceWaveBuffer.ToCommon(1);
             }

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

@@ -66,10 +66,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = Parameter.Input.AsSpan();
+            Span<byte> outputSpan = Parameter.Output.AsSpan();
+
             for (int i = 0; i < Parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
 
             // NOTE: We do the opposite as Nintendo here for now to restore previous behaviour

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

@@ -64,10 +64,13 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
             InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
             
+            Span<byte> inputSpan = Parameter.Input.AsSpan();
+            Span<byte> outputSpan = Parameter.Output.AsSpan();
+
             for (int i = 0; i < Parameter.ChannelCount; i++)
             {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
+                InputBufferIndices[i] = (ushort)(bufferOffset + inputSpan[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + outputSpan[i]);
             }
 
             IsLongSizePreDelaySupported = isLongSizePreDelaySupported;

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

@@ -74,7 +74,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
                 {
                     int tempBufferIndex = 0;
 
-                    if (!info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))
+                    if ((info.DecodingBehaviour & DecodingBehaviour.SkipPitchAndSampleRateConversion) != DecodingBehaviour.SkipPitchAndSampleRateConversion)
                     {
                         voiceState.Pitch.AsSpan()[..pitchMaxLength].CopyTo(tempBuffer);
                         tempBufferIndex += pitchMaxLength;
@@ -208,7 +208,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
                                     break;
                                 }
 
-                                if (info.DecodingBehaviour.HasFlag(DecodingBehaviour.PlayedSampleCountResetWhenLooping))
+                                if ((info.DecodingBehaviour & DecodingBehaviour.PlayedSampleCountResetWhenLooping) == DecodingBehaviour.PlayedSampleCountResetWhenLooping)
                                 {
                                     playedSampleCount = 0;
                                 }
@@ -222,7 +222,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
 
                     Span<int> outputSpanInt = MemoryMarshal.Cast<float, int>(outputBuffer[i..]);
 
-                    if (info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))
+                    if ((info.DecodingBehaviour & DecodingBehaviour.SkipPitchAndSampleRateConversion) == DecodingBehaviour.SkipPitchAndSampleRateConversion)
                     {
                         for (int j = 0; j < y; j++)
                         {

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

@@ -41,11 +41,12 @@ namespace Ryujinx.Audio.Renderer.Dsp
             }
 
             Array20<float> result = new();
+            Span<float> resultSpan = result.AsSpan();
 
             for (int i = 0; i < FilterBankLength; i++)
             {
                 float x = (Bank0CenterIndex - i) + offset;
-                result[i] = Sinc(x) * BlackmanWindow(x / FilterBankLength + 0.5f);
+                resultSpan[i] = Sinc(x) * BlackmanWindow(x / FilterBankLength + 0.5f);
             }
 
             return result;
@@ -79,6 +80,9 @@ namespace Ryujinx.Audio.Renderer.Dsp
                 Debug.Assert(state.History.Length == HistoryLength);
                 Debug.Assert(bank.Length == FilterBankLength);
                 
+                Span<float> bankSpan = bank.AsSpan();
+                Span<float> historySpan = state.History.AsSpan();
+
                 int curIdx = 0;
                 if (Vector.IsHardwareAccelerated)
                 {
@@ -88,15 +92,15 @@ namespace Ryujinx.Audio.Renderer.Dsp
                     while (curIdx < stopIdx)
                     {
                         result += Vector.Dot(
-                            new Vector<float>(bank.AsSpan().Slice(curIdx, Vector<float>.Count)),
+                            new Vector<float>(bankSpan[curIdx..(curIdx + Vector<float>.Count)]),
-                            new Vector<float>(state.History.AsSpan().Slice(curIdx, Vector<float>.Count)));
+                            new Vector<float>(historySpan[curIdx..(curIdx + Vector<float>.Count)]));
                         curIdx += Vector<float>.Count;
                     }
                 }
 
                 while (curIdx < FilterBankLength)
                 {
-                    result += bank[curIdx] * state.History[curIdx];
+                    result += bankSpan[curIdx] * historySpan[curIdx];
                     curIdx++;
                 }
 

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

@@ -141,18 +141,20 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             bool supportsOptimizedPath = _rendererContext.BehaviourContext.UseMultiTapBiquadFilterProcessing();
 
-            if (supportsOptimizedPath && voiceState.BiquadFilters[0].Enable && voiceState.BiquadFilters[1].Enable)
+            Span<BiquadFilterParameter> biquadFiltersSpan = voiceState.BiquadFilters.AsSpan();
+
+            if (supportsOptimizedPath && biquadFiltersSpan[0].Enable && biquadFiltersSpan[1].Enable)
             {
                 Memory<byte> biquadStateRawMemory = SpanMemoryManager<byte>.Cast(state)[..(Unsafe.SizeOf<BiquadFilterState>() * Constants.VoiceBiquadFilterCount)];
                 Memory<BiquadFilterState> stateMemory = SpanMemoryManager<BiquadFilterState>.Cast(biquadStateRawMemory);
 
-                _commandBuffer.GenerateMultiTapBiquadFilter(baseIndex, voiceState.BiquadFilters.AsSpan(), stateMemory, bufferOffset, bufferOffset, voiceState.BiquadFilterNeedInitialization, nodeId);
+                _commandBuffer.GenerateMultiTapBiquadFilter(baseIndex, biquadFiltersSpan, stateMemory, bufferOffset, bufferOffset, voiceState.BiquadFilterNeedInitialization, nodeId);
             }
             else
             {
-                for (int i = 0; i < voiceState.BiquadFilters.Length; i++)
+                for (int i = 0; i < biquadFiltersSpan.Length; i++)
                 {
-                    ref BiquadFilterParameter filter = ref voiceState.BiquadFilters[i];
+                    ref BiquadFilterParameter filter = ref biquadFiltersSpan[i];
 
                     if (filter.Enable)
                     {
@@ -312,11 +314,14 @@ namespace Ryujinx.Audio.Renderer.Server
             int nodeId = voiceState.NodeId;
             uint channelsCount = voiceState.ChannelsCount;
             
+            Span<int> channelResourceIdsSpan = voiceState.ChannelResourceIds.AsSpan();
+            Span<BiquadFilterParameter> biquadFiltersSpan = voiceState.BiquadFilters.AsSpan();
+
             for (int channelIndex = 0; channelIndex < channelsCount; channelIndex++)
             {
-                Memory<VoiceUpdateState> dspStateMemory = _voiceContext.GetUpdateStateForDsp(voiceState.ChannelResourceIds[channelIndex]);
+                Memory<VoiceUpdateState> dspStateMemory = _voiceContext.GetUpdateStateForDsp(channelResourceIdsSpan[channelIndex]);
 
-                ref VoiceChannelResource channelResource = ref _voiceContext.GetChannelResource(voiceState.ChannelResourceIds[channelIndex]);
+                ref VoiceChannelResource channelResource = ref _voiceContext.GetChannelResource(channelResourceIdsSpan[channelIndex]);
 
                 PerformanceDetailType dataSourceDetailType = PerformanceDetailType.Adpcm;
 
@@ -476,7 +481,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
                     for (int i = 0; i < voiceState.BiquadFilterNeedInitialization.Length; i++)
                     {
-                        voiceState.BiquadFilterNeedInitialization[i] = voiceState.BiquadFilters[i].Enable;
+                        voiceState.BiquadFilterNeedInitialization[i] = biquadFiltersSpan[i].Enable;
                     }
                 }
             }
@@ -526,15 +531,19 @@ namespace Ryujinx.Audio.Renderer.Server
 
             if (effect.IsEnabled)
             {
+                Span<float> volumesSpan = effect.Parameter.Volumes.AsSpan();
+                Span<byte> inputSpan = effect.Parameter.Input.AsSpan();
+                Span<byte> outputSpan = effect.Parameter.Output.AsSpan();
+                
                 for (int i = 0; i < effect.Parameter.MixesCount; i++)
                 {
-                    if (effect.Parameter.Volumes[i] != 0.0f)
+                    if (volumesSpan[i] != 0.0f)
                     {
                         _commandBuffer.GenerateMix(
-                            (uint)bufferOffset + effect.Parameter.Input[i],
+                            (uint)bufferOffset + inputSpan[i],
-                            (uint)bufferOffset + effect.Parameter.Output[i],
+                            (uint)bufferOffset + outputSpan[i],
                             nodeId,
-                            effect.Parameter.Volumes[i]);
+                            volumesSpan[i]);
                     }
                 }
             }
@@ -554,6 +563,10 @@ namespace Ryujinx.Audio.Renderer.Server
             {
                 int i = 0;
                 uint writeOffset = 0;
+                
+                Span<byte> inputSpan = effect.Parameter.Input.AsSpan();
+                Span<byte> outputSpan = effect.Parameter.Output.AsSpan();
+                
                 for (uint channelIndex = effect.Parameter.ChannelCount; channelIndex != 0; channelIndex--)
                 {
                     uint newUpdateCount = writeOffset + _commandBuffer.CommandList.SampleCount;
@@ -571,8 +584,8 @@ namespace Ryujinx.Audio.Renderer.Server
 
                     _commandBuffer.GenerateAuxEffect(
                         bufferOffset,
-                        effect.Parameter.Input[i],
+                        inputSpan[i],
-                        effect.Parameter.Output[i],
+                        outputSpan[i],
                         ref effect.State,
                         effect.IsEnabled,
                         effect.Parameter.BufferStorageSize,
@@ -620,6 +633,9 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             Debug.Assert(effect.Type == EffectType.BiquadFilter);
             
+            Span<byte> inputSpan = effect.Parameter.Input.AsSpan();
+            Span<byte> outputSpan = effect.Parameter.Output.AsSpan();
+
             if (effect.IsEnabled)
             {
                 bool needInitialization = effect.Parameter.Status == UsageState.Invalid ||
@@ -639,8 +655,8 @@ namespace Ryujinx.Audio.Renderer.Server
                         (int)bufferOffset,
                         ref parameter,
                         effect.State.Slice(i, 1),
-                        effect.Parameter.Input[i],
+                        inputSpan[i],
-                        effect.Parameter.Output[i],
+                        outputSpan[i],
                         needInitialization,
                         nodeId);
                 }
@@ -649,8 +665,8 @@ namespace Ryujinx.Audio.Renderer.Server
             {
                 for (int i = 0; i < effect.Parameter.ChannelCount; i++)
                 {
-                    uint inputBufferIndex = bufferOffset + effect.Parameter.Input[i];
+                    uint inputBufferIndex = bufferOffset + inputSpan[i];
-                    uint outputBufferIndex = bufferOffset + effect.Parameter.Output[i];
+                    uint outputBufferIndex = bufferOffset + outputSpan[i];
 
                     // If the input and output isn't the same, generate a command.
                     if (inputBufferIndex != outputBufferIndex)
@@ -702,6 +718,8 @@ namespace Ryujinx.Audio.Renderer.Server
                 int i = 0;
                 uint writeOffset = 0;
                 
+                Span<byte> inputSpan = effect.Parameter.Input.AsSpan();
+
                 for (uint channelIndex = effect.Parameter.ChannelCount; channelIndex != 0; channelIndex--)
                 {
                     uint newUpdateCount = writeOffset + _commandBuffer.CommandList.SampleCount;
@@ -719,7 +737,7 @@ namespace Ryujinx.Audio.Renderer.Server
 
                     _commandBuffer.GenerateCaptureEffect(
                         bufferOffset,
-                        effect.Parameter.Input[i],
+                        inputSpan[i],
                         effect.State.SendBufferInfo,
                         effect.IsEnabled,
                         effect.Parameter.BufferStorageSize,

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

@@ -218,7 +218,8 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// <returns>True if any biquad filter is enabled.</returns>
         public bool IsBiquadFilterEnabled()
         {
-            return _biquadFilters[0].Enable || _biquadFilters[1].Enable;
+            Span<BiquadFilterParameter> biquadFiltersSpan = _biquadFilters.AsSpan();
+            return biquadFiltersSpan[0].Enable || biquadFiltersSpan[1].Enable;
         }
 
         /// <summary>

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

@@ -162,9 +162,11 @@ namespace Ryujinx.Audio.Renderer.Server
                 {
                     ref VoiceState currentVoiceState = ref context.GetState(i);
 
+                    Span<int> channelResourceIdsSpan = parameter.ChannelResourceIds.AsSpan();
+
                     for (int channelResourceIndex = 0; channelResourceIndex < parameter.ChannelCount; channelResourceIndex++)
                     {
-                        int channelId = parameter.ChannelResourceIds[channelResourceIndex];
+                        int channelId = channelResourceIdsSpan[channelResourceIndex];
 
                         Debug.Assert(channelId >= 0 && channelId < context.GetCount());
 

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

@@ -126,9 +126,9 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 _sortedVoices.Span[i] = i;
             }
 
-            int[] sortedVoicesTemp = _sortedVoices[..(int)GetCount()].ToArray();
+            Span<int> sortedVoicesTemp = _sortedVoices[..(int)_voiceCount].Span;
 
-            Array.Sort(sortedVoicesTemp, (a, b) =>
+            sortedVoicesTemp.Sort((a, b) =>
             {
                 ref VoiceState aState = ref GetState(a);
                 ref VoiceState bState = ref GetState(b);
@@ -143,7 +143,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 return result;
             });
 
-            sortedVoicesTemp.AsSpan().CopyTo(_sortedVoices.Span);
+            // sortedVoicesTemp.CopyTo(_sortedVoices.Span);
         }
     }
 }

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

@@ -219,15 +219,17 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// </summary>
         private void InitializeWaveBuffers()
         {
-            for (int i = 0; i < WaveBuffers.Length; i++)
+            Span<WaveBuffer> waveBuffersSpan = WaveBuffers.AsSpan();
+            
+            for (int i = 0; i < waveBuffersSpan.Length; i++)
             {
-                WaveBuffers[i].StartSampleOffset = 0;
+                waveBuffersSpan[i].StartSampleOffset = 0;
-                WaveBuffers[i].EndSampleOffset = 0;
+                waveBuffersSpan[i].EndSampleOffset = 0;
-                WaveBuffers[i].ShouldLoop = false;
+                waveBuffersSpan[i].ShouldLoop = false;
-                WaveBuffers[i].IsEndOfStream = false;
+                waveBuffersSpan[i].IsEndOfStream = false;
-                WaveBuffers[i].BufferAddressInfo.Setup(0, 0);
+                waveBuffersSpan[i].BufferAddressInfo.Setup(0, 0);
-                WaveBuffers[i].ContextAddressInfo.Setup(0, 0);
+                waveBuffersSpan[i].ContextAddressInfo.Setup(0, 0);
-                WaveBuffers[i].IsSendToAudioProcessor = true;
+                waveBuffersSpan[i].IsSendToAudioProcessor = true;
             }
         }
 
@@ -447,9 +449,12 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
 
             ref VoiceUpdateState voiceUpdateState = ref voiceUpdateStates[0].Span[0];
             
+            Span<WaveBuffer> waveBuffersSpan = WaveBuffers.AsSpan();
+            Span<WaveBufferInternal> pWaveBuffersSpan = parameter.WaveBuffers.AsSpan();
+
             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], mapper, ref behaviourContext);
+                UpdateWaveBuffer(errorInfos.AsSpan(i * 2, 2), ref waveBuffersSpan[i], ref pWaveBuffersSpan[i], parameter.SampleFormat, voiceUpdateState.IsWaveBufferValid[i], mapper, ref behaviourContext);
             }
         }
 
@@ -534,9 +539,11 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         /// <param name="context">The voice context.</param>
         private void ResetResources(VoiceContext context)
         {
+            Span<int> channelResourceIdsSpan = ChannelResourceIds.AsSpan();
+            
             for (int i = 0; i < ChannelsCount; i++)
             {
-                int channelResourceId = ChannelResourceIds[i];
+                int channelResourceId = channelResourceIdsSpan[i];
 
                 ref VoiceChannelResource voiceChannelResource = ref context.GetChannelResource(channelResourceId);
 
@@ -560,9 +567,11 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
         {
             uint waveBufferIndex = WaveBuffersIndex;
             
+            Span<WaveBuffer> waveBuffersSpan = WaveBuffers.AsSpan();
+
             for (int i = 0; i < waveBufferCount; i++)
             {
-                WaveBuffers[(int)waveBufferIndex].IsSendToAudioProcessor = true;
+                waveBuffersSpan[(int)waveBufferIndex].IsSendToAudioProcessor = true;
 
                 for (int j = 0; j < channelCount; j++)
                 {
@@ -591,14 +600,18 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                 FlushWaveBufferCount = 0;
             }
 
+            Span<WaveBuffer> waveBuffersSpan;
+
             switch (PlayState)
             {
                 case PlayState.Started:
-                    for (int i = 0; i < WaveBuffers.Length; i++)
+                    waveBuffersSpan = WaveBuffers.AsSpan();
-                    {
-                        ref WaveBuffer wavebuffer = ref WaveBuffers[i];
                     
-                        if (!wavebuffer.IsSendToAudioProcessor)
+                    for (int i = 0; i < waveBuffersSpan.Length; i++)
+                    {
+                        ref WaveBuffer waveBuffer = ref waveBuffersSpan[i];
+
+                        if (!waveBuffer.IsSendToAudioProcessor)
                         {
                             for (int y = 0; y < ChannelsCount; y++)
                             {
@@ -607,7 +620,7 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                                 voiceUpdateStates[y].Span[0].IsWaveBufferValid[i] = true;
                             }
 
-                            wavebuffer.IsSendToAudioProcessor = true;
+                            waveBuffer.IsSendToAudioProcessor = true;
                         }
                     }
 
@@ -626,11 +639,13 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
                     return false;
 
                 case PlayState.Stopping:
-                    for (int i = 0; i < WaveBuffers.Length; i++)
+                    waveBuffersSpan = WaveBuffers.AsSpan();
-                    {
-                        ref WaveBuffer wavebuffer = ref WaveBuffers[i];
                     
-                        wavebuffer.IsSendToAudioProcessor = true;
+                    for (int i = 0; i < waveBuffersSpan.Length; i++)
+                    {
+                        ref WaveBuffer waveBuffer = ref waveBuffersSpan[i];
+
+                        waveBuffer.IsSendToAudioProcessor = true;
 
                         for (int j = 0; j < ChannelsCount; j++)
                         {
@@ -702,9 +717,11 @@ namespace Ryujinx.Audio.Renderer.Server.Voice
 
             Memory<VoiceUpdateState>[] voiceUpdateStates = new Memory<VoiceUpdateState>[Constants.VoiceChannelCountMax];
 
+            Span<int> channelResourceIdsSpan = ChannelResourceIds.AsSpan();
+            
             for (int i = 0; i < ChannelsCount; i++)
             {
-                voiceUpdateStates[i] = context.GetUpdateStateForDsp(ChannelResourceIds[i]);
+                voiceUpdateStates[i] = context.GetUpdateStateForDsp(channelResourceIdsSpan[i]);
             }
 
             return UpdateParametersForCommandGeneration(voiceUpdateStates);

src/Ryujinx.Common/Collections/IntrusiveRedBlackTree.cs

@@ -131,7 +131,6 @@ namespace Ryujinx.Common.Collections
                 if (parent.Predecessor != null)
                 {
                     newNode.Predecessor = parent.Predecessor;
-                    parent.Predecessor = newNode;
                     newNode.Predecessor.Successor = newNode;
                 }
                 

src/Ryujinx.Common/Memory/IArray.cs

@@ -1,3 +1,5 @@
+using System;
+
 namespace Ryujinx.Common.Memory
 {
     /// <summary>
@@ -17,5 +19,10 @@ namespace Ryujinx.Common.Memory
         /// Number of elements on the array.
         /// </summary>
         int Length { get; }
+
+        /// <summary>
+        /// Number of elements on the array.
+        /// </summary>
+        public Span<T> AsSpan();
     }
 }

src/Ryujinx.Common/Memory/MemoryOwner.cs

@@ -1,6 +1,7 @@
 #nullable enable
 using System;
 using System.Buffers;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -10,11 +11,126 @@ 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"/>.
+    /// accessor, with memory allocated from <see cref="ArrayPooling"/>.
     /// </summary>
     /// <typeparam name="T">The type of item to store.</typeparam>
     public sealed class MemoryOwner<T> : IMemoryOwner<T>
     {
+        private static class ArrayPooling
+        {
+            public class Holder(T[]? array = null) : IComparable<Holder>, IComparable<int>
+            {
+                public int SkipCount;
+                public readonly T[]? Array = array;
+
+                public int CompareTo(Holder? other)
+                {
+                    return Array!.Length.CompareTo(other!.Array!.Length);
+                }
+                
+                public int CompareTo(int other)
+                {
+                    int self = Array!.Length;
+
+                    if (self < other)
+                    {
+                        SkipCount++;
+                        return -1;
+                    }
+
+                    if (self > other * 4)
+                    {
+                        return 1;
+                    }
+                    
+                    return 0;
+                }
+            }
+            
+            // ReSharper disable once StaticMemberInGenericType
+            private static int _maxCacheCount = 50;
+            
+            private const int MaxSkipCount = 50;
+        
+            static readonly List<Holder> _pool = new();
+            
+            // ReSharper disable once StaticMemberInGenericType
+            static readonly Lock _lock = new();
+            
+            private static int BinarySearch(List<Holder> list, int size)
+            {
+                int min = 0;
+                int max = list.Count-1;
+
+                while (min <= max)
+                {
+                    int mid = (min + max) / 2;
+                    int comparison = list[mid].CompareTo(size);
+                    if (comparison == 0)
+                    {
+                        return mid;
+                    }
+                    if (comparison < 0)
+                    {
+                        min = mid+1;
+                    }
+                    else
+                    {
+                        max = mid-1;
+                    }
+                }
+                return ~min;
+            }
+
+            public static T[] Get(int minimumSize)
+            {
+                lock (_lock)
+                {
+                    int index = BinarySearch(_pool, minimumSize);
+
+                    if (index >= 0)
+                    {
+                        Holder holder = _pool[index];
+                        
+                        _pool.Remove(holder);
+                        return holder.Array!;
+                    }
+
+                    return new T[minimumSize];
+                }
+            }
+
+            public static void Return(T[] array)
+            {
+
+                lock (_lock)
+                {
+                    Holder holder = new(array);
+                    int i = _pool.BinarySearch(holder);
+                    if (i < 0)
+                    {
+                        _pool.Insert(~i, holder);
+                    }
+
+                    if (_pool.Count >= _maxCacheCount)
+                    {
+                        for (int index = 0; index < _pool.Count; index++)
+                        {
+                            Holder h = _pool[index];
+
+                            if (h.SkipCount >= MaxSkipCount)
+                            {
+                                _pool.Remove(h);
+                                index--;
+                            }
+                        }
+                        
+                        _maxCacheCount = _pool.Count * 2;
+                    }
+                }
+            }
+        }
+        
         private readonly int _length;
         private T[]? _array;
 
@@ -25,7 +141,7 @@ namespace Ryujinx.Common.Memory
         private MemoryOwner(int length)
         {
             _length = length;
-            _array = ArrayPool<T>.Shared.Rent(length);
+            _array = ArrayPooling.Get(length);
         }
 
         /// <summary>
@@ -124,7 +240,7 @@ namespace Ryujinx.Common.Memory
 
             if (array is not null)
             {
-                ArrayPool<T>.Shared.Return(array, RuntimeHelpers.IsReferenceOrContainsReferences<T>());
+                ArrayPooling.Return(array);
             }
         }
 

src/Ryujinx.Common/Memory/PartialUnmaps/ThreadLocalMap.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Runtime.InteropServices;
 using System.Threading;
 using static Ryujinx.Common.Memory.PartialUnmaps.PartialUnmapHelpers;
@@ -43,9 +44,12 @@ namespace Ryujinx.Common.Memory.PartialUnmaps
         {
             // Try get a match first.
             
+            Span<int> threadIdsSpan = ThreadIds.AsSpan();
+            Span<T> structsSpan = Structs.AsSpan();
+
             for (int i = 0; i < MapSize; i++)
             {
-                int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, threadId);
+                int compare = Interlocked.CompareExchange(ref threadIdsSpan[i], threadId, threadId);
 
                 if (compare == threadId)
                 {
@@ -57,11 +61,11 @@ namespace Ryujinx.Common.Memory.PartialUnmaps
 
             for (int i = 0; i < MapSize; i++)
             {
-                int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, 0);
+                int compare = Interlocked.CompareExchange(ref threadIdsSpan[i], threadId, 0);
 
                 if (compare == 0)
                 {
-                    Structs[i] = initial;
+                    structsSpan[i] = initial;
                     return i;
                 }
             }

src/Ryujinx.Common/SharedConstants.cs

@@ -2,8 +2,18 @@ namespace Ryujinx.Common
 {
     public static class SharedConstants
     {
-        public const string DefaultLanPlayHost = "ryuldn.vudjun.com";
+        public const string DefaultLanPlayHost = "ldn.ryujinx.app";
         public const short LanPlayPort = 30456;
-        public const string DefaultLanPlayWebHost = "ryuldnweb.vudjun.com";
+        public const string DefaultLanPlayWebHost = DefaultLanPlayHost;
+
+        public const string AmiiboTagsUrl = "https://raw.githubusercontent.com/Ryubing/Nfc/refs/heads/main/tags.json";
+
+        public const string FaqWikiUrl = "https://git.ryujinx.app/ryubing/ryujinx/-/wikis/FAQ-&-Troubleshooting";
+
+        public const string SetupGuideWikiUrl =
+            "https://git.ryujinx.app/ryubing/ryujinx/-/wikis/Setup-&-Configuration-Guide";
+
+        public const string MultiplayerWikiUrl =
+            "https://git.ryujinx.app/ryubing/ryujinx/-/wikis/Multiplayer-(LDN-Local-Wireless)-Guide";
     }
 }

src/Ryujinx.Graphics.Device/DeviceState.cs

@@ -82,15 +82,7 @@ namespace Ryujinx.Graphics.Device
             {
                 uint alignedOffset = index * RegisterSize;
                 
-                Func<int> readCallback = Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_readCallbacks), (nint)index);
+                return _readCallbacks[index]?.Invoke() ?? GetRefUnchecked<int>(alignedOffset);
-                if (readCallback != null)
-                {
-                    return readCallback();
-                }
-                else
-                {
-                    return GetRefUnchecked<int>(alignedOffset);
-                }
             }
 
             return 0;
@@ -107,7 +99,7 @@ namespace Ryujinx.Graphics.Device
 
                 GetRefIntAlignedUncheck(index) = data;
 
-                Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_writeCallbacks), (nint)index)?.Invoke(data);
+                _writeCallbacks[index]?.Invoke(data);
             }
         }
 
@@ -124,7 +116,7 @@ namespace Ryujinx.Graphics.Device
                 changed = storage != data;
                 storage = data;
 
-                Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_writeCallbacks), (nint)index)?.Invoke(data);
+                _writeCallbacks[index]?.Invoke(data);
             }
             else
             {

src/Ryujinx.Graphics.Gpu/Engine/MME/MacroHLE.cs

@@ -219,13 +219,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
             state.Write(LogicOpOffset, 0);
 
             Array8<Boolean32> enable = new();
+            Span<Boolean32> enableSpan = enable.AsSpan();
 
             for (int i = 0; i < 8; i++)
             {
-                enable[i] = new Boolean32((uint)(arg0 >> (i + 8)) & 1);
+                enableSpan[i] = new Boolean32((uint)(arg0 >> (i + 8)) & 1);
             }
 
-            _processor.ThreedClass.UpdateBlendEnable(ref enable);
+            _processor.ThreedClass.UpdateBlendEnable(enableSpan);
         }
 
         /// <summary>
@@ -236,13 +237,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         private void UpdateColorMasks(IDeviceState state, int arg0)
         {
             Array8<RtColorMask> masks = new();
+            Span<RtColorMask> masksSpan = masks.AsSpan();
 
             int index = 0;
 
             for (int i = 0; i < 4; i++)
             {
-                masks[index++] = new RtColorMask((uint)arg0 & 0x1fff);
+                masksSpan[index++] = new RtColorMask((uint)arg0 & 0x1fff);
-                masks[index++] = new RtColorMask(((uint)arg0 >> 16) & 0x1fff);
+                masksSpan[index++] = new RtColorMask(((uint)arg0 >> 16) & 0x1fff);
 
                 if (i != 3)
                 {
@@ -250,7 +252,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 }
             }
 
-            _processor.ThreedClass.UpdateColorMasks(ref masks);
+            _processor.ThreedClass.UpdateColorMasks(masksSpan);
         }
 
         /// <summary>

src/Ryujinx.Graphics.Gpu/Engine/Threed/Blender/AdvancedBlendManager.cs

@@ -75,10 +75,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.Blender
             {
                 bool constantsMatch = true;
 
+                Span<RgbHalf> blendUcodeConstantsSpan = _state.State.BlendUcodeConstants.AsSpan();
+
                 for (int i = 0; i < entry.Constants.Length; i++)
                 {
                     RgbFloat constant = entry.Constants[i];
-                    RgbHalf constant2 = _state.State.BlendUcodeConstants[i];
+                    RgbHalf constant2 = blendUcodeConstantsSpan[i];
 
                     if ((Half)constant.R != constant2.UnpackR() ||
                         (Half)constant.G != constant2.UnpackG() ||

src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VertexInfoBufferUpdater.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Shader;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -76,9 +77,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
         /// <param name="componentCount">Number of components that the format has</param>
         public void SetVertexStride(int index, int stride, int componentCount)
         {
-            if (_data.VertexStrides[index].X != stride)
+            Span<Vector4<int>> vertexStridesSpan = _data.VertexStrides.AsSpan();
+            
+            if (vertexStridesSpan[index].X != stride)
             {
-                _data.VertexStrides[index].X = stride;
+                vertexStridesSpan[index].X = stride;
                 MarkDirty(VertexInfoBuffer.VertexStridesOffset + index * Unsafe.SizeOf<Vector4<int>>(), sizeof(int));
             }
 
@@ -86,7 +89,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
             {
                 int value = c < componentCount ? 1 : 0;
 
-                ref int currentValue = ref GetElementRef(ref _data.VertexStrides[index], c);
+                ref int currentValue = ref GetElementRef(ref vertexStridesSpan[index], c);
 
                 if (currentValue != value)
                 {
@@ -104,15 +107,17 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
         /// <param name="divisor">If the draw is instanced, should have the vertex divisor value, otherwise should be zero</param>
         public void SetVertexOffset(int index, int offset, int divisor)
         {
-            if (_data.VertexOffsets[index].X != offset)
+            Span<Vector4<int>> vertexOffsetsSpan = _data.VertexOffsets.AsSpan();
+            
+            if (vertexOffsetsSpan[index].X != offset)
             {
-                _data.VertexOffsets[index].X = offset;
+                vertexOffsetsSpan[index].X = offset;
                 MarkDirty(VertexInfoBuffer.VertexOffsetsOffset + index * Unsafe.SizeOf<Vector4<int>>(), sizeof(int));
             }
 
-            if (_data.VertexOffsets[index].Y != divisor)
+            if (vertexOffsetsSpan[index].Y != divisor)
             {
-                _data.VertexOffsets[index].Y = divisor;
+                vertexOffsetsSpan[index].Y = divisor;
                 MarkDirty(VertexInfoBuffer.VertexOffsetsOffset + index * Unsafe.SizeOf<Vector4<int>>() + sizeof(int), sizeof(int));
             }
         }

src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VtgAsComputeState.cs

@@ -125,9 +125,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
             _vacContext.VertexInfoBufferUpdater.SetVertexCounts(_count, _instanceCount, _firstVertex, _firstInstance);
             _vacContext.VertexInfoBufferUpdater.SetGeometryCounts(primitivesCount);
 
+            Span<VertexAttribState> vertexAttribStateSpan = _state.State.VertexAttribState.AsSpan();
+            Span<GpuVa> vertexBufferEndAddressSpan = _state.State.VertexBufferEndAddress.AsSpan();
+            Span<VertexBufferState> vertexBufferStateSpan = _state.State.VertexBufferState.AsSpan();
+            Span<Boolean32> vertexBufferInstancedSpan = _state.State.VertexBufferInstanced.AsSpan();
+
             for (int index = 0; index < Constants.TotalVertexAttribs; index++)
             {
-                VertexAttribState vertexAttrib = _state.State.VertexAttribState[index];
+                VertexAttribState vertexAttrib = vertexAttribStateSpan[index];
 
                 if (!FormatTable.TryGetSingleComponentAttribFormat(vertexAttrib.UnpackFormat(), out Format format, out int componentsCount))
                 {
@@ -153,9 +158,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
 
                 int bufferIndex = vertexAttrib.UnpackBufferIndex();
 
-                GpuVa endAddress = _state.State.VertexBufferEndAddress[bufferIndex];
+                GpuVa endAddress = vertexBufferEndAddressSpan[bufferIndex];
-                VertexBufferState vertexBuffer = _state.State.VertexBufferState[bufferIndex];
+                VertexBufferState vertexBuffer = vertexBufferStateSpan[bufferIndex];
-                bool instanced = _state.State.VertexBufferInstanced[bufferIndex];
+                bool instanced = vertexBufferInstancedSpan[bufferIndex];
 
                 ulong address = vertexBuffer.Address.Pack();
 

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

@@ -822,6 +822,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             // host clipping.
             ScreenScissorState screenScissorState = _state.State.ScreenScissorState;
             
+            Span<ScissorState> scissorStateSpan = _state.State.ScissorState.AsSpan();
+
             bool clearAffectedByStencilMask = (_state.State.ClearFlags & 1) != 0;
             bool clearAffectedByScissor = (_state.State.ClearFlags & 0x100) != 0;
 
@@ -831,9 +833,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 bool fullClear = screenScissorState.X == 0 && screenScissorState.Y == 0;
 
-                if (fullClear && clearAffectedByScissor && _state.State.ScissorState[0].Enable)
+                if (fullClear && clearAffectedByScissor && scissorStateSpan[0].Enable)
                 {
-                    ref ScissorState scissorState = ref _state.State.ScissorState[0];
+                    ref ScissorState scissorState = ref scissorStateSpan[0];
 
                     fullClear = scissorState.X1 == screenScissorState.X &&
                         scissorState.Y1 == screenScissorState.Y &&
@@ -892,9 +894,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 int scissorW = screenScissorState.Width;
                 int scissorH = screenScissorState.Height;
 
-                if (clearAffectedByScissor && _state.State.ScissorState[0].Enable)
+                if (clearAffectedByScissor && scissorStateSpan[0].Enable)
                 {
-                    ref ScissorState scissorState = ref _state.State.ScissorState[0];
+                    ref ScissorState scissorState = ref scissorStateSpan[0];
 
                     scissorX = Math.Max(scissorX, scissorState.X1);
                     scissorY = Math.Max(scissorY, scissorState.Y1);

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

@@ -3,6 +3,7 @@ using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Types;
 using Ryujinx.Graphics.Gpu.Shader;
 using Ryujinx.Graphics.Shader;
+using System;
 
 namespace Ryujinx.Graphics.Gpu.Engine.Threed
 {
@@ -214,10 +215,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// Updates the type of the vertex attributes consumed by the shader.
         /// </summary>
         /// <param name="state">The new state</param>
-        public void SetAttributeTypes(ref Array32<VertexAttribState> state)
+        public void SetAttributeTypes(ReadOnlySpan<VertexAttribState> state)
         {
             bool changed = false;
-            ref Array32<AttributeType> attributeTypes = ref _graphics.AttributeTypes;
+            // ref Array32<AttributeType> attributeTypes = ref _graphics.AttributeTypes;
+            Span<AttributeType> attributeTypesSpan = _graphics.AttributeTypes.AsSpan();
             bool mayConvertVtgToCompute = ShaderCache.MayConvertVtgToCompute(ref _context.Capabilities);
             bool supportsScaledFormats = _context.Capabilities.SupportsScaledVertexFormats && !mayConvertVtgToCompute;
 
@@ -261,9 +263,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     }
                 }
 
-                if (attributeTypes[location] != value)
+                if (attributeTypesSpan[location] != value)
                 {
-                    attributeTypes[location] = value;
+                    attributeTypesSpan[location] = value;
                     changed = true;
                 }
             }
@@ -279,11 +281,13 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         /// <param name="rtControl">The render target control register</param>
         /// <param name="state">The color attachment state</param>
-        public void SetFragmentOutputTypes(RtControl rtControl, ref Array8<RtColorState> state)
+        public void SetFragmentOutputTypes(RtControl rtControl, ReadOnlySpan<RtColorState> state)
         {
             bool changed = false;
             int count = rtControl.UnpackCount();
             
+            Span<AttributeType> fragmentOutputTypesSpan = _graphics.FragmentOutputTypes.AsSpan();
+
             for (int index = 0; index < Constants.TotalRenderTargets; index++)
             {
                 int rtIndex = rtControl.UnpackPermutationIndex(index);
@@ -296,9 +300,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                     AttributeType type = format.IsInteger() ? (format.IsSint() ? AttributeType.Sint : AttributeType.Uint) : AttributeType.Float;
 
-                    if (type != _graphics.FragmentOutputTypes[index])
+                    if (type != fragmentOutputTypesSpan[index])
                     {
-                        _graphics.FragmentOutputTypes[index] = type;
+                        fragmentOutputTypesSpan[index] = type;
                         changed = true;
                     }
                 }

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

@@ -109,7 +109,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             if (index < BlockSize)
             {
-                int groupIndex = Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_registerToGroupMapping), (nint)index);
+                int groupIndex = _registerToGroupMapping[index];
                 if (groupIndex != 0)
                 {
                     groupIndex--;

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

@@ -423,9 +423,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void UpdateTfBufferState()
         {
+            Span<TfBufferState> tfBufferStateSpan = _state.State.TfBufferState.AsSpan();
+            
             for (int index = 0; index < Constants.TotalTransformFeedbackBuffers; index++)
             {
-                TfBufferState tfb = _state.State.TfBufferState[index];
+                TfBufferState tfb = tfBufferStateSpan[index];
 
                 if (!tfb.Enable)
                 {
@@ -466,10 +468,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             MemoryManager memoryManager = _channel.MemoryManager;
             RtControl rtControl = _state.State.RtControl;
 
-            bool useControl = updateFlags.HasFlag(RenderTargetUpdateFlags.UseControl);
+            bool useControl = (updateFlags & RenderTargetUpdateFlags.UseControl) == RenderTargetUpdateFlags.UseControl;
-            bool layered = updateFlags.HasFlag(RenderTargetUpdateFlags.Layered);
+            bool layered = (updateFlags & RenderTargetUpdateFlags.Layered) == RenderTargetUpdateFlags.Layered;
-            bool singleColor = updateFlags.HasFlag(RenderTargetUpdateFlags.SingleColor);
+            bool singleColor = (updateFlags & RenderTargetUpdateFlags.SingleColor) == RenderTargetUpdateFlags.SingleColor;
-            bool discard = updateFlags.HasFlag(RenderTargetUpdateFlags.DiscardClip);
+            bool discard = (updateFlags & RenderTargetUpdateFlags.DiscardClip) == RenderTargetUpdateFlags.DiscardClip;
 
             int count = useControl ? rtControl.UnpackCount() : Constants.TotalRenderTargets;
 
@@ -487,11 +489,13 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             bool changedScale = false;
             uint rtNoAlphaMask = 0;
 
+            Span<RtColorState> rtColorStateSpan = _state.State.RtColorState.AsSpan();
+
             for (int index = 0; index < Constants.TotalRenderTargets; index++)
             {
                 int rtIndex = useControl ? rtControl.UnpackPermutationIndex(index) : index;
 
-                RtColorState colorState = _state.State.RtColorState[rtIndex];
+                RtColorState colorState = rtColorStateSpan[rtIndex];
 
                 if (index >= count || !IsRtEnabled(colorState) || (singleColor && index != singleUse))
                 {
@@ -539,7 +543,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             Image.Texture depthStencil = null;
 
-            if (dsEnable && updateFlags.HasFlag(RenderTargetUpdateFlags.UpdateDepthStencil))
+            if (dsEnable && (updateFlags & RenderTargetUpdateFlags.UpdateDepthStencil) == RenderTargetUpdateFlags.UpdateDepthStencil)
             {
                 RtDepthStencilState dsState = _state.State.RtDepthStencilState;
                 Size3D dsSize = _state.State.RtDepthStencilSize;
@@ -599,7 +603,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         public void UpdateRenderTargetSpecialization()
         {
-            _currentSpecState.SetFragmentOutputTypes(_state.State.RtControl, ref _state.State.RtColorState);
+            _currentSpecState.SetFragmentOutputTypes(_state.State.RtControl, _state.State.RtColorState.AsSpan());
         }
 
         /// <summary>
@@ -624,10 +628,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             const int MaxH = 0xffff;
 
             Span<Rectangle<int>> regions = stackalloc Rectangle<int>[Constants.TotalViewports];
+            Span<ScissorState> scissorStateSpan = _state.State.ScissorState.AsSpan();
             
             for (int index = 0; index < Constants.TotalViewports; index++)
             {
-                ScissorState scissor = _state.State.ScissorState[index];
+                ScissorState scissor = scissorStateSpan[index];
 
                 bool enable = scissor.Enable && (scissor.X1 != MinX ||
                                                  scissor.Y1 != MinY ||
@@ -731,6 +736,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             UpdateDepthMode();
 
             Span<Viewport> viewports = stackalloc Viewport[Constants.TotalViewports];
+            Span<ViewportTransform> viewportTransformSpan = _state.State.ViewportTransform.AsSpan();
+            Span<ViewportExtents> viewportExtentsSpan = _state.State.ViewportExtents.AsSpan();
 
             for (int index = 0; index < Constants.TotalViewports; index++)
             {
@@ -745,8 +752,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     continue;
                 }
 
-                ref ViewportTransform transform = ref _state.State.ViewportTransform[index];
+                ref ViewportTransform transform = ref viewportTransformSpan[index];
-                ref ViewportExtents extents = ref _state.State.ViewportExtents[index];
+                ref ViewportExtents extents = ref viewportExtentsSpan[index];
 
                 float scaleX = MathF.Abs(transform.ScaleX);
                 float scaleY = transform.ScaleY;
@@ -968,10 +975,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             uint vbEnableMask = _vbEnableMask;
 
             Span<VertexAttribDescriptor> vertexAttribs = stackalloc VertexAttribDescriptor[Constants.TotalVertexAttribs];
+            Span<VertexAttribState> vertexAttribStateSpan = _state.State.VertexAttribState.AsSpan();
             
             for (int index = 0; index < Constants.TotalVertexAttribs; index++)
             {
-                VertexAttribState vertexAttrib = _state.State.VertexAttribState[index];
+                VertexAttribState vertexAttrib = vertexAttribStateSpan[index];
 
                 int bufferIndex = vertexAttrib.UnpackBufferIndex();
 
@@ -1015,7 +1023,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             _pipeline.SetVertexAttribs(vertexAttribs);
             _context.Renderer.Pipeline.SetVertexAttribs(vertexAttribs);
-            _currentSpecState.SetAttributeTypes(ref _state.State.VertexAttribState);
+            _currentSpecState.SetAttributeTypes(_state.State.VertexAttribState.AsSpan());
         }
 
         /// <summary>
@@ -1114,19 +1122,24 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             int drawVertexCount = _drawState.DrawVertexCount;
             uint vbEnableMask = 0;
             
+            Span<VertexBufferState> vertexBufferStateSpan = _state.State.VertexBufferState.AsSpan();
+            Span<BufferPipelineDescriptor> vertexBuffersSpan = _pipeline.VertexBuffers.AsSpan();
+            Span<GpuVa> vertexBufferEndAddressSpan = _state.State.VertexBufferEndAddress.AsSpan();
+            Span<Boolean32> vertexBufferInstancedSpan = _state.State.VertexBufferInstanced.AsSpan();
+
             for (int index = 0; index < Constants.TotalVertexBuffers; index++)
             {
-                VertexBufferState vertexBuffer = _state.State.VertexBufferState[index];
+                VertexBufferState vertexBuffer = vertexBufferStateSpan[index];
 
                 if (!vertexBuffer.UnpackEnable())
                 {
-                    _pipeline.VertexBuffers[index] = new BufferPipelineDescriptor(false, 0, 0);
+                    vertexBuffersSpan[index] = new BufferPipelineDescriptor(false, 0, 0);
                     _channel.BufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
 
                     continue;
                 }
 
-                GpuVa endAddress = _state.State.VertexBufferEndAddress[index];
+                GpuVa endAddress = vertexBufferEndAddressSpan[index];
 
                 ulong address = vertexBuffer.Address.Pack();
 
@@ -1137,7 +1150,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 int stride = vertexBuffer.UnpackStride();
 
-                bool instanced = _state.State.VertexBufferInstanced[index];
+                bool instanced = vertexBufferInstancedSpan[index];
 
                 int divisor = instanced ? vertexBuffer.Divisor : 0;
 
@@ -1184,7 +1197,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     size = Math.Min(vbSize, (ulong)((firstInstance + drawFirstVertex + drawVertexCount) * stride));
                 }
 
-                _pipeline.VertexBuffers[index] = new BufferPipelineDescriptor(_channel.MemoryManager.IsMapped(address), stride, divisor);
+                vertexBuffersSpan[index] = new BufferPipelineDescriptor(_channel.MemoryManager.IsMapped(address), stride, divisor);
                 _channel.BufferManager.SetVertexBuffer(index, address, size, stride, divisor);
             }
 
@@ -1237,10 +1250,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             bool rtColorMaskShared = _state.State.RtColorMaskShared;
 
             Span<uint> componentMasks = stackalloc uint[Constants.TotalRenderTargets];
+            Span<RtColorMask> rtColorMaskSpan = _state.State.RtColorMask.AsSpan();
+            Span<uint> colorWriteMaskSpan = _pipeline.ColorWriteMask.AsSpan();
 
             for (int index = 0; index < Constants.TotalRenderTargets; index++)
             {
-                RtColorMask colorMask = _state.State.RtColorMask[rtColorMaskShared ? 0 : index];
+                RtColorMask colorMask = rtColorMaskSpan[rtColorMaskShared ? 0 : index];
 
                 uint componentMask;
 
@@ -1250,7 +1265,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 componentMask |= (colorMask.UnpackAlpha() ? 8u : 0u);
 
                 componentMasks[index] = componentMask;
-                _pipeline.ColorWriteMask[index] = componentMask;
+                colorWriteMaskSpan[index] = componentMask;
             }
 
             _context.Renderer.Pipeline.SetRenderTargetColorMasks(componentMasks);
@@ -1282,10 +1297,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             if (blendIndependent)
             {
+                Span<Boolean32> blendEnableSpan = _state.State.BlendEnable.AsSpan();
+                Span<BlendState> blendStateSpan = _state.State.BlendState.AsSpan();
+                Span<BlendDescriptor> blendDescriptorsSpan = _pipeline.BlendDescriptors.AsSpan();
+                
                 for (int index = 0; index < Constants.TotalRenderTargets; index++)
                 {
-                    bool enable = _state.State.BlendEnable[index];
+                    bool enable = blendEnableSpan[index];
-                    BlendState blend = _state.State.BlendState[index];
+                    BlendState blend = blendStateSpan[index];
 
                     BlendDescriptor descriptor = new(
                         enable,
@@ -1306,7 +1325,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                         dualSourceBlendEnabled = true;
                     }
 
-                    _pipeline.BlendDescriptors[index] = descriptor;
+                    blendDescriptorsSpan[index] = descriptor;
                     _context.Renderer.Pipeline.SetBlendState(index, descriptor);
                 }
             }
@@ -1334,9 +1353,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     dualSourceBlendEnabled = true;
                 }
                 
+                Span<BlendDescriptor> blendDescriptorsSpan = _pipeline.BlendDescriptors.AsSpan();
+
                 for (int index = 0; index < Constants.TotalRenderTargets; index++)
                 {
-                    _pipeline.BlendDescriptors[index] = descriptor;
+                    blendDescriptorsSpan[index] = descriptor;
                     _context.Renderer.Pipeline.SetBlendState(index, descriptor);
                 }
             }
@@ -1422,12 +1443,13 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             ShaderAddresses addresses = new();
             Span<ulong> addressesSpan = addresses.AsSpan();
+            Span<ShaderState> shaderStateSpan = _state.State.ShaderState.AsSpan();
 
             ulong baseAddress = _state.State.ShaderBaseAddress.Pack();
 
             for (int index = 0; index < 6; index++)
             {
-                ShaderState shader = _state.State.ShaderState[index];
+                ShaderState shader = shaderStateSpan[index];
                 if (!shader.UnpackEnable() && index != 1)
                 {
                     continue;

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

@@ -242,22 +242,22 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// <param name="rhs">Second struct</param>
         /// <returns>True if equal, false otherwise</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static bool UnsafeEquals32Byte<T>(ref T lhs, ref T rhs) where T : unmanaged
+        private static bool UnsafeEquals32Byte<T>(Span<T> lhs, Span<T> rhs) where T : unmanaged
         {
             if (Vector256.IsHardwareAccelerated)
             {
                 return Vector256.EqualsAll(
-                    Unsafe.As<T, Vector256<uint>>(ref lhs),
+                    Unsafe.As<Span<T>, ReadOnlySpan<Vector256<uint>>>(ref lhs)[0],
-                    Unsafe.As<T, Vector256<uint>>(ref rhs)
+                    Unsafe.As<Span<T>, ReadOnlySpan<Vector256<uint>>>(ref rhs)[0]
                 );
             }
             else
             {
-                ref Vector128<uint> lhsVec = ref Unsafe.As<T, Vector128<uint>>(ref lhs);
+                ReadOnlySpan<Vector128<uint>> lhsVec = Unsafe.As<Span<T>, ReadOnlySpan<Vector128<uint>>>(ref lhs);
-                ref Vector128<uint> rhsVec = ref Unsafe.As<T, Vector128<uint>>(ref rhs);
+                ReadOnlySpan<Vector128<uint>> rhsVec = Unsafe.As<Span<T>, ReadOnlySpan<Vector128<uint>>>(ref rhs);
 
-                return Vector128.EqualsAll(lhsVec, rhsVec) &&
+                return Vector128.EqualsAll(lhsVec[0], rhsVec[0]) &&
-                    Vector128.EqualsAll(Unsafe.Add(ref lhsVec, 1), Unsafe.Add(ref rhsVec, 1));
+                    Vector128.EqualsAll(lhsVec[1], rhsVec[1]);
             }
         }
 
@@ -265,26 +265,26 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// Updates blend enable. Respects current shadow mode.
         /// </summary>
         /// <param name="masks">Blend enable</param>
-        public void UpdateBlendEnable(ref Array8<Boolean32> enable)
+        public void UpdateBlendEnable(Span<Boolean32> enable)
         {
             SetMmeShadowRamControlMode shadow = ShadowMode;
-            ref Array8<Boolean32> state = ref _state.State.BlendEnable;
+            Span<Boolean32> state = _state.State.BlendEnable.AsSpan();
 
             if (shadow.IsReplay())
             {
-                enable = _state.ShadowState.BlendEnable;
+                state.CopyTo(enable);
             }
 
-            if (!UnsafeEquals32Byte(ref enable, ref state))
+            if (!UnsafeEquals32Byte(enable, state))
             {
-                state = enable;
+                enable.CopyTo(state);
 
                 _stateUpdater.ForceDirty(StateUpdater.BlendStateIndex);
             }
 
             if (shadow.IsTrack())
             {
-                _state.ShadowState.BlendEnable = enable;
+                enable.CopyTo(state);
             }
         }
 
@@ -292,26 +292,26 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// Updates color masks. Respects current shadow mode.
         /// </summary>
         /// <param name="masks">Color masks</param>
-        public void UpdateColorMasks(ref Array8<RtColorMask> masks)
+        public void UpdateColorMasks(Span<RtColorMask> masks)
         {
             SetMmeShadowRamControlMode shadow = ShadowMode;
-            ref Array8<RtColorMask> state = ref _state.State.RtColorMask;
+            Span<RtColorMask> state = _state.State.RtColorMask.AsSpan();
 
             if (shadow.IsReplay())
             {
-                masks = _state.ShadowState.RtColorMask;
+                state.CopyTo(masks);
             }
 
-            if (!UnsafeEquals32Byte(ref masks, ref state))
+            if (!UnsafeEquals32Byte(masks, state))
             {
-                state = masks;
+                masks.CopyTo(state);
 
                 _stateUpdater.ForceDirty(StateUpdater.RtColorMaskIndex);
             }
 
             if (shadow.IsTrack())
             {
-                _state.ShadowState.RtColorMask = masks;
+                masks.CopyTo(state);
             }
         }
 

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

@@ -72,7 +72,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
     /// </summary>
     class BufferModifiedRangeList : NonOverlappingRangeList<BufferModifiedRange>
     {
-        private new const int BackingInitialSize = 8;
+        private const int BackingInitialSize = 8;
 
         private readonly GpuContext _context;
         private readonly Buffer _parent;
@@ -81,6 +81,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
         private BufferMigration _source;
         private BufferModifiedRangeList _migrationTarget;
         
+        private List<RangeItem<BufferModifiedRange>> _overlaps;
+
         /// <summary>
         /// Whether the modified range list has any entries or not.
         /// </summary>
@@ -106,6 +108,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _context = context;
             _parent = parent;
             _flushAction = flushAction;
+            _overlaps = [];
         }
 
         /// <summary>
@@ -117,11 +120,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         public void ExcludeModifiedRegions(ulong address, ulong size, Action<ulong, ulong> action)
         {
             // Slices a given region using the modified regions in the list. Calls the action for the new slices.
-            bool lockOwner = Lock.IsReadLockHeld;
-            if (!lockOwner)
-            {
             Lock.EnterReadLock();
-            }
 
             (RangeItem<BufferModifiedRange> first, RangeItem<BufferModifiedRange> last) = FindOverlaps(address, size);
 
@@ -142,10 +141,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                 current = current.Next;
             }
 
-            if (!lockOwner)
-            {
             Lock.ExitReadLock();
-            }
 
             if ((long)size > 0)
             {
@@ -176,9 +172,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                 return;
             }
 
-            BufferModifiedRange buffPost = null;
+            
-            bool extendsPost = false;
-            bool extendsPre = false;
 
             if (first == last)
             {
@@ -193,14 +187,12 @@ namespace Ryujinx.Graphics.Gpu.Memory
                 if (first.Address < address)
                 {
                     first.Value.Size = address - first.Address;
-
+                    Update(first);
-                    extendsPre = true;
 
                     if (first.EndAddress > endAddress)
                     {
-                        buffPost = new BufferModifiedRange(endAddress, first.EndAddress - endAddress,
+                        Add(new BufferModifiedRange(endAddress, first.EndAddress - endAddress,
-                            first.Value.SyncNumber, first.Value.Parent);
+                            first.Value.SyncNumber, first.Value.Parent));
-                        extendsPost = true;
                     }
                 }
                 else
@@ -209,6 +201,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                     {
                         first.Value.Size = first.EndAddress - endAddress;
                         first.Value.Address = endAddress;
+                        Update(first);
                     }
                     else
                     {
@@ -216,11 +209,6 @@ namespace Ryujinx.Graphics.Gpu.Memory
                     }
                 }
 
-                if (extendsPre && extendsPost)
-                {
-                    Add(buffPost);
-                }
-
                 Add(new BufferModifiedRange(address, size, syncNumber, this));
                 Lock.ExitWriteLock();
 
@@ -228,6 +216,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
 
             BufferModifiedRange buffPre = null;
+            BufferModifiedRange buffPost = null;
+            bool extendsPost = false;
+            bool extendsPre = false;
 
             if (first.Address < address)
             {
@@ -295,23 +286,24 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="rangeAction">The action to call for each modified range</param>
         public void GetRanges(ulong address, ulong size, Action<ulong, ulong> rangeAction)
         {
-            List<RangeItem<BufferModifiedRange>> overlaps = [];
-            
             // We use the non-span method here because keeping the lock will cause a deadlock.
             Lock.EnterReadLock();
+            
+            _overlaps.Clear();
+            
             (RangeItem<BufferModifiedRange> first, RangeItem<BufferModifiedRange> last) = FindOverlaps(address, size);
             
             RangeItem<BufferModifiedRange> current = first;
             while (last != null && current != last.Next)
             {
-                overlaps.Add(current);
+                _overlaps.Add(current);
                 current = current.Next;
             }
             Lock.ExitReadLock();
 
-            for (int i = 0; i < overlaps.Count; i++)
+            for (int i = 0; i < _overlaps.Count; i++)
             {
-                BufferModifiedRange overlap = overlaps[i].Value;
+                BufferModifiedRange overlap = _overlaps[i].Value;
                 rangeAction(overlap.Address, overlap.Size);
             }
         }
@@ -325,7 +317,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         public bool HasRange(ulong address, ulong size)
         {
             Lock.EnterReadLock();
-            (RangeItem<BufferModifiedRange> first, RangeItem<BufferModifiedRange> _) = FindOverlaps(address, size);
+            RangeItem<BufferModifiedRange> first = FindOverlapFast(address, size);
             bool result = first is not null;
             Lock.ExitReadLock();
             return result;
@@ -382,9 +374,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                         ulong clampAddress = Math.Max(address, overlap.Address);
                         ulong clampEnd = Math.Min(endAddress, overlap.EndAddress);
 
-                        Lock.EnterWriteLock();
                         ClearPart(overlap, clampAddress, clampEnd);
-                        Lock.ExitWriteLock();
 
                         RangeActionWithMigration(clampAddress, clampEnd - clampAddress, waitSync, _flushAction);
                     }
@@ -414,40 +404,33 @@ namespace Ryujinx.Graphics.Gpu.Memory
             ulong endAddress = address + size;
             ulong currentSync = _context.SyncNumber;
 
-            int rangeCount = 0;
-
             List<RangeItem<BufferModifiedRange>> overlaps = [];
 
             // Range list must be consistent for this operation
-            Lock.EnterReadLock();
             if (_migrationTarget != null)
-            {
-                rangeCount = -1;
-            }
-            else
-            {
-                // We use the non-span method here because the array is partially modified by the code, which would invalidate a span.
-                (RangeItem<BufferModifiedRange> first, RangeItem<BufferModifiedRange> last) = FindOverlaps(address, size);
-            
-                RangeItem<BufferModifiedRange> current = first;
-                while (last != null && current != last.Next)
-                {
-                    rangeCount++;
-                    overlaps.Add(current);
-                    current = current.Next;
-                }
-            }
-            Lock.ExitReadLock();
-
-            if (rangeCount == -1)
             {
                 _migrationTarget!.WaitForAndFlushRanges(address, size);
 
                 return;
             }
             
+            Lock.EnterWriteLock();
+            // We use the non-span method here because the array is partially modified by the code, which would invalidate a span.
+            (RangeItem<BufferModifiedRange> first, RangeItem<BufferModifiedRange> last) = FindOverlaps(address, size);
+            
+            RangeItem<BufferModifiedRange> current = first;
+            while (last != null && current != last.Next)
+            {
+                overlaps.Add(current);
+                current = current.Next;
+            }
+                
+            int rangeCount = overlaps.Count;
+
             if (rangeCount == 0)
             {
+                Lock.ExitWriteLock();
+                
                 return;
             }
 
@@ -470,6 +453,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             if (highestDiff == long.MinValue)
             {
+                Lock.ExitWriteLock();
+                
                 return;
             }
 
@@ -477,6 +462,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _context.Renderer.WaitSync(currentSync + (ulong)highestDiff);
 
             RemoveRangesAndFlush(overlaps.ToArray(), rangeCount, highestDiff, currentSync, address, endAddress);
+            
+            Lock.ExitWriteLock();
         }
 
         /// <summary>
@@ -603,22 +590,17 @@ namespace Ryujinx.Graphics.Gpu.Memory
                 return;
             }
 
-            BufferModifiedRange buffPost = null;
-            bool extendsPost = false;
-            bool extendsPre = false;
-
             if (first == last)
             {
                 if (first.Address < address)
                 {
                     first.Value.Size = address - first.Address;
-                    extendsPre = true;
+                    Update(first);
 
                     if (first.EndAddress > endAddress)
                     {
-                        buffPost = new BufferModifiedRange(endAddress, first.EndAddress - endAddress,
+                        Add(new BufferModifiedRange(endAddress, first.EndAddress - endAddress,
-                            first.Value.SyncNumber, first.Value.Parent);
+                            first.Value.SyncNumber, first.Value.Parent));
-                        extendsPost = true;
                     }
                 }
                 else
@@ -627,6 +609,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
                     {
                         first.Value.Size = first.EndAddress - endAddress;
                         first.Value.Address = endAddress;
+                        Update(first);
                     }
                     else
                     {
@@ -634,16 +617,14 @@ namespace Ryujinx.Graphics.Gpu.Memory
                     }
                 }
 
-                if (extendsPre && extendsPost)
-                {
-                    Add(buffPost);
-                }
-
                 Lock.ExitWriteLock();
                 return;
             }
 
             BufferModifiedRange buffPre = null;
+            BufferModifiedRange buffPost = null;
+            bool extendsPost = false;
+            bool extendsPre = false;
 
             if (first.Address < address)
             {

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

@@ -54,7 +54,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static BufferStage FromUsage(BufferUsageFlags flags)
         {
-            if (flags.HasFlag(BufferUsageFlags.Write))
+            if ((flags & BufferUsageFlags.Write) == BufferUsageFlags.Write)
             {
                 return BufferStage.StorageWrite;
             }
@@ -67,7 +67,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static BufferStage FromUsage(TextureUsageFlags flags)
         {
-            if (flags.HasFlag(TextureUsageFlags.ImageStore))
+            if ((flags & TextureUsageFlags.ImageStore) == TextureUsageFlags.ImageStore)
             {
                 return BufferStage.StorageWrite;
             }

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

@@ -1,5 +1,6 @@
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Shader;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -104,9 +105,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="scale">Scale value</param>
         public void UpdateRenderScale(int index, float scale)
         {
-            if (_data.RenderScale[1 + index].X != scale)
+            Span<Vector4<float>> renderScaleSpan = _data.RenderScale.AsSpan();
+            
+            if (renderScaleSpan[1 + index].X != scale)
             {
-                _data.RenderScale[1 + index].X = scale;
+                renderScaleSpan[1 + index].X = scale;
                 DirtyRenderScale(1 + index, 1);
             }
         }
@@ -133,11 +136,13 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="isBgra">True if the format is BGRA< false otherwise</param>
         public void SetRenderTargetIsBgra(int index, bool isBgra)
         {
-            bool isBgraChanged = _data.FragmentIsBgra[index].X != 0 != isBgra;
+            Span<Vector4<int>> fragmentIsBgraSpan = _data.FragmentIsBgra.AsSpan();
+            
+            bool isBgraChanged = fragmentIsBgraSpan[index].X != 0 != isBgra;
 
             if (isBgraChanged)
             {
-                _data.FragmentIsBgra[index].X = isBgra ? 1 : 0;
+                fragmentIsBgraSpan[index].X = isBgra ? 1 : 0;
                 DirtyFragmentIsBgra(index, 1);
             }
         }

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

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Threed;
 using Ryujinx.Graphics.Gpu.Engine.Types;
@@ -258,21 +259,25 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             int count = rtControl.UnpackCount();
 
+            Span<RtColorState> rtColorStateSpan = state.RtColorState.AsSpan();
+            Span<bool> attachmentEnableSpan = pipeline.AttachmentEnable.AsSpan();
+            Span<Format> attachmentFormatsSpan = pipeline.AttachmentFormats.AsSpan();
+
             for (int index = 0; index < Constants.TotalRenderTargets; index++)
             {
                 int rtIndex = rtControl.UnpackPermutationIndex(index);
 
-                var colorState = state.RtColorState[rtIndex];
+                var colorState = rtColorStateSpan[rtIndex];
 
                 if (index >= count || colorState.Format == 0 || colorState.WidthOrStride == 0)
                 {
-                    pipeline.AttachmentEnable[index] = false;
+                    attachmentEnableSpan[index] = false;
-                    pipeline.AttachmentFormats[index] = Format.R8G8B8A8Unorm;
+                    attachmentFormatsSpan[index] = Format.R8G8B8A8Unorm;
                 }
                 else
                 {
-                    pipeline.AttachmentEnable[index] = true;
+                    attachmentEnableSpan[index] = true;
-                    pipeline.AttachmentFormats[index] = colorState.Format.Convert().Format;
+                    attachmentFormatsSpan[index] = colorState.Format.Convert().Format;
                 }
             }
 
@@ -580,15 +585,18 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             TransformFeedbackDescriptor[] descs = new TransformFeedbackDescriptor[Constants.TotalTransformFeedbackBuffers];
 
+            Span<TfState> tfStateSpan = state.TfState.AsSpan();
+            Span<Array32<uint>> tfVaryingLocationsSpan = state.TfVaryingLocations.AsSpan();
+            
             for (int i = 0; i < Constants.TotalTransformFeedbackBuffers; i++)
             {
-                var tf = state.TfState[i];
+                var tf = tfStateSpan[i];
 
                 descs[i] = new TransformFeedbackDescriptor(
                     tf.BufferIndex,
                     tf.Stride,
                     tf.VaryingsCount,
-                    ref state.TfVaryingLocations[i]);
+                    ref tfVaryingLocationsSpan[i]);
             }
 
             return descs;

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

@@ -580,10 +580,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             if (ShaderCache.MayConvertVtgToCompute(ref channel.Capabilities) && !vertexAsCompute)
             {
-                for (int index = 0; index < graphicsState.AttributeTypes.Length; index++)
+                Span<AttributeType> attributeTypesSpan = graphicsState.AttributeTypes.AsSpan();
+                Span<AttributeType> gAttributeTypesSpan = GraphicsState.AttributeTypes.AsSpan();
+                
+                for (int index = 0; index < attributeTypesSpan.Length; index++)
                 {
-                    AttributeType lType = FilterAttributeType(channel, graphicsState.AttributeTypes[index]);
+                    AttributeType lType = FilterAttributeType(channel, attributeTypesSpan[index]);
-                    AttributeType rType = FilterAttributeType(channel, GraphicsState.AttributeTypes[index]);
+                    AttributeType rType = FilterAttributeType(channel, gAttributeTypesSpan[index]);
 
                     if (lType != rType)
                     {
@@ -729,6 +732,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             int constantBufferUsePerStageMask = _constantBufferUsePerStage;
 
+            Span<uint> constantBufferUseSpan = ConstantBufferUse.AsSpan();
+            
             while (constantBufferUsePerStageMask != 0)
             {
                 int index = BitOperations.TrailingZeroCount(constantBufferUsePerStageMask);
@@ -737,7 +742,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                     ? channel.BufferManager.GetComputeUniformBufferUseMask()
                     : channel.BufferManager.GetGraphicsUniformBufferUseMask(index);
 
-                if (ConstantBufferUse[index] != useMask)
+                if (constantBufferUseSpan[index] != useMask)
                 {
                     return false;
                 }
@@ -801,7 +806,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         {
             if (specializationState != null)
             {
-                if (specializationState.Value.QueriedFlags.HasFlag(QueriedTextureStateFlags.CoordNormalized) &&
+                if ((specializationState.Value.QueriedFlags & QueriedTextureStateFlags.CoordNormalized) == QueriedTextureStateFlags.CoordNormalized &&
                     specializationState.Value.CoordNormalized != descriptor.UnpackTextureCoordNormalized())
                 {
                     return false;
@@ -877,10 +882,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             int constantBufferUsePerStageMask = specState._constantBufferUsePerStage;
 
+            Span<uint> constantBufferUseSpan = specState.ConstantBufferUse.AsSpan();
+            
             while (constantBufferUsePerStageMask != 0)
             {
                 int index = BitOperations.TrailingZeroCount(constantBufferUsePerStageMask);
-                dataReader.Read(ref specState.ConstantBufferUse[index]);
+                dataReader.Read(ref constantBufferUseSpan[index]);
                 constantBufferUsePerStageMask &= ~(1 << index);
             }
 
@@ -980,10 +987,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             int constantBufferUsePerStageMask = _constantBufferUsePerStage;
             
+            Span<uint> constantBufferUseSpan = ConstantBufferUse.AsSpan();
+
             while (constantBufferUsePerStageMask != 0)
             {
                 int index = BitOperations.TrailingZeroCount(constantBufferUsePerStageMask);
-                dataWriter.Write(ref ConstantBufferUse[index]);
+                dataWriter.Write(ref constantBufferUseSpan[index]);
                 constantBufferUsePerStageMask &= ~(1 << index);
             }
 

src/Ryujinx.Graphics.Nvdec.FFmpeg/H264/SpsAndPpsReconstruction.cs

@@ -92,20 +92,24 @@ namespace Ryujinx.Graphics.Nvdec.FFmpeg.H264
 
             if (pictureInfo.ScalingMatrixPresent)
             {
+                Span<Array16<byte>> scalingLists4x4Span = pictureInfo.ScalingLists4x4.AsSpan();
+                
                 for (int index = 0; index < 6; index++)
                 {
                     writer.WriteBit(true);
 
-                    WriteScalingList(ref writer, pictureInfo.ScalingLists4x4[index]);
+                    WriteScalingList(ref writer, scalingLists4x4Span[index]);
                 }
 
                 if (pictureInfo.Transform8x8ModeFlag)
                 {
+                    Span<Array64<byte>> scalingLists8x8Span = pictureInfo.ScalingLists8x8.AsSpan();
+                    
                     for (int index = 0; index < 2; index++)
                     {
                         writer.WriteBit(true);
 
-                        WriteScalingList(ref writer, pictureInfo.ScalingLists8x8[index]);
+                        WriteScalingList(ref writer, scalingLists8x8Span[index]);
                     }
                 }
             }
@@ -144,9 +148,11 @@ namespace Ryujinx.Graphics.Nvdec.FFmpeg.H264
 
             int lastScale = 8;
 
-            for (int index = 0; index < list.Length; index++)
+            Span<byte> listSpan = list.AsSpan();
+
+            for (int index = 0; index < listSpan.Length; index++)
             {
-                byte value = list[scan[index]];
+                byte value = listSpan[scan[index]];
 
                 int deltaScale = value - lastScale;
 

src/Ryujinx.Graphics.Nvdec.Vp9/DecodeFrame.cs

@@ -21,49 +21,67 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
         private static void ReadTxModeProbs(ref Vp9EntropyProbs txProbs, ref Reader r)
         {
+            Span<Array1<byte>> tx8x8ProbSpan1 = txProbs.Tx8x8Prob.AsSpan();
+            Span<Array2<byte>> tx16x16ProbSpan1 = txProbs.Tx16x16Prob.AsSpan();
+            Span<Array3<byte>> tx32x32ProbSpan1 = txProbs.Tx32x32Prob.AsSpan();
+            
             for (int i = 0; i < EntropyMode.TxSizeContexts; ++i)
             {
+                Span<byte> tx8x8ProbSpan2 = tx8x8ProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < (int)TxSize.TxSizes - 3; ++j)
                 {
-                    r.DiffUpdateProb(ref txProbs.Tx8x8Prob[i][j]);
+                    r.DiffUpdateProb(ref tx8x8ProbSpan2[j]);
                 }
             }
 
             for (int i = 0; i < EntropyMode.TxSizeContexts; ++i)
             {
+                Span<byte> tx16x16ProbSpan2 = tx16x16ProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < (int)TxSize.TxSizes - 2; ++j)
                 {
-                    r.DiffUpdateProb(ref txProbs.Tx16x16Prob[i][j]);
+                    r.DiffUpdateProb(ref tx16x16ProbSpan2[j]);
                 }
             }
 
             for (int i = 0; i < EntropyMode.TxSizeContexts; ++i)
             {
+                Span<byte> tx32x32ProbSpan2 = tx32x32ProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < (int)TxSize.TxSizes - 1; ++j)
                 {
-                    r.DiffUpdateProb(ref txProbs.Tx32x32Prob[i][j]);
+                    r.DiffUpdateProb(ref tx32x32ProbSpan2[j]);
                 }
             }
         }
 
         private static void ReadSwitchableInterpProbs(ref Vp9EntropyProbs fc, ref Reader r)
         {
-            for (int j = 0; j < Constants.SwitchableFilterContexts; ++j)
+            Span<Array2<byte>> switchableInterpProbSpan1 = fc.SwitchableInterpProb.AsSpan();
+            
+            for (int i = 0; i < Constants.SwitchableFilterContexts; ++i)
             {
-                for (int i = 0; i < Constants.SwitchableFilters - 1; ++i)
+                Span<byte> switchableInterpProbSpan2 = switchableInterpProbSpan1[i].AsSpan();
+                
+                for (int j = 0; j < Constants.SwitchableFilters - 1; ++j)
                 {
-                    r.DiffUpdateProb(ref fc.SwitchableInterpProb[j][i]);
+                    r.DiffUpdateProb(ref switchableInterpProbSpan2[j]);
                 }
             }
         }
 
         private static void ReadInterModeProbs(ref Vp9EntropyProbs fc, ref Reader r)
         {
+            Span<Array3<byte>> interModeProbSpan1 = fc.InterModeProb.AsSpan();
+            
             for (int i = 0; i < Constants.InterModeContexts; ++i)
             {
+                Span<byte> interModeProbSpan2 = interModeProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < Constants.InterModes - 1; ++j)
                 {
-                    r.DiffUpdateProb(ref fc.InterModeProb[i][j]);
+                    r.DiffUpdateProb(ref interModeProbSpan2[j]);
                 }
             }
         }
@@ -72,30 +90,43 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             r.UpdateMvProbs(ctx.Joints.AsSpan(), EntropyMv.Joints - 1);
 
-            for (int i = 0; i < 2; ++i)
+            Span<byte> signSpan = ctx.Sign.AsSpan();
-            {
+            Span<Array10<byte>> classesSpan = ctx.Classes.AsSpan();
-                r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref ctx.Sign[i], 1), 1);
+            Span<Array1<byte>> class0Span = ctx.Class0.AsSpan();
-                r.UpdateMvProbs(ctx.Classes[i].AsSpan(), EntropyMv.Classes - 1);
+            Span<Array10<byte>> bitsSpan = ctx.Bits.AsSpan();
-                r.UpdateMvProbs(ctx.Class0[i].AsSpan(), EntropyMv.Class0Size - 1);
-                r.UpdateMvProbs(ctx.Bits[i].AsSpan(), EntropyMv.OffsetBits);
-            }
 
             for (int i = 0; i < 2; ++i)
             {
+                r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref signSpan[i], 1), 1);
+                r.UpdateMvProbs(classesSpan[i].AsSpan(), EntropyMv.Classes - 1);
+                r.UpdateMvProbs(class0Span[i].AsSpan(), EntropyMv.Class0Size - 1);
+                r.UpdateMvProbs(bitsSpan[i].AsSpan(), EntropyMv.OffsetBits);
+            }
+            
+            Span<Array2<Array3<byte>>> class0FpSpan1 = ctx.Class0Fp.AsSpan();
+            Span<Array3<byte>> fpSpan = ctx.Fp.AsSpan();
+
+            for (int i = 0; i < 2; ++i)
+            {
+                Span<Array3<byte>> class0FpSpan2 = class0FpSpan1[i].AsSpan();
+                
                 for (int j = 0; j < EntropyMv.Class0Size; ++j)
                 {
-                    r.UpdateMvProbs(ctx.Class0Fp[i][j].AsSpan(), EntropyMv.FpSize - 1);
+                    r.UpdateMvProbs(class0FpSpan2[j].AsSpan(), EntropyMv.FpSize - 1);
                 }
 
-                r.UpdateMvProbs(ctx.Fp[i].AsSpan(), 3);
+                r.UpdateMvProbs(fpSpan[i].AsSpan(), 3);
             }
 
             if (allowHp)
             {
+                Span<byte> class0HpSpan = ctx.Class0Hp.AsSpan();
+                Span<byte> hpSpan = ctx.Hp.AsSpan();
+                
                 for (int i = 0; i < 2; ++i)
                 {
-                    r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref ctx.Class0Hp[i], 1), 1);
+                    r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref class0HpSpan[i], 1), 1);
-                    r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref ctx.Hp[i], 1), 1);
+                    r.UpdateMvProbs(MemoryMarshal.CreateSpan(ref hpSpan[i], 1), 1);
                 }
             }
         }
@@ -751,10 +782,16 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             int refr;
             bool isScaled;
 
+            Span<sbyte> refFrameSpan = mi.RefFrame.AsSpan();
+            Span<Mv> mvSpan = mi.Mv.AsSpan();
+            Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
+            Span<Ptr<RefBuffer>> blockRefsSpan = xd.BlockRefs.AsSpan();
+            Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
+
             for (refr = 0; refr < 1 + isCompound; ++refr)
             {
-                int frame = mi.RefFrame[refr];
+                int frame = refFrameSpan[refr];
-                ref RefBuffer refBuf = ref cm.FrameRefs[frame - Constants.LastFrame];
+                ref RefBuffer refBuf = ref frameRefsSpan[frame - Constants.LastFrame];
                 ref ScaleFactors sf = ref refBuf.Sf;
                 ref Surface refFrameBuf = ref refBuf.Buf;
 
@@ -767,13 +804,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 isScaled = sf.IsScaled();
                 ReconInter.SetupPrePlanes(ref xd, refr, ref refFrameBuf, miRow, miCol,
                     isScaled ? new Ptr<ScaleFactors>(ref sf) : Ptr<ScaleFactors>.Null);
-                xd.BlockRefs[refr] = new Ptr<RefBuffer>(ref refBuf);
+                blockRefsSpan[refr] = new Ptr<RefBuffer>(ref refBuf);
 
                 if (sbType < BlockSize.Block8X8)
                 {
                     for (plane = 0; plane < Constants.MaxMbPlane; ++plane)
                     {
-                        ref MacroBlockDPlane pd = ref xd.Plane[plane];
+                        ref MacroBlockDPlane pd = ref planeSpan[plane];
                         ref Buf2D dstBuf = ref pd.Dst;
                         int num4X4W = pd.N4W;
                         int num4X4H = pd.N4H;
@@ -811,10 +848,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 }
                 else
                 {
-                    Mv mv = mi.Mv[refr];
+                    Mv mv = mvSpan[refr];
                     for (plane = 0; plane < Constants.MaxMbPlane; ++plane)
                     {
-                        ref MacroBlockDPlane pd = ref xd.Plane[plane];
+                        ref MacroBlockDPlane pd = ref planeSpan[plane];
                         ref Buf2D dstBuf = ref pd.Dst;
                         int num4X4W = pd.N4W;
                         int num4X4H = pd.N4H;
@@ -847,12 +884,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
         private static void SetPlaneN4(ref MacroBlockD xd, int bw, int bh, int bwl, int bhl)
         {
+            Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
+            
             for (int i = 0; i < Constants.MaxMbPlane; i++)
             {
-                xd.Plane[i].N4W = (ushort)((bw << 1) >> xd.Plane[i].SubsamplingX);
+                planeSpan[i].N4W = (ushort)((bw << 1) >> planeSpan[i].SubsamplingX);
-                xd.Plane[i].N4H = (ushort)((bh << 1) >> xd.Plane[i].SubsamplingY);
+                planeSpan[i].N4H = (ushort)((bh << 1) >> planeSpan[i].SubsamplingY);
-                xd.Plane[i].N4Wl = (byte)(bwl - xd.Plane[i].SubsamplingX);
+                planeSpan[i].N4Wl = (byte)(bwl - planeSpan[i].SubsamplingX);
-                xd.Plane[i].N4Hl = (byte)(bhl - xd.Plane[i].SubsamplingY);
+                planeSpan[i].N4Hl = (byte)(bhl - planeSpan[i].SubsamplingY);
             }
         }
 
@@ -892,7 +931,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // as they are always compared to values that are in 1/8th pel units
             xd.SetMiRowCol(ref tile, miRow, bh, miCol, bw, cm.MiRows, cm.MiCols);
 
-            ReconInter.SetupDstPlanes(ref xd.Plane, ref xd.CurBuf, miRow, miCol);
+            ReconInter.SetupDstPlanes(xd.Plane.AsSpan(), ref xd.CurBuf, miRow, miCol);
             return ref xd.Mi[0].Value;
         }
 
@@ -933,10 +972,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             if (!mi.IsInterBlock())
             {
-                int plane;
+                Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
-                for (plane = 0; plane < Constants.MaxMbPlane; ++plane)
+                
+                for (int plane = 0; plane < Constants.MaxMbPlane; ++plane)
                 {
-                    ref MacroBlockDPlane pd = ref xd.Plane[plane];
+                    ref MacroBlockDPlane pd = ref planeSpan[plane];
                     TxSize txSize = plane != 0 ? mi.GetUvTxSize(ref pd) : mi.TxSize;
                     int num4X4W = pd.N4W;
                     int num4X4H = pd.N4H;
@@ -967,12 +1007,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // Reconstruction
                 if (mi.Skip == 0)
                 {
-                    int eobtotal = 0;
+                    Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
-                    int plane;
                     
-                    for (plane = 0; plane < Constants.MaxMbPlane; ++plane)
+                    int eobtotal = 0;
+
+                    for (int plane = 0; plane < Constants.MaxMbPlane; ++plane)
                     {
-                        ref MacroBlockDPlane pd = ref xd.Plane[plane];
+                        ref MacroBlockDPlane pd = ref planeSpan[plane];
                         TxSize txSize = plane != 0 ? mi.GetUvTxSize(ref pd) : mi.TxSize;
                         int num4X4W = pd.N4W;
                         int num4X4H = pd.N4H;
@@ -1159,22 +1200,30 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             }
         }
 
-        private static void ReadCoefProbsCommon(ref Array2<Array2<Array6<Array6<Array3<byte>>>>> coefProbs,
+        private static void ReadCoefProbsCommon(ReadOnlySpan<Array2<Array6<Array6<Array3<byte>>>>> coefProbs1,
             ref Reader r, int txSize)
         {
             if (r.ReadBit() != 0)
             {
                 for (int i = 0; i < Constants.PlaneTypes; ++i)
                 {
+                    Span<Array6<Array6<Array3<byte>>>> coefProbs2 = coefProbs1[i].AsSpan(); 
+                    
                     for (int j = 0; j < Entropy.RefTypes; ++j)
                     {
+                        Span<Array6<Array3<byte>>> coefProbs3 = coefProbs2[j].AsSpan(); 
+                        
                         for (int k = 0; k < Entropy.CoefBands; ++k)
                         {
+                            Span<Array3<byte>> coefProbs4 = coefProbs3[k].AsSpan();
+                            
                             for (int l = 0; l < Entropy.BAND_COEFF_CONTEXTS(k); ++l)
                             {
+                                Span<byte> coefProbs5 = coefProbs4[l].AsSpan();
+                                
                                 for (int m = 0; m < Entropy.UnconstrainedNodes; ++m)
                                 {
-                                    r.DiffUpdateProb(ref coefProbs[i][j][k][l][m]);
+                                    r.DiffUpdateProb(ref coefProbs5[m]);
                                 }
                             }
                         }
@@ -1185,10 +1234,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
         private static void ReadCoefProbs(ref Vp9EntropyProbs fc, TxMode txMode, ref Reader r)
         {
+            Span<Array2<Array2<Array6<Array6<Array3<byte>>>>>> coefProbsSpan = fc.CoefProbs.AsSpan();
+            
             int maxTxSize = (int)Luts.TxModeToBiggestTxSize[(int)txMode];
+            
             for (int txSize = (int)TxSize.Tx4X4; txSize <= maxTxSize; ++txSize)
             {
-                ReadCoefProbsCommon(ref fc.CoefProbs[txSize], ref r, txSize);
+                ReadCoefProbsCommon(coefProbsSpan[txSize].AsSpan(), ref r, txSize);
             }
         }
 
@@ -1207,11 +1259,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 lf.ModeRefDeltaUpdate = rb.ReadBit() != 0;
                 if (lf.ModeRefDeltaUpdate)
                 {
+                    Span<sbyte> refDeltasSpan = lf.RefDeltas.AsSpan();
+                    Span<sbyte> modeDeltasSpan = lf.ModeDeltas.AsSpan();
+                    
                     for (int i = 0; i < LoopFilter.MaxRefLfDeltas; i++)
                     {
                         if (rb.ReadBit() != 0)
                         {
-                            lf.RefDeltas[i] = (sbyte)rb.ReadSignedLiteral(6);
+                            refDeltasSpan[i] = (sbyte)rb.ReadSignedLiteral(6);
                         }
                     }
 
@@ -1219,7 +1274,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     {
                         if (rb.ReadBit() != 0)
                         {
-                            lf.ModeDeltas[i] = (sbyte)rb.ReadSignedLiteral(6);
+                            modeDeltasSpan[i] = (sbyte)rb.ReadSignedLiteral(6);
                         }
                     }
                 }
@@ -1267,6 +1322,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             cm.ResizeContextBuffers(allocator, width, height);
             SetupRenderSize(ref cm, ref rb);
 
+            Span<RefCntBuffer> frameBuffsSpan = pool.FrameBufs.AsSpan();
+
             if (cm.GetFrameNewBuffer().ReallocFrameBuffer(
                     allocator,
                     cm.Width,
@@ -1276,21 +1333,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     cm.UseHighBitDepth,
                     Surface.DecBorderInPixels,
                     cm.ByteAlignment,
-                    new Ptr<VpxCodecFrameBuffer>(ref pool.FrameBufs[cm.NewFbIdx].RawFrameBuffer),
+                    new Ptr<VpxCodecFrameBuffer>(ref frameBuffsSpan[cm.NewFbIdx].RawFrameBuffer),
                     FrameBuffers.GetFrameBuffer,
                     pool.CbPriv) != 0)
             {
                 cm.Error.InternalError(CodecErr.MemError, "Failed to allocate frame buffer");
             }
 
-            pool.FrameBufs[cm.NewFbIdx].Released = 0;
+            frameBuffsSpan[cm.NewFbIdx].Released = 0;
-            pool.FrameBufs[cm.NewFbIdx].Buf.SubsamplingX = cm.SubsamplingX;
+            frameBuffsSpan[cm.NewFbIdx].Buf.SubsamplingX = cm.SubsamplingX;
-            pool.FrameBufs[cm.NewFbIdx].Buf.SubsamplingY = cm.SubsamplingY;
+            frameBuffsSpan[cm.NewFbIdx].Buf.SubsamplingY = cm.SubsamplingY;
-            pool.FrameBufs[cm.NewFbIdx].Buf.BitDepth = (uint)cm.BitDepth;
+            frameBuffsSpan[cm.NewFbIdx].Buf.BitDepth = (uint)cm.BitDepth;
-            pool.FrameBufs[cm.NewFbIdx].Buf.ColorSpace = cm.ColorSpace;
+            frameBuffsSpan[cm.NewFbIdx].Buf.ColorSpace = cm.ColorSpace;
-            pool.FrameBufs[cm.NewFbIdx].Buf.ColorRange = cm.ColorRange;
+            frameBuffsSpan[cm.NewFbIdx].Buf.ColorRange = cm.ColorRange;
-            pool.FrameBufs[cm.NewFbIdx].Buf.RenderWidth = cm.RenderWidth;
+            frameBuffsSpan[cm.NewFbIdx].Buf.RenderWidth = cm.RenderWidth;
-            pool.FrameBufs[cm.NewFbIdx].Buf.RenderHeight = cm.RenderHeight;
+            frameBuffsSpan[cm.NewFbIdx].Buf.RenderHeight = cm.RenderHeight;
         }
 
         private static bool ValidRefFrameImgFmt(
@@ -1311,13 +1368,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             bool hasValidRefFrame = false;
             ref BufferPool pool = ref cm.BufferPool.Value;
+            Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
+            
             for (int i = 0; i < Constants.RefsPerFrame; ++i)
             {
                 if (rb.ReadBit() != 0)
                 {
-                    if (cm.FrameRefs[i].Idx != RefBuffer.InvalidIdx)
+                    if (frameRefsSpan[i].Idx != RefBuffer.InvalidIdx)
                     {
-                        ref Surface buf = ref cm.FrameRefs[i].Buf;
+                        ref Surface buf = ref frameRefsSpan[i].Buf;
                         width = buf.YCropWidth;
                         height = buf.YCropHeight;
                         found = true;
@@ -1342,7 +1401,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // has valid dimensions.
             for (int i = 0; i < Constants.RefsPerFrame; ++i)
             {
-                ref RefBuffer refFrame = ref cm.FrameRefs[i];
+                ref RefBuffer refFrame = ref frameRefsSpan[i];
                 hasValidRefFrame |=
                     refFrame.Idx != RefBuffer.InvalidIdx &&
                     ScaleFactors.ValidRefFrameSize(refFrame.Buf.YCropWidth, refFrame.Buf.YCropHeight, width,
@@ -1356,7 +1415,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             for (int i = 0; i < Constants.RefsPerFrame; ++i)
             {
-                ref RefBuffer refFrame = ref cm.FrameRefs[i];
+                ref RefBuffer refFrame = ref frameRefsSpan[i];
                 if (refFrame.Idx == RefBuffer.InvalidIdx ||
                     !ValidRefFrameImgFmt(
                         (BitDepth)refFrame.Buf.BitDepth,
@@ -1374,6 +1433,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             cm.ResizeContextBuffers(allocator, width, height);
             SetupRenderSize(ref cm, ref rb);
             
+            Span<RefCntBuffer> frameBuffsSpan = pool.FrameBufs.AsSpan();
+
             if (cm.GetFrameNewBuffer().ReallocFrameBuffer(
                     allocator,
                     cm.Width,
@@ -1383,21 +1444,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     cm.UseHighBitDepth,
                     Surface.DecBorderInPixels,
                     cm.ByteAlignment,
-                    new Ptr<VpxCodecFrameBuffer>(ref pool.FrameBufs[cm.NewFbIdx].RawFrameBuffer),
+                    new Ptr<VpxCodecFrameBuffer>(ref frameBuffsSpan[cm.NewFbIdx].RawFrameBuffer),
                     FrameBuffers.GetFrameBuffer,
                     pool.CbPriv) != 0)
             {
                 cm.Error.InternalError(CodecErr.MemError, "Failed to allocate frame buffer");
             }
 
-            pool.FrameBufs[cm.NewFbIdx].Released = 0;
+            frameBuffsSpan[cm.NewFbIdx].Released = 0;
-            pool.FrameBufs[cm.NewFbIdx].Buf.SubsamplingX = cm.SubsamplingX;
+            frameBuffsSpan[cm.NewFbIdx].Buf.SubsamplingX = cm.SubsamplingX;
-            pool.FrameBufs[cm.NewFbIdx].Buf.SubsamplingY = cm.SubsamplingY;
+            frameBuffsSpan[cm.NewFbIdx].Buf.SubsamplingY = cm.SubsamplingY;
-            pool.FrameBufs[cm.NewFbIdx].Buf.BitDepth = (uint)cm.BitDepth;
+            frameBuffsSpan[cm.NewFbIdx].Buf.BitDepth = (uint)cm.BitDepth;
-            pool.FrameBufs[cm.NewFbIdx].Buf.ColorSpace = cm.ColorSpace;
+            frameBuffsSpan[cm.NewFbIdx].Buf.ColorSpace = cm.ColorSpace;
-            pool.FrameBufs[cm.NewFbIdx].Buf.ColorRange = cm.ColorRange;
+            frameBuffsSpan[cm.NewFbIdx].Buf.ColorRange = cm.ColorRange;
-            pool.FrameBufs[cm.NewFbIdx].Buf.RenderWidth = cm.RenderWidth;
+            frameBuffsSpan[cm.NewFbIdx].Buf.RenderWidth = cm.RenderWidth;
-            pool.FrameBufs[cm.NewFbIdx].Buf.RenderHeight = cm.RenderHeight;
+            frameBuffsSpan[cm.NewFbIdx].Buf.RenderHeight = cm.RenderHeight;
         }
 
         // Reads the next tile returning its size and adjusting '*data' accordingly
@@ -1437,7 +1498,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         }
 
         private static void GetTileBuffers(ref Vp9Common cm, ArrayPtr<byte> data, int tileCols,
-            ref Array64<TileBuffer> tileBuffers)
+            Span<TileBuffer> tileBuffers)
         {
             for (int c = 0; c < tileCols; ++c)
             {
@@ -1453,14 +1514,16 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             ArrayPtr<byte> data,
             int tileCols,
             int tileRows,
-            ref Array4<Array64<TileBuffer>> tileBuffers)
+            Span<Array64<TileBuffer>> tileBuffers1)
         {
             for (int r = 0; r < tileRows; ++r)
             {
+                Span<TileBuffer> tileBuffers2 = tileBuffers1[r].AsSpan();
+                
                 for (int c = 0; c < tileCols; ++c)
                 {
                     bool isLast = r == tileRows - 1 && c == tileCols - 1;
-                    ref TileBuffer buf = ref tileBuffers[r][c];
+                    ref TileBuffer buf = ref tileBuffers2[c];
                     GetTileBuffer(isLast, ref cm.Error, ref data, ref buf);
                 }
             }
@@ -1485,14 +1548,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             LoopFilter.ResetLfm(ref cm);
             
-            GetTileBuffers(ref cm, data, tileCols, tileRows, ref tileBuffers);
+            Span<Array64<TileBuffer>> tileBuffers1 = tileBuffers.AsSpan();
+            Span<TileWorkerData> tileWorkerDataSpan = cm.TileWorkerData.AsSpan();
+
+            GetTileBuffers(ref cm, data, tileCols, tileRows, tileBuffers1);
             // Load all tile information into tile_data.
             for (tileRow = 0; tileRow < tileRows; ++tileRow)
             {
+                Span<TileBuffer> tileBuffers2 = tileBuffers1[tileRow].AsSpan();
+                
                 for (tileCol = 0; tileCol < tileCols; ++tileCol)
                 {
-                    ref TileBuffer buf = ref tileBuffers[tileRow][tileCol];
+                    ref TileBuffer buf = ref tileBuffers2[tileCol];
-                    ref TileWorkerData tileData = ref cm.TileWorkerData[(tileCols * tileRow) + tileCol];
+                    ref TileWorkerData tileData = ref tileWorkerDataSpan[(tileCols * tileRow) + tileCol];
                     tileData.Xd = cm.Mb;
                     tileData.Xd.Corrupted = false;
                     tileData.Xd.Counts = cm.Counts;
@@ -1512,7 +1580,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     for (tileCol = 0; tileCol < tileCols; ++tileCol)
                     {
                         int col = tileCol;
-                        ref TileWorkerData tileData = ref cm.TileWorkerData[(tileCols * tileRow) + col];
+                        ref TileWorkerData tileData = ref tileWorkerDataSpan[(tileCols * tileRow) + col];
                         tile.SetCol(ref cm, col);
                         tileData.Xd.LeftContext = new Array3<Array16<sbyte>>();
                         tileData.Xd.LeftSegContext = new Array8<sbyte>();
@@ -1531,11 +1599,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             }
 
             // Get last tile data.
-            return cm.TileWorkerData[(tileCols * tileRows) - 1].BitReader.FindEnd();
+            return tileWorkerDataSpan[(tileCols * tileRows) - 1].BitReader.FindEnd();
         }
 
         private static bool DecodeTileCol(ref TileWorkerData tileData, ref Vp9Common cm,
-            ref Array64<TileBuffer> tileBuffers)
+            Span<TileBuffer> tileBuffers)
         {
             ref TileInfo tile = ref tileData.Xd.Tile;
             int finalCol = (1 << cm.Log2TileCols) - 1;
@@ -1594,9 +1662,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             cm.AboveContext.AsSpan().Clear();
             cm.AboveSegContext.AsSpan().Clear();
             
+            Span<TileWorkerData> tileWorkerDataSpan = cm.TileWorkerData.AsSpan();
+
             for (n = 0; n < numWorkers; ++n)
             {
-                ref TileWorkerData tileData = ref cm.TileWorkerData[n + totalTiles];
+                ref TileWorkerData tileData = ref tileWorkerDataSpan[n + totalTiles];
 
                 tileData.Xd = cm.Mb;
                 tileData.Xd.Counts = new Ptr<Vp9BackwardUpdates>(ref tileData.Counts);
@@ -1604,17 +1674,17 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             }
 
             Array64<TileBuffer> tileBuffers = new();
+            Span<TileBuffer> tileBuffersSpan = tileBuffers.AsSpan();
 
-            GetTileBuffers(ref cm, data, tileCols, ref tileBuffers);
+            GetTileBuffers(ref cm, data, tileCols, tileBuffersSpan);
 
-            tileBuffers.AsSpan()[..tileCols].Sort(CompareTileBuffers);
+            tileBuffersSpan[..tileCols].Sort(CompareTileBuffers);
 
             if (numWorkers == tileCols)
             {
-                TileBuffer largest = tileBuffers[0];
+                TileBuffer largest = tileBuffersSpan[0];
-                Span<TileBuffer> buffers = tileBuffers.AsSpan();
+                tileBuffersSpan[1..].CopyTo(tileBuffersSpan[..^1]);
-                buffers[1..].CopyTo(buffers[..(tileBuffers.Length - 1)]);
+                tileBuffersSpan[tileCols - 1] = largest;
-                tileBuffers[tileCols - 1] = largest;
             }
             else
             {
@@ -1625,9 +1695,9 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // larger tile implies it is more difficult to decode.
                 while (start < end)
                 {
-                    tmp = tileBuffers[start];
+                    tmp = tileBuffersSpan[start];
-                    tileBuffers[start] = tileBuffers[end];
+                    tileBuffersSpan[start] = tileBuffersSpan[end];
-                    tileBuffers[end] = tmp;
+                    tileBuffersSpan[end] = tmp;
                     start += 2;
                     end -= 2;
                 }
@@ -1640,7 +1710,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             for (n = 0; n < numWorkers; ++n)
             {
                 int count = baseVal + ((remain + n) / numWorkers);
-                ref TileWorkerData tileData = ref cm.TileWorkerData[n + totalTiles];
+                ref TileWorkerData tileData = ref tileWorkerDataSpan[n + totalTiles];
 
                 tileData.BufStart = bufStart;
                 tileData.BufEnd = bufStart + count - 1;
@@ -1654,7 +1724,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 ref TileWorkerData tileData = ref cmPtr.Value.TileWorkerData[n + totalTiles];
 
-                if (!DecodeTileCol(ref tileData, ref cmPtr.Value, ref tileBuffers))
+                if (!DecodeTileCol(ref tileData, ref cmPtr.Value, tileBuffers.AsSpan()))
                 {
                     cmPtr.Value.Mb.Corrupted = true;
                 }
@@ -1664,14 +1734,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 if (bitReaderEnd.IsNull)
                 {
-                    ref TileWorkerData tileData = ref cm.TileWorkerData[n - 1 + totalTiles];
+                    ref TileWorkerData tileData = ref tileWorkerDataSpan[n - 1 + totalTiles];
                     bitReaderEnd = tileData.DataEnd;
                 }
             }
 
             for (n = 0; n < numWorkers; ++n)
             {
-                ref TileWorkerData tileData = ref cm.TileWorkerData[n + totalTiles];
+                ref TileWorkerData tileData = ref tileWorkerDataSpan[n + totalTiles];
                 AccumulateFrameCounts(ref cm.Counts.Value, ref tileData.Counts);
             }
 
@@ -1705,7 +1775,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             if (cm.FrameType == FrameType.KeyFrame && cm.CurrentVideoFrame > 0)
             {
-                ref Array12<RefCntBuffer> frameBufs = ref cm.BufferPool.Value.FrameBufs;
+                Span<RefCntBuffer> frameBuffs = cm.BufferPool.Value.FrameBufs.AsSpan();
                 ref BufferPool pool = ref cm.BufferPool.Value;
 
                 for (int i = 0; i < Constants.FrameBuffers; ++i)
@@ -1715,11 +1785,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         continue;
                     }
 
-                    frameBufs[i].RefCount = 0;
+                    frameBuffs[i].RefCount = 0;
-                    if (frameBufs[i].Released == 0)
+                    if (frameBuffs[i].Released == 0)
                     {
-                        FrameBuffers.ReleaseFrameBuffer(pool.CbPriv, ref frameBufs[i].RawFrameBuffer);
+                        FrameBuffers.ReleaseFrameBuffer(pool.CbPriv, ref frameBuffs[i].RawFrameBuffer);
-                        frameBufs[i].Released = 1;
+                        frameBuffs[i].Released = 1;
                     }
                 }
             }
@@ -1742,7 +1812,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                    readSyncCode2 == SyncCode2;
         }
 
-        private static void RefCntFb(ref Array12<RefCntBuffer> bufs, ref int idx, int newIdx)
+        private static void RefCntFb(Span<RefCntBuffer> bufs, ref int idx, int newIdx)
         {
             int refIndex = idx;
 
@@ -1761,13 +1831,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             ref Vp9Common cm = ref pbi.Common;
             ref BufferPool pool = ref cm.BufferPool.Value;
-            ref Array12<RefCntBuffer> frameBufs = ref pool.FrameBufs;
+            Span<RefCntBuffer> frameBuffs = pool.FrameBufs.AsSpan();
             int mask, refIndex = 0;
             ulong sz;
 
             cm.LastFrameType = cm.FrameType;
             cm.LastIntraOnly = cm.IntraOnly;
 
+            Span<int> refFrameSpan = cm.RefFrameMap.AsSpan();
+
             if (rb.ReadLiteral(2) != FrameMarker)
             {
                 cm.Error.InternalError(CodecErr.UnsupBitstream, "Invalid frame marker");
@@ -1783,14 +1855,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             if (cm.ShowExistingFrame != 0)
             {
                 // Show an existing frame directly.
-                int frameToShow = cm.RefFrameMap[rb.ReadLiteral(3)];
+                int frameToShow = refFrameSpan[rb.ReadLiteral(3)];
-                if (frameToShow < 0 || frameBufs[frameToShow].RefCount < 1)
+                if (frameToShow < 0 || frameBuffs[frameToShow].RefCount < 1)
                 {
                     cm.Error.InternalError(CodecErr.UnsupBitstream,
                         $"Buffer {frameToShow} does not contain a decoded frame");
                 }
 
-                RefCntFb(ref frameBufs, ref cm.NewFbIdx, frameToShow);
+                RefCntFb(frameBuffs, ref cm.NewFbIdx, frameToShow);
                 pbi.RefreshFrameFlags = 0;
                 cm.Lf.FilterLevel = 0;
                 cm.ShowFrame = 1;
@@ -1812,16 +1884,18 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 cm.ReadBitdepthColorspaceSampling(ref rb);
                 pbi.RefreshFrameFlags = (1 << Constants.RefFrames) - 1;
 
+                Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
+
                 for (int i = 0; i < Constants.RefsPerFrame; ++i)
                 {
-                    cm.FrameRefs[i].Idx = RefBuffer.InvalidIdx;
+                    frameRefsSpan[i].Idx = RefBuffer.InvalidIdx;
-                    cm.FrameRefs[i].Buf = default;
+                    frameRefsSpan[i].Buf = default;
                 }
 
                 SetupFrameSize(allocator, ref cm, ref rb);
                 if (pbi.NeedResync != 0)
                 {
-                    cm.RefFrameMap.AsSpan().Fill(-1);
+                    refFrameSpan.Fill(-1);
                     FlushAllFbOnKey(ref cm);
                     pbi.NeedResync = 0;
                 }
@@ -1860,22 +1934,25 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     SetupFrameSize(allocator, ref cm, ref rb);
                     if (pbi.NeedResync != 0)
                     {
-                        cm.RefFrameMap.AsSpan().Fill(-1);
+                        refFrameSpan.Fill(-1);
                         pbi.NeedResync = 0;
                     }
                 }
                 else if (pbi.NeedResync != 1)
                 {
+                    Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
+                    Span<sbyte> refFrameSignBiasSpan = cm.RefFrameSignBias.AsSpan();
+                    
                     /* Skip if need resync */
                     pbi.RefreshFrameFlags = rb.ReadLiteral(Constants.RefFrames);
                     for (int i = 0; i < Constants.RefsPerFrame; ++i)
                     {
                         int refr = rb.ReadLiteral(Constants.RefFramesLog2);
-                        int idx = cm.RefFrameMap[refr];
+                        int idx = refFrameSpan[refr];
-                        ref RefBuffer refFrame = ref cm.FrameRefs[i];
+                        ref RefBuffer refFrame = ref frameRefsSpan[i];
                         refFrame.Idx = idx;
-                        refFrame.Buf = frameBufs[idx].Buf;
+                        refFrame.Buf = frameBuffs[idx].Buf;
-                        cm.RefFrameSignBias[Constants.LastFrame + i] = (sbyte)rb.ReadBit();
+                        refFrameSignBiasSpan[Constants.LastFrame + i] = (sbyte)rb.ReadBit();
                     }
 
                     SetupFrameSizeWithRefs(allocator, ref cm, ref rb);
@@ -1885,7 +1962,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
                     for (int i = 0; i < Constants.RefsPerFrame; ++i)
                     {
-                        ref RefBuffer refBuf = ref cm.FrameRefs[i];
+                        ref RefBuffer refBuf = ref frameRefsSpan[i];
                         refBuf.Sf.SetupScaleFactorsForFrame(
                             refBuf.Buf.YCropWidth,
                             refBuf.Buf.YCropHeight,
@@ -1926,23 +2003,25 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // below, forcing the use of context 0 for those frame types.
             cm.FrameContextIdx = (uint)rb.ReadLiteral(Constants.FrameContextsLog2);
 
+            Span<int> nextRefFrameMapSpan = cm.NextRefFrameMap.AsSpan();
+
             // Generate next_ref_frame_map.
             for (mask = pbi.RefreshFrameFlags; mask != 0; mask >>= 1)
             {
                 if ((mask & 1) != 0)
                 {
-                    cm.NextRefFrameMap[refIndex] = cm.NewFbIdx;
+                    nextRefFrameMapSpan[refIndex] = cm.NewFbIdx;
-                    ++frameBufs[cm.NewFbIdx].RefCount;
+                    ++frameBuffs[cm.NewFbIdx].RefCount;
                 }
                 else
                 {
-                    cm.NextRefFrameMap[refIndex] = cm.RefFrameMap[refIndex];
+                    nextRefFrameMapSpan[refIndex] = cm.RefFrameMap[refIndex];
                 }
 
                 // Current thread holds the reference frame.
                 if (cm.RefFrameMap[refIndex] >= 0)
                 {
-                    ++frameBufs[cm.RefFrameMap[refIndex]].RefCount;
+                    ++frameBuffs[cm.RefFrameMap[refIndex]].RefCount;
                 }
 
                 ++refIndex;
@@ -1950,11 +2029,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             for (; refIndex < Constants.RefFrames; ++refIndex)
             {
-                cm.NextRefFrameMap[refIndex] = cm.RefFrameMap[refIndex];
+                nextRefFrameMapSpan[refIndex] = refFrameSpan[refIndex];
                 // Current thread holds the reference frame.
-                if (cm.RefFrameMap[refIndex] >= 0)
+                if (refFrameSpan[refIndex] >= 0)
                 {
-                    ++frameBufs[cm.RefFrameMap[refIndex]].RefCount;
+                    ++frameBuffs[refFrameSpan[refIndex]].RefCount;
                 }
             }
 
@@ -2001,9 +2080,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             ReadCoefProbs(ref fc, cm.TxMode, ref r);
 
+            Span<byte> skipProbSpan = fc.SkipProb.AsSpan();
+
             for (int k = 0; k < Constants.SkipContexts; ++k)
             {
-                r.DiffUpdateProb(ref fc.SkipProb[k]);
+                r.DiffUpdateProb(ref skipProbSpan[k]);
             }
 
             if (!cm.FrameIsIntraOnly())
@@ -2015,9 +2096,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     ReadSwitchableInterpProbs(ref fc, ref r);
                 }
                 
+                Span<byte> intraInterProbSpan = fc.IntraInterProb.AsSpan();
+
                 for (int i = 0; i < Constants.IntraInterContexts; i++)
                 {
-                    r.DiffUpdateProb(ref fc.IntraInterProb[i]);
+                    r.DiffUpdateProb(ref intraInterProbSpan[i]);
                 }
 
                 cm.ReferenceMode = cm.ReadFrameReferenceMode(ref r);
@@ -2028,19 +2111,27 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
                 cm.ReadFrameReferenceModeProbs(ref r);
                 
+                Span<Array9<byte>> yModeProbSpan1 = fc.YModeProb.AsSpan();
+
                 for (int j = 0; j < EntropyMode.BlockSizeGroups; j++)
                 {
+                    Span<byte> yModeProbSpan2 = yModeProbSpan1[j].AsSpan();
+                    
                     for (int i = 0; i < Constants.IntraModes - 1; ++i)
                     {
-                        r.DiffUpdateProb(ref fc.YModeProb[j][i]);
+                        r.DiffUpdateProb(ref yModeProbSpan2[i]);
                     }
                 }
                 
+                Span<Array3<byte>> partitionProbSpan1 = fc.PartitionProb.AsSpan();
+
                 for (int j = 0; j < Constants.PartitionContexts; ++j)
                 {
+                    Span<byte> partitionProbSpan2 = partitionProbSpan1[j].AsSpan();
+                    
                     for (int i = 0; i < Constants.PartitionTypes - 1; ++i)
                     {
-                        r.DiffUpdateProb(ref fc.PartitionProb[j][i]);
+                        r.DiffUpdateProb(ref partitionProbSpan2[i]);
                     }
                 }
 
@@ -2098,7 +2189,9 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             xd.SetupBlockPlanes(cm.SubsamplingX, cm.SubsamplingY);
 
-            cm.Fc = new Ptr<Vp9EntropyProbs>(ref cm.FrameContexts[(int)cm.FrameContextIdx]);
+            Span<Vp9EntropyProbs> frameContextsSpan = cm.FrameContexts.AsSpan();
+
+            cm.Fc = new Ptr<Vp9EntropyProbs>(ref frameContextsSpan[(int)cm.FrameContextIdx]);
 
             xd.Corrupted = false;
             newFb.Corrupted = ReadCompressedHeader(ref pbi, data, firstPartitionSize) ? 1 : 0;
@@ -2167,7 +2260,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // Non frame parallel update frame context here.
             if (cm.RefreshFrameContext != 0 && contextUpdated == 0)
             {
-                cm.FrameContexts[(int)cm.FrameContextIdx] = cm.Fc.Value;
+                frameContextsSpan[(int)cm.FrameContextIdx] = cm.Fc.Value;
             }
         }
     }

src/Ryujinx.Graphics.Nvdec.Vp9/DecodeMv.cs

@@ -50,9 +50,9 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             return PredictionMode.NearestMv + mode;
         }
 
-        private static int ReadSegmentId(ref Reader r, ref Array7<byte> segTreeProbs)
+        private static int ReadSegmentId(ref Reader r, ReadOnlySpan<byte> segTreeProbs)
         {
-            return r.ReadTree(Luts.SegmentTree, segTreeProbs.AsSpan());
+            return r.ReadTree(Luts.SegmentTree, segTreeProbs);
         }
 
         private static ReadOnlySpan<byte> GetTxProbs(ref Vp9EntropyProbs fc, TxSize maxTxSize, int ctx)
@@ -187,7 +187,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 return 0;
             }
 
-            segmentId = ReadSegmentId(ref r, ref cm.Fc.Value.SegTreeProb);
+            segmentId = ReadSegmentId(ref r, cm.Fc.Value.SegTreeProb.AsSpan());
             SetSegmentId(ref cm, miOffset, xMis, yMis, segmentId);
             return segmentId;
         }
@@ -223,15 +223,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             if (seg.TemporalUpdate)
             {
-                byte predProb = Segmentation.GetPredProbSegId(ref cm.Fc.Value.SegPredProb, ref xd);
+                byte predProb = Segmentation.GetPredProbSegId(cm.Fc.Value.SegPredProb.AsSpan(), ref xd);
                 mi.SegIdPredicted = (sbyte)r.Read(predProb);
                 segmentId = mi.SegIdPredicted != 0
                     ? predictedSegmentId
-                    : ReadSegmentId(ref r, ref cm.Fc.Value.SegTreeProb);
+                    : ReadSegmentId(ref r, cm.Fc.Value.SegTreeProb.AsSpan());
             }
             else
             {
-                segmentId = ReadSegmentId(ref r, ref cm.Fc.Value.SegTreeProb);
+                segmentId = ReadSegmentId(ref r, cm.Fc.Value.SegTreeProb.AsSpan());
             }
 
             SetSegmentId(ref cm, miOffset, xMis, yMis, segmentId);
@@ -272,10 +272,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 int n = (int)mvClass + Constants.Class0Bits - 1; // Number of bits
 
+                Span<byte> bitsSpan = fc.Bits[mvcomp].AsSpan();
+                
                 d = 0;
                 for (int i = 0; i < n; ++i)
                 {
-                    d |= r.Read(fc.Bits[mvcomp][i]) << i;
+                    d |= r.Read(bitsSpan[i]) << i;
                 }
 
                 mag = Constants.Class0Size << ((int)mvClass + 2);
@@ -343,7 +345,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             ref MacroBlockD xd,
             ref Reader r,
             int segmentId,
-            ref Array2<sbyte> refFrame)
+            Span<sbyte> refFrame)
         {
             ref Vp9EntropyProbs fc = ref cm.Fc.Value;
 
@@ -418,23 +420,25 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             BlockSize bsize = mi.SbType;
 
+            Span<BModeInfo> bmiSpan = mi.Bmi.AsSpan();
+
             switch (bsize)
             {
                 case BlockSize.Block4X4:
                     for (int i = 0; i < 4; ++i)
                     {
-                        mi.Bmi[i].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
+                        bmiSpan[i].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
                     }
 
-                    mi.Mode = mi.Bmi[3].Mode;
+                    mi.Mode = bmiSpan[3].Mode;
                     break;
                 case BlockSize.Block4X8:
-                    mi.Bmi[0].Mode = mi.Bmi[2].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
+                    bmiSpan[0].Mode = bmiSpan[2].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
-                    mi.Bmi[1].Mode = mi.Bmi[3].Mode = mi.Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
+                    bmiSpan[1].Mode = bmiSpan[3].Mode = mi.Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
                     break;
                 case BlockSize.Block8X4:
-                    mi.Bmi[0].Mode = mi.Bmi[1].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
+                    bmiSpan[0].Mode = bmiSpan[1].Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
-                    mi.Bmi[2].Mode = mi.Bmi[3].Mode = mi.Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
+                    bmiSpan[2].Mode = bmiSpan[3].Mode = mi.Mode = ReadIntraModeY(ref cm, ref xd, ref r, 0);
                     break;
                 default:
                     mi.Mode = ReadIntraModeY(ref cm, ref xd, ref r, Luts.SizeGroupLookup[(int)bsize]);
@@ -447,29 +451,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // modes in GetPredContextSwitchableInterp()
             mi.InterpFilter = Constants.SwitchableFilters;
 
-            mi.RefFrame[0] = Constants.IntraFrame;
+            Span<sbyte> refFrameSpan = mi.RefFrame.AsSpan();
-            mi.RefFrame[1] = Constants.None;
-        }
             
-        private static void CopyPair(ref Array2<Mv> dst, ref Array2<Mv> src)
+            refFrameSpan[0] = Constants.IntraFrame;
-        {
+            refFrameSpan[1] = Constants.None;
-            dst[0] = src[0];
-            dst[1] = src[1];
-        }
-
-        private static void ZeroPair(ref Array2<Mv> dst)
-        {
-            dst[0] = new Mv();
-            dst[1] = new Mv();
         }
 
         private static bool Assign(
             ref Vp9Common cm,
             ref MacroBlockD xd,
             PredictionMode mode,
-            ref Array2<Mv> mv,
+            Span<Mv> mv,
-            ref Array2<Mv> refMv,
+            Span<Mv> refMv,
-            ref Array2<Mv> nearNearestMv,
+            Span<Mv> nearNearestMv,
             int isCompound,
             bool allowHp,
             ref Reader r)
@@ -491,12 +485,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 case PredictionMode.NearMv:
                 case PredictionMode.NearestMv:
                     {
-                        CopyPair(ref mv, ref nearNearestMv);
+                        nearNearestMv.CopyTo(mv);
                         break;
                     }
                 case PredictionMode.ZeroMv:
                     {
-                        ZeroPair(ref mv);
+                        mv.Clear();
                         break;
                     }
                 default:
@@ -559,26 +553,29 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         private static bool IsDiffRefFrameAddEb(
             ref ModeInfo mbmi,
             sbyte refFrame,
-            ref Array4<sbyte> refSignBias,
+            Span<sbyte> refSignBias,
             ref int refmvCount,
             Span<Mv> mvRefList,
             bool earlyBreak)
         {
             if (mbmi.IsInterBlock())
             {
-                if (mbmi.RefFrame[0] != refFrame)
+                Span<sbyte> refFrameSpan = mbmi.RefFrame.AsSpan();
+                Span<Mv> mvSpan = mbmi.Mv.AsSpan();
+                
+                if (refFrameSpan[0] != refFrame)
                 {
-                    if (AddRefListEb(mbmi.ScaleMv(0, refFrame, ref refSignBias), ref refmvCount, mvRefList,
+                    if (AddRefListEb(mbmi.ScaleMv(0, refFrame, refSignBias), ref refmvCount, mvRefList,
                             earlyBreak))
                     {
                         return true;
                     }
                 }
 
-                if (mbmi.HasSecondRef() && mbmi.RefFrame[1] != refFrame &&
+                if (mbmi.HasSecondRef() && refFrameSpan[1] != refFrame &&
-                    Unsafe.As<Mv, int>(ref mbmi.Mv[1]) != Unsafe.As<Mv, int>(ref mbmi.Mv[0]))
+                    Unsafe.As<Mv, int>(ref mvSpan[1]) != Unsafe.As<Mv, int>(ref mvSpan[0]))
                 {
-                    if (AddRefListEb(mbmi.ScaleMv(1, refFrame, ref refSignBias), ref refmvCount, mvRefList,
+                    if (AddRefListEb(mbmi.ScaleMv(1, refFrame, refSignBias), ref refmvCount, mvRefList,
                             earlyBreak))
                     {
                         return true;
@@ -603,7 +600,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             int block,
             int isSub8X8)
         {
-            ref Array4<sbyte> refSignBias = ref cm.RefFrameSignBias;
+            Span<sbyte> refSignBias = cm.RefFrameSignBias.AsSpan();
             int i, refmvCount = 0;
             bool differentRefFound = false;
             Ptr<MvRef> prevFrameMvs = cm.UsePrevFrameMvs
@@ -630,7 +627,9 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         ref ModeInfo candidateMi = ref xd.Mi[mvRef.Col + (mvRef.Row * xd.MiStride)].Value;
                         differentRefFound = true;
 
-                        if (candidateMi.RefFrame[0] == refFrame)
+                        Span<sbyte> refFrameSpan = candidateMi.RefFrame.AsSpan();
+                        
+                        if (refFrameSpan[0] == refFrame)
                         {
                             if (AddRefListEb(candidateMi.GetSubBlockMv(0, mvRef.Col, block), ref refmvCount,
                                     mvRefList, earlyBreak))
@@ -638,7 +637,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                                 goto Done;
                             }
                         }
-                        else if (candidateMi.RefFrame[1] == refFrame)
+                        else if (refFrameSpan[1] == refFrame)
                         {
                             if (AddRefListEb(candidateMi.GetSubBlockMv(1, mvRef.Col, block), ref refmvCount,
                                     mvRefList, earlyBreak))
@@ -661,16 +660,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     ref ModeInfo candidate = ref xd.Mi[mvRef.Col + (mvRef.Row * xd.MiStride)].Value;
                     differentRefFound = true;
                     
-                    if (candidate.RefFrame[0] == refFrame)
+                    Span<sbyte> refFrameSpan = candidate.RefFrame.AsSpan();
+                    Span<Mv> mvSpan = candidate.Mv.AsSpan();
+
+                    if (refFrameSpan[0] == refFrame)
                     {
-                        if (AddRefListEb(candidate.Mv[0], ref refmvCount, mvRefList, earlyBreak))
+                        if (AddRefListEb(mvSpan[0], ref refmvCount, mvRefList, earlyBreak))
                         {
                             goto Done;
                         }
                     }
-                    else if (candidate.RefFrame[1] == refFrame)
+                    else if (refFrameSpan[1] == refFrame)
                     {
-                        if (AddRefListEb(candidate.Mv[1], ref refmvCount, mvRefList, earlyBreak))
+                        if (AddRefListEb(mvSpan[1], ref refmvCount, mvRefList, earlyBreak))
                         {
                             goto Done;
                         }
@@ -681,16 +683,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // Check the last frame's mode and mv info.
             if (!prevFrameMvs.IsNull)
             {
-                if (prevFrameMvs.Value.RefFrame[0] == refFrame)
+                Span<sbyte> refFrameSpan = prevFrameMvs.Value.RefFrame.AsSpan();
+                Span<Mv> mvSpan = prevFrameMvs.Value.Mv.AsSpan();
+                
+                if (refFrameSpan[0] == refFrame)
                 {
-                    if (AddRefListEb(prevFrameMvs.Value.Mv[0], ref refmvCount, mvRefList, earlyBreak))
+                    if (AddRefListEb(mvSpan[0], ref refmvCount, mvRefList, earlyBreak))
                     {
                         goto Done;
                     }
                 }
-                else if (prevFrameMvs.Value.RefFrame[1] == refFrame)
+                else if (refFrameSpan[1] == refFrame)
                 {
-                    if (AddRefListEb(prevFrameMvs.Value.Mv[1], ref refmvCount, mvRefList, earlyBreak))
+                    if (AddRefListEb(mvSpan[1], ref refmvCount, mvRefList, earlyBreak))
                     {
                         goto Done;
                     }
@@ -710,7 +715,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         ref ModeInfo candidate = ref xd.Mi[mvRef.Col + (mvRef.Row * xd.MiStride)].Value;
 
                         // If the candidate is Intra we don't want to consider its mv.
-                        if (IsDiffRefFrameAddEb(ref candidate, refFrame, ref refSignBias, ref refmvCount, mvRefList,
+                        if (IsDiffRefFrameAddEb(ref candidate, refFrame, refSignBias, ref refmvCount, mvRefList,
                                 earlyBreak))
                         {
                             goto Done;
@@ -722,10 +727,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             // Since we still don't have a candidate we'll try the last frame.
             if (!prevFrameMvs.IsNull)
             {
-                if (prevFrameMvs.Value.RefFrame[0] != refFrame && prevFrameMvs.Value.RefFrame[0] > Constants.IntraFrame)
+                Span<sbyte> refFrameSpan = prevFrameMvs.Value.RefFrame.AsSpan();
+                Span<Mv> mvSpan = prevFrameMvs.Value.Mv.AsSpan();
+                
+                if (refFrameSpan[0] != refFrame && refFrameSpan[0] > Constants.IntraFrame)
                 {
-                    Mv mv = prevFrameMvs.Value.Mv[0];
+                    Mv mv = mvSpan[0];
-                    if (refSignBias[prevFrameMvs.Value.RefFrame[0]] != refSignBias[refFrame])
+                    if (refSignBias[refFrameSpan[0]] != refSignBias[refFrame])
                     {
                         mv.Row *= -1;
                         mv.Col *= -1;
@@ -737,13 +745,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     }
                 }
 
-                if (prevFrameMvs.Value.RefFrame[1] > Constants.IntraFrame &&
+                if (refFrameSpan[1] > Constants.IntraFrame &&
-                    prevFrameMvs.Value.RefFrame[1] != refFrame &&
+                    refFrameSpan[1] != refFrame &&
-                    Unsafe.As<Mv, int>(ref prevFrameMvs.Value.Mv[1]) !=
+                    Unsafe.As<Mv, int>(ref mvSpan[1]) !=
-                    Unsafe.As<Mv, int>(ref prevFrameMvs.Value.Mv[0]))
+                    Unsafe.As<Mv, int>(ref mvSpan[0]))
                 {
-                    Mv mv = prevFrameMvs.Value.Mv[1];
+                    Mv mv = mvSpan[1];
-                    if (refSignBias[prevFrameMvs.Value.RefFrame[1]] != refSignBias[refFrame])
+                    if (refSignBias[refFrameSpan[1]] != refSignBias[refFrame])
                     {
                         mv.Row *= -1;
                         mv.Col *= -1;
@@ -789,7 +797,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             Span<Mv> mvList = stackalloc Mv[Constants.MaxMvRefCandidates];
             ref ModeInfo mi = ref xd.Mi[0].Value;
-            ref Array4<BModeInfo> bmi = ref mi.Bmi;
+            Span<BModeInfo> bmi = mi.Bmi.AsSpan();
             int refmvCount;
 
             Debug.Assert(Constants.MaxMvRefCandidates == 2);
@@ -884,11 +892,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             BlockSize bsize = mi.SbType;
             bool allowHp = cm.AllowHighPrecisionMv;
             Array2<Mv> bestRefMvs = new();
+            Span<Mv> bestRefMvsSpan = bestRefMvs.AsSpan();
             int refr, isCompound;
             byte interModeCtx;
             Span<Position> mvRefSearch = Luts.MvRefBlocks[(int)bsize];
 
-            ReadRefFrames(ref cm, ref xd, ref r, mi.SegmentId, ref mi.RefFrame);
+            ReadRefFrames(ref cm, ref xd, ref r, mi.SegmentId, mi.RefFrame.AsSpan());
             isCompound = mi.HasSecondRef() ? 1 : 0;
             interModeCtx = GetModeContext(ref cm, ref xd, mvRefSearch, miRow, miCol);
 
@@ -920,16 +929,17 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 if (mi.Mode != PredictionMode.ZeroMv)
                 {
                     Span<Mv> tmpMvs = stackalloc Mv[Constants.MaxMvRefCandidates];
+                    Span<sbyte> refFrameSpan = mi.RefFrame.AsSpan();
 
                     for (refr = 0; refr < 1 + isCompound; ++refr)
                     {
-                        sbyte frame = mi.RefFrame[refr];
+                        sbyte frame = refFrameSpan[refr];
                         int refmvCount;
 
                         refmvCount = DecFindRefs(ref cm, ref xd, mi.Mode, frame, mvRefSearch, tmpMvs, miRow, miCol,
                             -1, 0);
 
-                        DecFindBestRefs(allowHp, tmpMvs, ref bestRefMvs[refr], refmvCount);
+                        DecFindBestRefs(allowHp, tmpMvs, ref bestRefMvsSpan[refr], refmvCount);
                     }
                 }
             }
@@ -945,10 +955,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 int idx, idy;
                 PredictionMode bMode = 0;
                 Array2<Mv> bestSub8X8 = new();
+                Span<Mv> bestSub8X8Span = bestSub8X8.AsSpan();
+                Span<BModeInfo> bmiSpan = mi.Bmi.AsSpan();
                 const uint InvalidMv = 0x80008000;
                 // Initialize the 2nd element as even though it won't be used meaningfully
                 // if isCompound is false.
-                Unsafe.As<Mv, uint>(ref bestSub8X8[1]) = InvalidMv;
+                Unsafe.As<Mv, uint>(ref bestSub8X8Span[1]) = InvalidMv;
                 for (idy = 0; idy < 2; idy += num4X4H)
                 {
                     for (idx = 0; idx < 2; idx += num4X4W)
@@ -961,11 +973,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             for (refr = 0; refr < 1 + isCompound; ++refr)
                             {
                                 AppendSub8X8ForIdx(ref cm, ref xd, mvRefSearch, bMode, j, refr, miRow, miCol,
-                                    ref bestSub8X8[refr]);
+                                    ref bestSub8X8Span[refr]);
                             }
                         }
 
-                        if (!Assign(ref cm, ref xd, bMode, ref mi.Bmi[j].Mv, ref bestRefMvs, ref bestSub8X8,
+                        if (!Assign(ref cm, ref xd, bMode, bmiSpan[j].Mv.AsSpan(), bestRefMvs.AsSpan(), bestSub8X8.AsSpan(),
                                 isCompound, allowHp, ref r))
                         {
                             xd.Corrupted |= true;
@@ -974,23 +986,22 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
                         if (num4X4H == 2)
                         {
-                            mi.Bmi[j + 2] = mi.Bmi[j];
+                            bmiSpan[j + 2] = bmiSpan[j];
                         }
 
                         if (num4X4W == 2)
                         {
-                            mi.Bmi[j + 1] = mi.Bmi[j];
+                            bmiSpan[j + 1] = bmiSpan[j];
                         }
                     }
                 }
 
                 mi.Mode = bMode;
-
+                bmiSpan[3].Mv.AsSpan().CopyTo(mi.Mv.AsSpan());
-                CopyPair(ref mi.Mv, ref mi.Bmi[3].Mv);
             }
             else
             {
-                xd.Corrupted |= !Assign(ref cm, ref xd, mi.Mode, ref mi.Mv, ref bestRefMvs, ref bestRefMvs,
+                xd.Corrupted |= !Assign(ref cm, ref xd, mi.Mode, mi.Mv.AsSpan(), bestRefMvs.AsSpan(), bestRefMvs.AsSpan(),
                     isCompound, allowHp, ref r);
             }
         }
@@ -1082,33 +1093,42 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             int miOffset = (miRow * cm.MiCols) + miCol;
 
+            Span<sbyte> refFrameSpan = mi.Value.RefFrame.AsSpan();
+
             mi.Value.SegmentId = (sbyte)ReadIntraSegmentId(ref cm, miOffset, xMis, yMis, ref r);
             mi.Value.Skip = (sbyte)ReadSkip(ref cm, ref xd, mi.Value.SegmentId, ref r);
             mi.Value.TxSize = ReadTxSize(ref cm, ref xd, true, ref r);
-            mi.Value.RefFrame[0] = Constants.IntraFrame;
+            refFrameSpan[0] = Constants.IntraFrame;
-            mi.Value.RefFrame[1] = Constants.None;
+            refFrameSpan[1] = Constants.None;
 
+            Span<BModeInfo> bmiSpan;
             switch (bsize)
             {
                 case BlockSize.Block4X4:
+                    bmiSpan = mi.Value.Bmi.AsSpan();
+                    
                     for (int i = 0; i < 4; ++i)
                     {
-                        mi.Value.Bmi[i].Mode =
+                        bmiSpan[i].Mode =
                             ReadIntraMode(ref r, GetYModeProbs(ref cm.Fc.Value, mi, aboveMi, leftMi, i));
                     }
 
-                    mi.Value.Mode = mi.Value.Bmi[3].Mode;
+                    mi.Value.Mode = bmiSpan[3].Mode;
                     break;
                 case BlockSize.Block4X8:
-                    mi.Value.Bmi[0].Mode = mi.Value.Bmi[2].Mode =
+                    bmiSpan = mi.Value.Bmi.AsSpan();
+                    
+                    bmiSpan[0].Mode = bmiSpan[2].Mode =
                         ReadIntraMode(ref r, GetYModeProbs(ref cm.Fc.Value, mi, aboveMi, leftMi, 0));
-                    mi.Value.Bmi[1].Mode = mi.Value.Bmi[3].Mode = mi.Value.Mode =
+                    bmiSpan[1].Mode = bmiSpan[3].Mode = mi.Value.Mode =
                         ReadIntraMode(ref r, GetYModeProbs(ref cm.Fc.Value, mi, aboveMi, leftMi, 1));
                     break;
                 case BlockSize.Block8X4:
-                    mi.Value.Bmi[0].Mode = mi.Value.Bmi[1].Mode =
+                    bmiSpan = mi.Value.Bmi.AsSpan();
+                    
+                    bmiSpan[0].Mode = bmiSpan[1].Mode =
                         ReadIntraMode(ref r, GetYModeProbs(ref cm.Fc.Value, mi, aboveMi, leftMi, 0));
-                    mi.Value.Bmi[2].Mode = mi.Value.Bmi[3].Mode = mi.Value.Mode =
+                    bmiSpan[2].Mode = bmiSpan[3].Mode = mi.Value.Mode =
                         ReadIntraMode(ref r, GetYModeProbs(ref cm.Fc.Value, mi, aboveMi, leftMi, 2));
                     break;
                 default:
@@ -1119,12 +1139,6 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             mi.Value.UvMode = ReadIntraMode(ref r, cm.Fc.Value.KfUvModeProb[(int)mi.Value.Mode].AsSpan());
         }
 
-        private static void CopyRefFramePair(ref Array2<sbyte> dst, ref Array2<sbyte> src)
-        {
-            dst[0] = src[0];
-            dst[1] = src[1];
-        }
-
         public static void ReadModeInfo(
             ref TileWorkerData twd,
             ref Vp9Common cm,
@@ -1151,8 +1165,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     for (int w = 0; w < xMis; ++w)
                     {
                         ref MvRef mv = ref frameMvs[w];
-                        CopyRefFramePair(ref mv.RefFrame, ref mi.RefFrame);
+                        mi.RefFrame.AsSpan().CopyTo(mv.RefFrame.AsSpan());
-                        CopyPair(ref mv.Mv, ref mi.Mv);
+                        mi.Mv.AsSpan().CopyTo(mv.Mv.AsSpan());
                     }
 
                     frameMvs = frameMvs.Slice(cm.MiCols);

src/Ryujinx.Graphics.Nvdec.Vp9/Decoder.cs

@@ -89,9 +89,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             cm.Lf.RefDeltas = pictureInfo.RefDeltas;
             cm.Lf.ModeDeltas = pictureInfo.ModeDeltas;
 
-            cm.FrameRefs[0].Buf = (Surface)pictureInfo.LastReference;
+            Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
-            cm.FrameRefs[1].Buf = (Surface)pictureInfo.GoldenReference;
+            frameRefsSpan[0].Buf = (Surface)pictureInfo.LastReference;
-            cm.FrameRefs[2].Buf = (Surface)pictureInfo.AltReference;
+            frameRefsSpan[1].Buf = (Surface)pictureInfo.GoldenReference;
+            frameRefsSpan[2].Buf = (Surface)pictureInfo.AltReference;
             cm.Mb.CurBuf = (Surface)output;
 
             cm.Mb.SetupBlockPlanes(1, 1);

src/Ryujinx.Graphics.Nvdec.Vp9/Detokenize.cs

@@ -28,7 +28,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             PlaneType type,
             Span<int> dqcoeff,
             TxSize txSize,
-            ref Array2<short> dq,
+            ReadOnlySpan<short> dq,
             int ctx,
             ReadOnlySpan<short> scan,
             ReadOnlySpan<short> nb,
@@ -39,7 +39,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             ref Vp9EntropyProbs fc = ref xd.Fc.Value;
             int refr = xd.Mi[0].Value.IsInterBlock() ? 1 : 0;
             int band, c = 0;
-            ref Array6<Array6<Array3<byte>>> coefProbs = ref fc.CoefProbs[(int)txSize][(int)type][refr];
+            ReadOnlySpan<Array6<Array3<byte>>> coefProbs = fc.CoefProbs[(int)txSize][(int)type][refr].AsSpan();
             Span<byte> tokenCache = stackalloc byte[32 * 32];
             ReadOnlySpan<byte> bandTranslate = Luts.GetBandTranslate(txSize);
             int dqShift = txSize == TxSize.Tx32X32 ? 1 : 0;
@@ -57,22 +57,25 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             uint range = r.Range;
             int count = r.Count;
             
+            ReadOnlySpan<Array6<Array4<uint>>> coefSpan = counts.Coef[(int)txSize][(int)type][refr].AsSpan();
+            ReadOnlySpan<Array6<uint>> eobBranchSpan = counts.EobBranch[(int)txSize][(int)type][refr].AsSpan();
+
             while (c < maxEob)
             {
                 int val = -1;
                 band = bandTranslate[0];
                 bandTranslate = bandTranslate[1..];
-                ref Array3<byte> prob = ref coefProbs[band][ctx];
+                ReadOnlySpan<byte> prob = coefProbs[band][ctx].AsSpan();
                 if (!xd.Counts.IsNull)
                 {
-                    ++counts.EobBranch[(int)txSize][(int)type][refr][band][ctx];
+                    ++eobBranchSpan[band][ctx];
                 }
 
                 if (r.ReadBool(prob[EobContextNode], ref value, ref count, ref range) == 0)
                 {
                     if (!xd.Counts.IsNull)
                     {
-                        ++counts.Coef[(int)txSize][(int)type][refr][band][ctx][Constants.EobModelToken];
+                        ++coefSpan[band][ctx][Constants.EobModelToken];
                     }
 
                     break;
@@ -82,7 +85,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     if (!xd.Counts.IsNull)
                     {
-                        ++counts.Coef[(int)txSize][(int)type][refr][band][ctx][Constants.ZeroToken];
+                        ++coefSpan[band][ctx][Constants.ZeroToken];
                     }
 
                     dqv = dq[1];
@@ -99,7 +102,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     ctx = GetCoefContext(nb, tokenCache, c);
                     band = bandTranslate[0];
                     bandTranslate = bandTranslate[1..];
-                    prob = ref coefProbs[band][ctx];
+                    prob = coefProbs[band][ctx].AsSpan();
                 }
 
                 if (r.ReadBool(prob[OneContextNode], ref value, ref count, ref range) != 0)
@@ -107,7 +110,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     ReadOnlySpan<byte> p = Luts.Pareto8Full[prob[Constants.PivotNode] - 1];
                     if (!xd.Counts.IsNull)
                     {
-                        ++counts.Coef[(int)txSize][(int)type][refr][band][ctx][Constants.TwoToken];
+                        ++coefSpan[band][ctx][Constants.TwoToken];
                     }
 
                     if (r.ReadBool(p[0], ref value, ref count, ref range) != 0)
@@ -175,7 +178,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     if (!xd.Counts.IsNull)
                     {
-                        ++counts.Coef[(int)txSize][(int)type][refr][band][ctx][Constants.OneToken];
+                        ++coefSpan[band][ctx][Constants.OneToken];
                     }
 
                     tokenCache[scan[c]] = 1;
@@ -232,7 +235,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             ref Reader r = ref twd.BitReader;
             ref MacroBlockD xd = ref twd.Xd;
             ref MacroBlockDPlane pd = ref xd.Plane[plane];
-            ref Array2<short> dequant = ref pd.SegDequant[segId];
+            Span<short> dequant = pd.SegDequant[segId].AsSpan();
             int eob;
             Span<sbyte> a = pd.AboveContext.AsSpan()[x..];
             Span<sbyte> l = pd.LeftContext.AsSpan()[y..];
@@ -250,7 +253,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         GetPlaneType(plane),
                         pd.DqCoeff.AsSpan(),
                         txSize,
-                        ref dequant,
+                        dequant,
                         ctx,
                         sc.Scan,
                         sc.Neighbors,
@@ -266,7 +269,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         GetPlaneType(plane),
                         pd.DqCoeff.AsSpan(),
                         txSize,
-                        ref dequant,
+                        dequant,
                         ctx,
                         sc.Scan,
                         sc.Neighbors,
@@ -283,7 +286,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         GetPlaneType(plane),
                         pd.DqCoeff.AsSpan(),
                         txSize,
-                        ref dequant,
+                        dequant,
                         ctx,
                         sc.Scan,
                         sc.Neighbors,
@@ -303,7 +306,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         GetPlaneType(plane),
                         pd.DqCoeff.AsSpan(),
                         txSize,
-                        ref dequant,
+                        dequant,
                         ctx,
                         sc.Scan,
                         sc.Neighbors,

src/Ryujinx.Graphics.Nvdec.Vp9/Dsp/Convolve.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Nvdec.Vp9.Common;
+using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
@@ -129,7 +130,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int x = 0; x < w; ++x)
                 {
                     byte* srcX = &src[xQ4 >> SubpelBits];
-                    ref Array8<short> xFilter = ref xFilters[xQ4 & SubpelMask];
+                    Span<short> xFilter = xFilters[xQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -164,7 +165,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int x = 0; x < w; ++x)
                 {
                     byte* srcX = &src[xQ4 >> SubpelBits];
-                    ref Array8<short> xFilter = ref xFilters[xQ4 & SubpelMask];
+                    Span<short> xFilter = xFilters[xQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -275,7 +276,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int y = 0; y < h; ++y)
                 {
                     byte* srcY = &src[(yQ4 >> SubpelBits) * srcStride];
-                    ref Array8<short> yFilter = ref yFilters[yQ4 & SubpelMask];
+                    Span<short> yFilter = yFilters[yQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -310,7 +311,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int y = 0; y < h; ++y)
                 {
                     byte* srcY = &src[(yQ4 >> SubpelBits) * srcStride];
-                    ref Array8<short> yFilter = ref yFilters[yQ4 & SubpelMask];
+                    Span<short> yFilter = yFilters[yQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -619,7 +620,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int x = 0; x < w; ++x)
                 {
                     ushort* srcX = &src[xQ4 >> SubpelBits];
-                    ref Array8<short> xFilter = ref xFilters[xQ4 & SubpelMask];
+                    Span<short> xFilter = xFilters[xQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -655,7 +656,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int x = 0; x < w; ++x)
                 {
                     ushort* srcX = &src[xQ4 >> SubpelBits];
-                    ref Array8<short> xFilter = ref xFilters[xQ4 & SubpelMask];
+                    Span<short> xFilter = xFilters[xQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -692,7 +693,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int y = 0; y < h; ++y)
                 {
                     ushort* srcY = &src[(yQ4 >> SubpelBits) * srcStride];
-                    ref Array8<short> yFilter = ref yFilters[yQ4 & SubpelMask];
+                    Span<short> yFilter = yFilters[yQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {
@@ -728,7 +729,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Dsp
                 for (int y = 0; y < h; ++y)
                 {
                     ushort* srcY = &src[(yQ4 >> SubpelBits) * srcStride];
-                    ref Array8<short> yFilter = ref yFilters[yQ4 & SubpelMask];
+                    Span<short> yFilter = yFilters[yQ4 & SubpelMask].AsSpan();
                     int sum = 0;
                     for (int k = 0; k < SubpelTaps; ++k)
                     {

src/Ryujinx.Graphics.Nvdec.Vp9/EntropyMode.cs

@@ -304,31 +304,40 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         }
 
         internal static void TxCountsToBranchCounts32X32(ReadOnlySpan<uint> txCount32X32P,
-            ref Array3<Array2<uint>> ct32X32P)
+            ReadOnlySpan<Array2<uint>> ct32X32P)
         {
-            ct32X32P[0][0] = txCount32X32P[(int)TxSize.Tx4X4];
+            Span<uint> ct32X32PSpan0 = ct32X32P[0].AsSpan();
-            ct32X32P[0][1] = txCount32X32P[(int)TxSize.Tx8X8] + txCount32X32P[(int)TxSize.Tx16X16] +
+            Span<uint> ct32X32PSpan1 = ct32X32P[1].AsSpan();
+            Span<uint> ct32X32PSpan2 = ct32X32P[2].AsSpan();
+            
+            ct32X32PSpan0[0] = txCount32X32P[(int)TxSize.Tx4X4];
+            ct32X32PSpan0[1] = txCount32X32P[(int)TxSize.Tx8X8] + txCount32X32P[(int)TxSize.Tx16X16] +
                              txCount32X32P[(int)TxSize.Tx32X32];
-            ct32X32P[1][0] = txCount32X32P[(int)TxSize.Tx8X8];
+            ct32X32PSpan1[0] = txCount32X32P[(int)TxSize.Tx8X8];
-            ct32X32P[1][1] = txCount32X32P[(int)TxSize.Tx16X16] + txCount32X32P[(int)TxSize.Tx32X32];
+            ct32X32PSpan1[1] = txCount32X32P[(int)TxSize.Tx16X16] + txCount32X32P[(int)TxSize.Tx32X32];
-            ct32X32P[2][0] = txCount32X32P[(int)TxSize.Tx16X16];
+            ct32X32PSpan2[0] = txCount32X32P[(int)TxSize.Tx16X16];
-            ct32X32P[2][1] = txCount32X32P[(int)TxSize.Tx32X32];
+            ct32X32PSpan2[1] = txCount32X32P[(int)TxSize.Tx32X32];
         }
 
         internal static void TxCountsToBranchCounts16X16(ReadOnlySpan<uint> txCount16X16P,
-            ref Array2<Array2<uint>> ct16X16P)
+            ReadOnlySpan<Array2<uint>> ct16X16P)
         {
-            ct16X16P[0][0] = txCount16X16P[(int)TxSize.Tx4X4];
+            Span<uint> ct16X16PSpan0 = ct16X16P[0].AsSpan();
-            ct16X16P[0][1] = txCount16X16P[(int)TxSize.Tx8X8] + txCount16X16P[(int)TxSize.Tx16X16];
+            Span<uint> ct16X16PSpan1 = ct16X16P[1].AsSpan();
-            ct16X16P[1][0] = txCount16X16P[(int)TxSize.Tx8X8];
+            
-            ct16X16P[1][1] = txCount16X16P[(int)TxSize.Tx16X16];
+            ct16X16PSpan0[0] = txCount16X16P[(int)TxSize.Tx4X4];
+            ct16X16PSpan0[1] = txCount16X16P[(int)TxSize.Tx8X8] + txCount16X16P[(int)TxSize.Tx16X16];
+            ct16X16PSpan1[0] = txCount16X16P[(int)TxSize.Tx8X8];
+            ct16X16PSpan1[1] = txCount16X16P[(int)TxSize.Tx16X16];
         }
 
         internal static void TxCountsToBranchCounts8X8(ReadOnlySpan<uint> txCount8X8P,
-            ref Array1<Array2<uint>> ct8X8P)
+            ReadOnlySpan<Array2<uint>> ct8X8P)
         {
-            ct8X8P[0][0] = txCount8X8P[(int)TxSize.Tx4X4];
+            Span<uint> ct8X8PSpan = ct8X8P[0].AsSpan();
-            ct8X8P[0][1] = txCount8X8P[(int)TxSize.Tx8X8];
+            
+            ct8X8PSpan[0] = txCount8X8P[(int)TxSize.Tx4X4];
+            ct8X8PSpan[1] = txCount8X8P[(int)TxSize.Tx8X8];
         }
 
         public static unsafe void SetupPastIndependence(ref Vp9Common cm)

src/Ryujinx.Graphics.Nvdec.Vp9/LoopFilter.cs

@@ -378,9 +378,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             int index = shiftY;
 
+            Span<byte> lflYSpan = lfm.LflY.AsSpan();
+            
             for (int i = 0; i < bh; i++)
             {
-                MemoryMarshal.CreateSpan(ref lfm.LflY[index], 64 - index)[..bw].Fill((byte)filterLevel);
+                MemoryMarshal.CreateSpan(ref lflYSpan[index], 64 - index)[..bw].Fill((byte)filterLevel);
                 index += 8;
             }
 
@@ -445,24 +447,29 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             const ushort LeftBorderUv = 0x1111;
             const ushort AboveBorderUv = 0x000f;
             
+            Span<ulong> leftYSpan = lfm.LeftY.AsSpan();
+            Span<ulong> aboveYSpan = lfm.AboveY.AsSpan();
+            Span<ushort> leftUvSpan = lfm.LeftUv.AsSpan();
+            Span<ushort> aboveUvSpan = lfm.AboveUv.AsSpan();
+
             // The largest loopfilter we have is 16x16 so we use the 16x16 mask
             // for 32x32 transforms also.
-            lfm.LeftY[(int)TxSize.Tx16X16] |= lfm.LeftY[(int)TxSize.Tx32X32];
+            leftYSpan[(int)TxSize.Tx16X16] |= leftYSpan[(int)TxSize.Tx32X32];
-            lfm.AboveY[(int)TxSize.Tx16X16] |= lfm.AboveY[(int)TxSize.Tx32X32];
+            aboveYSpan[(int)TxSize.Tx16X16] |= aboveYSpan[(int)TxSize.Tx32X32];
-            lfm.LeftUv[(int)TxSize.Tx16X16] |= lfm.LeftUv[(int)TxSize.Tx32X32];
+            leftUvSpan[(int)TxSize.Tx16X16] |= leftUvSpan[(int)TxSize.Tx32X32];
-            lfm.AboveUv[(int)TxSize.Tx16X16] |= lfm.AboveUv[(int)TxSize.Tx32X32];
+            aboveUvSpan[(int)TxSize.Tx16X16] |= aboveUvSpan[(int)TxSize.Tx32X32];
 
             // We do at least 8 tap filter on every 32x32 even if the transform size
             // is 4x4. So if the 4x4 is set on a border pixel add it to the 8x8 and
             // remove it from the 4x4.
-            lfm.LeftY[(int)TxSize.Tx8X8] |= lfm.LeftY[(int)TxSize.Tx4X4] & LeftBorder;
+            leftYSpan[(int)TxSize.Tx8X8] |= leftYSpan[(int)TxSize.Tx4X4] & LeftBorder;
-            lfm.LeftY[(int)TxSize.Tx4X4] &= ~LeftBorder;
+            leftYSpan[(int)TxSize.Tx4X4] &= ~LeftBorder;
-            lfm.AboveY[(int)TxSize.Tx8X8] |= lfm.AboveY[(int)TxSize.Tx4X4] & AboveBorder;
+            aboveYSpan[(int)TxSize.Tx8X8] |= aboveYSpan[(int)TxSize.Tx4X4] & AboveBorder;
-            lfm.AboveY[(int)TxSize.Tx4X4] &= ~AboveBorder;
+            aboveYSpan[(int)TxSize.Tx4X4] &= ~AboveBorder;
-            lfm.LeftUv[(int)TxSize.Tx8X8] |= (ushort)(lfm.LeftUv[(int)TxSize.Tx4X4] & LeftBorderUv);
+            leftUvSpan[(int)TxSize.Tx8X8] |= (ushort)(leftUvSpan[(int)TxSize.Tx4X4] & LeftBorderUv);
-            lfm.LeftUv[(int)TxSize.Tx4X4] &= unchecked((ushort)~LeftBorderUv);
+            leftUvSpan[(int)TxSize.Tx4X4] &= unchecked((ushort)~LeftBorderUv);
-            lfm.AboveUv[(int)TxSize.Tx8X8] |= (ushort)(lfm.AboveUv[(int)TxSize.Tx4X4] & AboveBorderUv);
+            aboveUvSpan[(int)TxSize.Tx8X8] |= (ushort)(aboveUvSpan[(int)TxSize.Tx4X4] & AboveBorderUv);
-            lfm.AboveUv[(int)TxSize.Tx4X4] &= unchecked((ushort)~AboveBorderUv);
+            aboveUvSpan[(int)TxSize.Tx4X4] &= unchecked((ushort)~AboveBorderUv);
 
             // We do some special edge handling.
             if (miRow + Constants.MiBlockSize > cm.MiRows)
@@ -476,10 +483,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // Remove values completely outside our border.
                 for (int i = 0; i < (int)TxSize.Tx32X32; i++)
                 {
-                    lfm.LeftY[i] &= maskY;
+                    leftYSpan[i] &= maskY;
-                    lfm.AboveY[i] &= maskY;
+                    aboveYSpan[i] &= maskY;
-                    lfm.LeftUv[i] &= maskUv;
+                    leftUvSpan[i] &= maskUv;
-                    lfm.AboveUv[i] &= maskUv;
+                    aboveUvSpan[i] &= maskUv;
                 }
 
                 lfm.Int4X4Y &= maskY;
@@ -489,14 +496,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // apply the shorter one instead.
                 if (rows == 1)
                 {
-                    lfm.AboveUv[(int)TxSize.Tx8X8] |= lfm.AboveUv[(int)TxSize.Tx16X16];
+                    aboveUvSpan[(int)TxSize.Tx8X8] |= aboveUvSpan[(int)TxSize.Tx16X16];
-                    lfm.AboveUv[(int)TxSize.Tx16X16] = 0;
+                    aboveUvSpan[(int)TxSize.Tx16X16] = 0;
                 }
 
                 if (rows == 5)
                 {
-                    lfm.AboveUv[(int)TxSize.Tx8X8] |= (ushort)(lfm.AboveUv[(int)TxSize.Tx16X16] & 0xff00);
+                    aboveUvSpan[(int)TxSize.Tx8X8] |= (ushort)(aboveUvSpan[(int)TxSize.Tx16X16] & 0xff00);
-                    lfm.AboveUv[(int)TxSize.Tx16X16] &= (ushort)~(lfm.AboveUv[(int)TxSize.Tx16X16] & 0xff00);
+                    aboveUvSpan[(int)TxSize.Tx16X16] &= (ushort)~(aboveUvSpan[(int)TxSize.Tx16X16] & 0xff00);
                 }
             }
 
@@ -516,10 +523,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // Remove the bits outside the image edge.
                 for (int i = 0; i < (int)TxSize.Tx32X32; i++)
                 {
-                    lfm.LeftY[i] &= maskY;
+                    leftYSpan[i] &= maskY;
-                    lfm.AboveY[i] &= maskY;
+                    aboveYSpan[i] &= maskY;
-                    lfm.LeftUv[i] &= maskUv;
+                    leftUvSpan[i] &= maskUv;
-                    lfm.AboveUv[i] &= maskUv;
+                    aboveUvSpan[i] &= maskUv;
                 }
 
                 lfm.Int4X4Y &= maskY;
@@ -529,14 +536,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 // apply the shorter one instead.
                 if (columns == 1)
                 {
-                    lfm.LeftUv[(int)TxSize.Tx8X8] |= lfm.LeftUv[(int)TxSize.Tx16X16];
+                    leftUvSpan[(int)TxSize.Tx8X8] |= leftUvSpan[(int)TxSize.Tx16X16];
-                    lfm.LeftUv[(int)TxSize.Tx16X16] = 0;
+                    leftUvSpan[(int)TxSize.Tx16X16] = 0;
                 }
 
                 if (columns == 5)
                 {
-                    lfm.LeftUv[(int)TxSize.Tx8X8] |= (ushort)(lfm.LeftUv[(int)TxSize.Tx16X16] & 0xcccc);
+                    leftUvSpan[(int)TxSize.Tx8X8] |= (ushort)(leftUvSpan[(int)TxSize.Tx16X16] & 0xcccc);
-                    lfm.LeftUv[(int)TxSize.Tx16X16] &= (ushort)~(lfm.LeftUv[(int)TxSize.Tx16X16] & 0xcccc);
+                    leftUvSpan[(int)TxSize.Tx16X16] &= (ushort)~(leftUvSpan[(int)TxSize.Tx16X16] & 0xcccc);
                 }
             }
 
@@ -546,28 +553,28 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 for (int i = 0; i < (int)TxSize.Tx32X32; i++)
                 {
-                    lfm.LeftY[i] &= 0xfefefefefefefefeUL;
+                    leftYSpan[i] &= 0xfefefefefefefefeUL;
-                    lfm.LeftUv[i] &= 0xeeee;
+                    leftUvSpan[i] &= 0xeeee;
                 }
             }
 
             // Assert if we try to apply 2 different loop filters at the same position.
-            Debug.Assert((lfm.LeftY[(int)TxSize.Tx16X16] & lfm.LeftY[(int)TxSize.Tx8X8]) == 0);
+            Debug.Assert((leftYSpan[(int)TxSize.Tx16X16] & leftYSpan[(int)TxSize.Tx8X8]) == 0);
-            Debug.Assert((lfm.LeftY[(int)TxSize.Tx16X16] & lfm.LeftY[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((leftYSpan[(int)TxSize.Tx16X16] & leftYSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.LeftY[(int)TxSize.Tx8X8] & lfm.LeftY[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((leftYSpan[(int)TxSize.Tx8X8] & leftYSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.Int4X4Y & lfm.LeftY[(int)TxSize.Tx16X16]) == 0);
+            Debug.Assert((lfm.Int4X4Y & leftYSpan[(int)TxSize.Tx16X16]) == 0);
-            Debug.Assert((lfm.LeftUv[(int)TxSize.Tx16X16] & lfm.LeftUv[(int)TxSize.Tx8X8]) == 0);
+            Debug.Assert((leftUvSpan[(int)TxSize.Tx16X16] & leftUvSpan[(int)TxSize.Tx8X8]) == 0);
-            Debug.Assert((lfm.LeftUv[(int)TxSize.Tx16X16] & lfm.LeftUv[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((leftUvSpan[(int)TxSize.Tx16X16] & leftUvSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.LeftUv[(int)TxSize.Tx8X8] & lfm.LeftUv[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((leftUvSpan[(int)TxSize.Tx8X8] & leftUvSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.Int4X4Uv & lfm.LeftUv[(int)TxSize.Tx16X16]) == 0);
+            Debug.Assert((lfm.Int4X4Uv & leftUvSpan[(int)TxSize.Tx16X16]) == 0);
-            Debug.Assert((lfm.AboveY[(int)TxSize.Tx16X16] & lfm.AboveY[(int)TxSize.Tx8X8]) == 0);
+            Debug.Assert((aboveYSpan[(int)TxSize.Tx16X16] & aboveYSpan[(int)TxSize.Tx8X8]) == 0);
-            Debug.Assert((lfm.AboveY[(int)TxSize.Tx16X16] & lfm.AboveY[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((aboveYSpan[(int)TxSize.Tx16X16] & aboveYSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.AboveY[(int)TxSize.Tx8X8] & lfm.AboveY[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((aboveYSpan[(int)TxSize.Tx8X8] & aboveYSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.Int4X4Y & lfm.AboveY[(int)TxSize.Tx16X16]) == 0);
+            Debug.Assert((lfm.Int4X4Y & aboveYSpan[(int)TxSize.Tx16X16]) == 0);
-            Debug.Assert((lfm.AboveUv[(int)TxSize.Tx16X16] & lfm.AboveUv[(int)TxSize.Tx8X8]) == 0);
+            Debug.Assert((aboveUvSpan[(int)TxSize.Tx16X16] & aboveUvSpan[(int)TxSize.Tx8X8]) == 0);
-            Debug.Assert((lfm.AboveUv[(int)TxSize.Tx16X16] & lfm.AboveUv[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((aboveUvSpan[(int)TxSize.Tx16X16] & aboveUvSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.AboveUv[(int)TxSize.Tx8X8] & lfm.AboveUv[(int)TxSize.Tx4X4]) == 0);
+            Debug.Assert((aboveUvSpan[(int)TxSize.Tx8X8] & aboveUvSpan[(int)TxSize.Tx4X4]) == 0);
-            Debug.Assert((lfm.Int4X4Uv & lfm.AboveUv[(int)TxSize.Tx16X16]) == 0);
+            Debug.Assert((lfm.Int4X4Uv & aboveUvSpan[(int)TxSize.Tx16X16]) == 0);
         }
 
         public static unsafe void ResetLfm(ref Vp9Common cm)
@@ -583,6 +590,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             int lvl;
 
+            Span<LoopFilterThresh> lFThrSpan = lfi.Lfthr.AsSpan();
+
             // For each possible value for the loop filter fill out limits
             for (lvl = 0; lvl <= MaxLoopFilter; lvl++)
             {
@@ -602,8 +611,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     blockInsideLimit = 1;
                 }
 
-                lfi.Lfthr[lvl].Lim.AsSpan().Fill((byte)blockInsideLimit);
+                lFThrSpan[lvl].Lim.AsSpan().Fill((byte)blockInsideLimit);
-                lfi.Lfthr[lvl].Mblim.AsSpan().Fill((byte)((2 * (lvl + 2)) + blockInsideLimit));
+                lFThrSpan[lvl].Mblim.AsSpan().Fill((byte)((2 * (lvl + 2)) + blockInsideLimit));
             }
         }
 
@@ -625,6 +634,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 lf.LastSharpnessLevel = lf.SharpnessLevel;
             }
 
+            Span<Array4<Array2<byte>>> lvlSpan = lfi.Lvl.AsSpan();
+            Span<sbyte> refDeltasSpan = lf.RefDeltas.AsSpan();
+            Span<sbyte> modeDeltasSpan = lf.ModeDeltas.AsSpan();
+            sbyte intraFrameRefDelta = refDeltasSpan[Constants.IntraFrame];
+
             for (segId = 0; segId < Constants.MaxSegments; segId++)
             {
                 int lvlSeg = defaultFiltLvl;
@@ -639,20 +653,24 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     // We could get rid of this if we assume that deltas are set to
                     // zero when not in use; encoder always uses deltas
-                    MemoryMarshal.Cast<Array2<byte>, byte>(lfi.Lvl[segId].AsSpan()).Fill((byte)lvlSeg);
+                    MemoryMarshal.Cast<Array2<byte>, byte>(lvlSpan[segId].AsSpan()).Fill((byte)lvlSeg);
                 }
                 else
                 {
                     int refr, mode;
-                    int intraLvl = lvlSeg + (lf.RefDeltas[Constants.IntraFrame] * scale);
+                    int intraLvl = lvlSeg + (intraFrameRefDelta * scale);
-                    lfi.Lvl[segId][Constants.IntraFrame][0] = (byte)Math.Clamp(intraLvl, 0, MaxLoopFilter);
+                    lvlSpan[segId][Constants.IntraFrame][0] = (byte)Math.Clamp(intraLvl, 0, MaxLoopFilter);
+                    
+                    Span<Array2<byte>> lvlSpan2 = lvlSpan[segId].AsSpan();
 
                     for (refr = Constants.LastFrame; refr < Constants.MaxRefFrames; ++refr)
                     {
+                        Span<byte> lvlSpan3 = lvlSpan2[refr].AsSpan();
+                        
                         for (mode = 0; mode < MaxModeLfDeltas; ++mode)
                         {
-                            int interLvl = lvlSeg + (lf.RefDeltas[refr] * scale) + (lf.ModeDeltas[mode] * scale);
+                            int interLvl = lvlSeg + (refDeltasSpan[refr] * scale) + (modeDeltasSpan[mode] * scale);
-                            lfi.Lvl[segId][refr][mode] = (byte)Math.Clamp(interLvl, 0, MaxLoopFilter);
+                            lvlSpan3[mode] = (byte)Math.Clamp(interLvl, 0, MaxLoopFilter);
                         }
                     }
                 }
@@ -811,18 +829,32 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     lfis[1] = lfthr[lfl[lflForward]];
                     ss[1] = ss[0].Slice(8 * pitch);
 
+                    Span<byte> mblim0Span = lfis[0].Mblim.AsSpan();
+                    Span<byte> lim0Span = lfis[0].Lim.AsSpan();
+                    Span<byte> hevThr0Span = lfis[0].HevThr.AsSpan();
+                    Span<byte> mblim1Span = lfis[1].Mblim.AsSpan();
+                    Span<byte> lim1Span = lfis[1].Lim.AsSpan();
+                    Span<byte> hevThr1Span = lfis[1].HevThr.AsSpan();
+
                     if ((mask16X16 & dualOne) != 0)
                     {
                         if ((mask16X16 & dualOne) == dualOne)
                         {
-                            LoopFilterScalar.HighBdLpfVertical16Dual(ss[0], pitch, lfis[0].Mblim[0], lfis[0].Lim[0],
+                            LoopFilterScalar.HighBdLpfVertical16Dual(ss[0], pitch, mblim0Span[0], lim0Span[0],
-                                lfis[0].HevThr[0], bd);
+                                hevThr0Span[0], bd);
                         }
                         else
                         {
-                            ref LoopFilterThresh lfi = ref lfis[(mask16X16 & 1) == 0 ? 1 : 0];
+                            if ((mask16X16 & 1) == 0)
-                            LoopFilterScalar.HighBdLpfVertical16(ss[(mask16X16 & 1) == 0 ? 1 : 0], pitch, lfi.Mblim[0],
+                            {
-                                lfi.Lim[0], lfi.HevThr[0], bd);
+                                LoopFilterScalar.HighBdLpfVertical16(ss[1], pitch, mblim1Span[0],
+                                    lim1Span[0], hevThr1Span[0], bd);
+                            }
+                            else
+                            {
+                                LoopFilterScalar.HighBdLpfVertical16(ss[0], pitch, mblim0Span[0],
+                                    lim0Span[0], hevThr0Span[0], bd);
+                            }
                         }
                     }
 
@@ -833,24 +865,26 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             LoopFilterScalar.HighBdLpfVertical8Dual(
                                 ss[0],
                                 pitch,
-                                lfis[0].Mblim[0],
+                                mblim0Span[0],
-                                lfis[0].Lim[0],
+                                lim0Span[0],
-                                lfis[0].HevThr[0],
+                                hevThr0Span[0],
-                                lfis[1].Mblim[0],
+                                mblim1Span[0],
-                                lfis[1].Lim[0],
+                                lim1Span[0],
-                                lfis[1].HevThr[0],
+                                hevThr1Span[0],
                                 bd);
                         }
                         else
                         {
-                            ref LoopFilterThresh lfi = ref lfis[(mask8X8 & 1) == 0 ? 1 : 0];
+                            if ((mask8X8 & 1) == 0)
-                            LoopFilterScalar.HighBdLpfVertical8(
+                            {
-                                ss[(mask8X8 & 1) == 0 ? 1 : 0],
+                                LoopFilterScalar.HighBdLpfVertical8(ss[1], pitch, mblim1Span[0],
-                                pitch,
+                                    lim1Span[0], hevThr1Span[0], bd);
-                                lfi.Mblim[0],
+                            }
-                                lfi.Lim[0],
+                            else
-                                lfi.HevThr[0],
+                            {
-                                bd);
+                                LoopFilterScalar.HighBdLpfVertical8(ss[0], pitch, mblim0Span[0],
+                                    lim0Span[0], hevThr0Span[0], bd);
+                            }
                         }
                     }
 
@@ -861,19 +895,26 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             LoopFilterScalar.HighBdLpfVertical4Dual(
                                 ss[0],
                                 pitch,
-                                lfis[0].Mblim[0],
+                                mblim0Span[0],
-                                lfis[0].Lim[0],
+                                lim0Span[0],
-                                lfis[0].HevThr[0],
+                                hevThr0Span[0],
-                                lfis[1].Mblim[0],
+                                mblim1Span[0],
-                                lfis[1].Lim[0],
+                                lim1Span[0],
-                                lfis[1].HevThr[0],
+                                hevThr1Span[0],
                                 bd);
                         }
                         else
                         {
-                            ref LoopFilterThresh lfi = ref lfis[(mask4X4 & 1) == 0 ? 1 : 0];
+                            if ((mask4X4 & 1) == 0)
-                            LoopFilterScalar.HighBdLpfVertical4(ss[(mask4X4 & 1) == 0 ? 1 : 0], pitch, lfi.Mblim[0],
+                            {
-                                lfi.Lim[0], lfi.HevThr[0], bd);
+                                LoopFilterScalar.HighBdLpfVertical4(ss[1], pitch, mblim1Span[0],
+                                    lim1Span[0], hevThr1Span[0], bd);
+                            }
+                            else
+                            {
+                                LoopFilterScalar.HighBdLpfVertical4(ss[0], pitch, mblim0Span[0],
+                                    lim0Span[0], hevThr0Span[0], bd);
+                            }
                         }
                     }
 
@@ -884,19 +925,26 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             LoopFilterScalar.HighBdLpfVertical4Dual(
                                 ss[0].Slice(4),
                                 pitch,
-                                lfis[0].Mblim[0],
+                                mblim0Span[0],
-                                lfis[0].Lim[0],
+                                lim0Span[0],
-                                lfis[0].HevThr[0],
+                                hevThr0Span[0],
-                                lfis[1].Mblim[0],
+                                mblim1Span[0],
-                                lfis[1].Lim[0],
+                                lim1Span[0],
-                                lfis[1].HevThr[0],
+                                hevThr1Span[0],
                                 bd);
                         }
                         else
                         {
-                            ref LoopFilterThresh lfi = ref lfis[(mask4X4Int & 1) == 0 ? 1 : 0];
+                            if ((mask4X4Int & 1) == 0)
-                            LoopFilterScalar.HighBdLpfVertical4(ss[(mask4X4Int & 1) == 0 ? 1 : 0].Slice(4), pitch,
+                            {
-                                lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0], bd);
+                                LoopFilterScalar.HighBdLpfVertical4(ss[1].Slice(4), pitch, mblim1Span[0],
+                                    lim1Span[0], hevThr1Span[0], bd);
+                            }
+                            else
+                            {
+                                LoopFilterScalar.HighBdLpfVertical4(ss[0].Slice(4), pitch, mblim0Span[0],
+                                    lim0Span[0], hevThr0Span[0], bd);
+                            }
                         }
                     }
                 }
@@ -1087,17 +1135,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     LoopFilterThresh lfi = lfthr[lfl[0]];
                     
+                    Span<byte> mblimSpan = lfi.Mblim.AsSpan();
+                    Span<byte> limSpan = lfi.Lim.AsSpan();
+                    Span<byte> hevThrSpan = lfi.HevThr.AsSpan();
+
                     if ((mask16X16 & 1) != 0)
                     {
                         if ((mask16X16 & 3) == 3)
                         {
-                            LoopFilterScalar.HighBdLpfHorizontal16Dual(s, pitch, lfi.Mblim[0], lfi.Lim[0],
+                            LoopFilterScalar.HighBdLpfHorizontal16Dual(s, pitch, mblimSpan[0], limSpan[0],
-                                lfi.HevThr[0], bd);
+                                hevThrSpan[0], bd);
                             count = 2;
                         }
                         else
                         {
-                            LoopFilterScalar.HighBdLpfHorizontal16(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0],
+                            LoopFilterScalar.HighBdLpfHorizontal16(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0],
                                 bd);
                         }
                     }
@@ -1108,15 +1160,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             // Next block's thresholds.
                             LoopFilterThresh lfin = lfthr[lfl[1]];
                             
+                            Span<byte> nMblimSpan = lfin.Mblim.AsSpan();
+                            Span<byte> nLimSpan = lfin.Lim.AsSpan();
+                            Span<byte> nHevThrSpan = lfin.HevThr.AsSpan();
+
                             LoopFilterScalar.HighBdLpfHorizontal8Dual(
                                 s,
                                 pitch,
-                                lfi.Mblim[0],
+                                mblimSpan[0],
-                                lfi.Lim[0],
+                                limSpan[0],
-                                lfi.HevThr[0],
+                                hevThrSpan[0],
-                                lfin.Mblim[0],
+                                nMblimSpan[0],
-                                lfin.Lim[0],
+                                nLimSpan[0],
-                                lfin.HevThr[0],
+                                nHevThrSpan[0],
                                 bd);
 
                             if ((mask4X4Int & 3) == 3)
@@ -1124,36 +1180,36 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                                 LoopFilterScalar.HighBdLpfHorizontal4Dual(
                                     s.Slice(4 * pitch),
                                     pitch,
-                                    lfi.Mblim[0],
+                                    mblimSpan[0],
-                                    lfi.Lim[0],
+                                    limSpan[0],
-                                    lfi.HevThr[0],
+                                    hevThrSpan[0],
-                                    lfin.Mblim[0],
+                                    nMblimSpan[0],
-                                    lfin.Lim[0],
+                                    nLimSpan[0],
-                                    lfin.HevThr[0],
+                                    nHevThrSpan[0],
                                     bd);
                             }
                             else if ((mask4X4Int & 1) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, lfi.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, mblimSpan[0],
-                                    lfi.Lim[0], lfi.HevThr[0], bd);
+                                    limSpan[0], hevThrSpan[0], bd);
                             }
                             else if ((mask4X4Int & 2) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(8 + (4 * pitch)), pitch, lfin.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(8 + (4 * pitch)), pitch, nMblimSpan[0],
-                                    lfin.Lim[0], lfin.HevThr[0], bd);
+                                    nLimSpan[0], nHevThrSpan[0], bd);
                             }
 
                             count = 2;
                         }
                         else
                         {
-                            LoopFilterScalar.HighBdLpfHorizontal8(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0],
+                            LoopFilterScalar.HighBdLpfHorizontal8(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0],
                                 bd);
 
                             if ((mask4X4Int & 1) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, lfi.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, mblimSpan[0],
-                                    lfi.Lim[0], lfi.HevThr[0], bd);
+                                    limSpan[0], hevThrSpan[0], bd);
                             }
                         }
                     }
@@ -1164,15 +1220,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                             // Next block's thresholds.
                             LoopFilterThresh lfin = lfthr[lfl[1]];
                             
+                            Span<byte> nMblimSpan = lfin.Mblim.AsSpan();
+                            Span<byte> nLimSpan = lfin.Lim.AsSpan();
+                            Span<byte> nHevThrSpan = lfin.HevThr.AsSpan();
+
                             LoopFilterScalar.HighBdLpfHorizontal4Dual(
                                 s,
                                 pitch,
-                                lfi.Mblim[0],
+                                mblimSpan[0],
-                                lfi.Lim[0],
+                                limSpan[0],
-                                lfi.HevThr[0],
+                                hevThrSpan[0],
-                                lfin.Mblim[0],
+                                nMblimSpan[0],
-                                lfin.Lim[0],
+                                nLimSpan[0],
-                                lfin.HevThr[0],
+                                nHevThrSpan[0],
                                 bd);
 
                             if ((mask4X4Int & 3) == 3)
@@ -1180,43 +1240,43 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                                 LoopFilterScalar.HighBdLpfHorizontal4Dual(
                                     s.Slice(4 * pitch),
                                     pitch,
-                                    lfi.Mblim[0],
+                                    mblimSpan[0],
-                                    lfi.Lim[0],
+                                    limSpan[0],
-                                    lfi.HevThr[0],
+                                    hevThrSpan[0],
-                                    lfin.Mblim[0],
+                                    nMblimSpan[0],
-                                    lfin.Lim[0],
+                                    nLimSpan[0],
-                                    lfin.HevThr[0],
+                                    nHevThrSpan[0],
                                     bd);
                             }
                             else if ((mask4X4Int & 1) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, lfi.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, mblimSpan[0],
-                                    lfi.Lim[0], lfi.HevThr[0], bd);
+                                    limSpan[0], hevThrSpan[0], bd);
                             }
                             else if ((mask4X4Int & 2) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(8 + (4 * pitch)), pitch, lfin.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(8 + (4 * pitch)), pitch, nMblimSpan[0],
-                                    lfin.Lim[0], lfin.HevThr[0], bd);
+                                    nLimSpan[0], nHevThrSpan[0], bd);
                             }
 
                             count = 2;
                         }
                         else
                         {
-                            LoopFilterScalar.HighBdLpfHorizontal4(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0],
+                            LoopFilterScalar.HighBdLpfHorizontal4(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0],
                                 bd);
 
                             if ((mask4X4Int & 1) != 0)
                             {
-                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, lfi.Mblim[0],
+                                LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, mblimSpan[0],
-                                    lfi.Lim[0], lfi.HevThr[0], bd);
+                                    limSpan[0], hevThrSpan[0], bd);
                             }
                         }
                     }
                     else
                     {
-                        LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, lfi.Mblim[0], lfi.Lim[0],
+                        LoopFilterScalar.HighBdLpfHorizontal4(s.Slice(4 * pitch), pitch, mblimSpan[0], limSpan[0],
-                            lfi.HevThr[0], bd);
+                            hevThrSpan[0], bd);
                     }
                 }
 
@@ -1292,25 +1352,29 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 LoopFilterThresh lfi = lfthr[lfl[0]];
                 
+                Span<byte> mblimSpan = lfi.Mblim.AsSpan();
+                Span<byte> limSpan = lfi.Lim.AsSpan();
+                Span<byte> hevThrSpan = lfi.HevThr.AsSpan();
+
                 if ((mask & 1) != 0)
                 {
                     if ((mask16X16 & 1) != 0)
                     {
-                        LoopFilterScalar.HighBdLpfVertical16(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0], bd);
+                        LoopFilterScalar.HighBdLpfVertical16(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0], bd);
                     }
                     else if ((mask8X8 & 1) != 0)
                     {
-                        LoopFilterScalar.HighBdLpfVertical8(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0], bd);
+                        LoopFilterScalar.HighBdLpfVertical8(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0], bd);
                     }
                     else if ((mask4X4 & 1) != 0)
                     {
-                        LoopFilterScalar.HighBdLpfVertical4(s, pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0], bd);
+                        LoopFilterScalar.HighBdLpfVertical4(s, pitch, mblimSpan[0], limSpan[0], hevThrSpan[0], bd);
                     }
                 }
 
                 if ((mask4X4Int & 1) != 0)
                 {
-                    LoopFilterScalar.HighBdLpfVertical4(s.Slice(4), pitch, lfi.Mblim[0], lfi.Lim[0], lfi.HevThr[0], bd);
+                    LoopFilterScalar.HighBdLpfVertical4(s.Slice(4), pitch, mblimSpan[0], limSpan[0], hevThrSpan[0], bd);
                 }
 
                 s = s.Slice(8);
@@ -1555,9 +1619,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         {
             ref Buf2D dst = ref plane.Dst;
             ArrayPtr<byte> dst0 = dst.Buf;
-            ulong mask16X16 = lfm.LeftY[(int)TxSize.Tx16X16];
+            Span<ulong> leftYSpan = lfm.LeftY.AsSpan();
-            ulong mask8X8 = lfm.LeftY[(int)TxSize.Tx8X8];
+            ulong mask16X16 = leftYSpan[(int)TxSize.Tx16X16];
-            ulong mask4X4 = lfm.LeftY[(int)TxSize.Tx4X4];
+            ulong mask8X8 = leftYSpan[(int)TxSize.Tx8X8];
+            ulong mask4X4 = leftYSpan[(int)TxSize.Tx4X4];
             ulong mask4X4Int = lfm.Int4X4Y;
 
             Debug.Assert(plane.SubsamplingX == 0 && plane.SubsamplingY == 0);
@@ -1604,9 +1669,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             // Horizontal pass
             dst.Buf = dst0;
-            mask16X16 = lfm.AboveY[(int)TxSize.Tx16X16];
+            Span<ulong> aboveYSpan = lfm.AboveY.AsSpan();
-            mask8X8 = lfm.AboveY[(int)TxSize.Tx8X8];
+            mask16X16 = aboveYSpan[(int)TxSize.Tx16X16];
-            mask4X4 = lfm.AboveY[(int)TxSize.Tx4X4];
+            mask8X8 = aboveYSpan[(int)TxSize.Tx8X8];
+            mask4X4 = aboveYSpan[(int)TxSize.Tx4X4];
             mask4X4Int = lfm.Int4X4Y;
 
             for (int r = 0; r < Constants.MiBlockSize && miRow + r < cm.MiRows; r++)
@@ -1669,10 +1735,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             ArrayPtr<byte> dst0 = dst.Buf;
 
             Span<byte> lflUv = stackalloc byte[16];
+            Span<byte> lflY = lfm.LflY.AsSpan();
 
-            ushort mask16X16 = lfm.LeftUv[(int)TxSize.Tx16X16];
+            Span<ushort> leftUvSpan = lfm.LeftUv.AsSpan();
-            ushort mask8X8 = lfm.LeftUv[(int)TxSize.Tx8X8];
+            ushort mask16X16 = leftUvSpan[(int)TxSize.Tx16X16];
-            ushort mask4X4 = lfm.LeftUv[(int)TxSize.Tx4X4];
+            ushort mask8X8 = leftUvSpan[(int)TxSize.Tx8X8];
+            ushort mask4X4 = leftUvSpan[(int)TxSize.Tx4X4];
             ushort mask4X4Int = lfm.Int4X4Uv;
 
             Debug.Assert(plane.SubsamplingX == 1 && plane.SubsamplingY == 1);
@@ -1682,8 +1750,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 for (int c = 0; c < Constants.MiBlockSize >> 1; c++)
                 {
-                    lflUv[(r << 1) + c] = lfm.LflY[(r << 3) + (c << 1)];
+                    lflUv[(r << 1) + c] = lflY[(r << 3) + (c << 1)];
-                    lflUv[((r + 2) << 1) + c] = lfm.LflY[((r + 2) << 3) + (c << 1)];
+                    lflUv[((r + 2) << 1) + c] = lflY[((r + 2) << 3) + (c << 1)];
                 }
 
                 if (cm.UseHighBitDepth)
@@ -1725,9 +1793,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
             // Horizontal pass
             dst.Buf = dst0;
-            mask16X16 = lfm.AboveUv[(int)TxSize.Tx16X16];
+            Span<ushort> aboveUvSpan = lfm.AboveUv.AsSpan();
-            mask8X8 = lfm.AboveUv[(int)TxSize.Tx8X8];
+            mask16X16 = aboveUvSpan[(int)TxSize.Tx16X16];
-            mask4X4 = lfm.AboveUv[(int)TxSize.Tx4X4];
+            mask8X8 = aboveUvSpan[(int)TxSize.Tx8X8];
+            mask4X4 = aboveUvSpan[(int)TxSize.Tx4X4];
             mask4X4Int = lfm.Int4X4Uv;
 
             for (int r = 0; r < Constants.MiBlockSize && miRow + r < cm.MiRows; r += 2)
@@ -1806,16 +1875,17 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             int sbCols = TileInfo.MiColsAlignedToSb(cm.MiCols) >> Constants.MiBlockSizeLog2;
             LfPath path;
             int miRow, miCol;
+            Span<MacroBlockDPlane> planesSpan = planes.AsSpan();
 
             if (yOnly)
             {
                 path = LfPath.LfPath444;
             }
-            else if (planes[1].SubsamplingY == 1 && planes[1].SubsamplingX == 1)
+            else if (planesSpan[1].SubsamplingY == 1 && planesSpan[1].SubsamplingX == 1)
             {
                 path = LfPath.LfPath420;
             }
-            else if (planes[1].SubsamplingY == 0 && planes[1].SubsamplingX == 0)
+            else if (planesSpan[1].SubsamplingY == 0 && planesSpan[1].SubsamplingX == 0)
             {
                 path = LfPath.LfPath444;
             }
@@ -1837,23 +1907,23 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
                     lfSync.SyncRead(r, c);
 
-                    ReconInter.SetupDstPlanes(ref planes, ref frameBuffer, miRow, miCol);
+                    ReconInter.SetupDstPlanes(planesSpan, ref frameBuffer, miRow, miCol);
 
                     AdjustMask(ref cm, miRow, miCol, ref lfm[0]);
 
-                    FilterBlockPlaneSs00(ref cm, ref planes[0], miRow, ref lfm[0]);
+                    FilterBlockPlaneSs00(ref cm, ref planesSpan[0], miRow, ref lfm[0]);
                     for (plane = 1; plane < numPlanes; ++plane)
                     {
                         switch (path)
                         {
                             case LfPath.LfPath420:
-                                FilterBlockPlaneSs11(ref cm, ref planes[plane], miRow, ref lfm[0]);
+                                FilterBlockPlaneSs11(ref cm, ref planesSpan[plane], miRow, ref lfm[0]);
                                 break;
                             case LfPath.LfPath444:
-                                FilterBlockPlaneSs00(ref cm, ref planes[plane], miRow, ref lfm[0]);
+                                FilterBlockPlaneSs00(ref cm, ref planesSpan[plane], miRow, ref lfm[0]);
                                 break;
                             case LfPath.LfPathSlow:
-                                FilterBlockPlaneNon420(ref cm, ref planes[plane], mi.Slice(miCol), miRow,
+                                FilterBlockPlaneNon420(ref cm, ref planesSpan[plane], mi.Slice(miCol), miRow,
                                     miCol);
                                 break;
                         }

src/Ryujinx.Graphics.Nvdec.Vp9/Luts.cs

@@ -270,17 +270,16 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
         private static Array8<short> NewArray8Short(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7)
         {
-            Array8<short> output = new()
+            Array8<short> output = new();
-            {
+            Span<short> outputSpan = output.AsSpan();
-                [0] = e0,
+            outputSpan[0] = e0;
-                [1] = e1,
+            outputSpan[1] = e1;
-                [2] = e2,
+            outputSpan[2] = e2;
-                [3] = e3,
+            outputSpan[3] = e3;
-                [4] = e4,
+            outputSpan[4] = e4;
-                [5] = e5,
+            outputSpan[5] = e5;
-                [6] = e6,
+            outputSpan[6] = e6;
-                [7] = e7
+            outputSpan[7] = e7;
-            };
 
             return output;
         }

src/Ryujinx.Graphics.Nvdec.Vp9/PredCommon.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Graphics.Nvdec.Vp9.Types;
+using System;
 using System.Diagnostics;
 
 namespace Ryujinx.Graphics.Nvdec.Vp9
@@ -109,15 +110,17 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     sbyte vrfa = aSg ? xd.AboveMi.Value.RefFrame[0] : xd.AboveMi.Value.RefFrame[varRefIdx];
                     sbyte vrfl = lSg ? xd.LeftMi.Value.RefFrame[0] : xd.LeftMi.Value.RefFrame[varRefIdx];
 
-                    if (vrfa == vrfl && cm.CompVarRef[1] == vrfa)
+                    Span<sbyte> compVarRefSpan = cm.CompVarRef.AsSpan();
+                    
+                    if (vrfa == vrfl && compVarRefSpan[1] == vrfa)
                     {
                         predContext = 0;
                     }
                     else if (lSg && aSg)
                     {
                         // Single/Single
-                        if ((vrfa == cm.CompFixedRef && vrfl == cm.CompVarRef[0]) ||
+                        if ((vrfa == cm.CompFixedRef && vrfl == compVarRefSpan[0]) ||
-                            (vrfl == cm.CompFixedRef && vrfa == cm.CompVarRef[0]))
+                            (vrfl == cm.CompFixedRef && vrfa == compVarRefSpan[0]))
                         {
                             predContext = 4;
                         }
@@ -135,11 +138,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                         // Single/Comp
                         sbyte vrfc = lSg ? vrfa : vrfl;
                         sbyte rfs = aSg ? vrfa : vrfl;
-                        if (vrfc == cm.CompVarRef[1] && rfs != cm.CompVarRef[1])
+                        if (vrfc == compVarRefSpan[1] && rfs != compVarRefSpan[1])
                         {
                             predContext = 1;
                         }
-                        else if (rfs == cm.CompVarRef[1] && vrfc != cm.CompVarRef[1])
+                        else if (rfs == compVarRefSpan[1] && vrfc != compVarRefSpan[1])
                         {
                             predContext = 2;
                         }
@@ -212,14 +215,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     // Intra/Inter or Inter/Intra
                     ref ModeInfo edgeMi = ref aboveIntra ? ref xd.LeftMi.Value : ref xd.AboveMi.Value;
+                    Span<sbyte> refFrameSpan = edgeMi.RefFrame.AsSpan();
                     if (!edgeMi.HasSecondRef())
                     {
-                        predContext = 4 * (edgeMi.RefFrame[0] == Constants.LastFrame ? 1 : 0);
+                        predContext = 4 * (refFrameSpan[0] == Constants.LastFrame ? 1 : 0);
                     }
                     else
                     {
-                        predContext = 1 + (edgeMi.RefFrame[0] == Constants.LastFrame ||
+                        predContext = 1 + (refFrameSpan[0] == Constants.LastFrame ||
-                                           edgeMi.RefFrame[1] == Constants.LastFrame
+                                           refFrameSpan[1] == Constants.LastFrame
                             ? 1
                             : 0);
                     }
@@ -229,10 +233,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     // Inter/Inter
                     bool aboveHasSecond = xd.AboveMi.Value.HasSecondRef();
                     bool leftHasSecond = xd.LeftMi.Value.HasSecondRef();
-                    sbyte above0 = xd.AboveMi.Value.RefFrame[0];
+                    Span<sbyte> aRefFrameSpan = xd.AboveMi.Value.RefFrame.AsSpan();
-                    sbyte above1 = xd.AboveMi.Value.RefFrame[1];
+                    sbyte above0 = aRefFrameSpan[0];
-                    sbyte left0 = xd.LeftMi.Value.RefFrame[0];
+                    sbyte above1 = aRefFrameSpan[1];
-                    sbyte left1 = xd.LeftMi.Value.RefFrame[1];
+                    Span<sbyte> lRefFrameSpan = xd.LeftMi.Value.RefFrame.AsSpan();
+                    sbyte left0 = lRefFrameSpan[0];
+                    sbyte left1 = lRefFrameSpan[1];
 
                     if (aboveHasSecond && leftHasSecond)
                     {
@@ -281,8 +287,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     }
                     else
                     {
-                        predContext = 1 + (edgeMi.RefFrame[0] == Constants.LastFrame ||
+                        Span<sbyte> refFrameSpan = edgeMi.RefFrame.AsSpan();
-                                           edgeMi.RefFrame[1] == Constants.LastFrame
+                        
+                        predContext = 1 + (refFrameSpan[0] == Constants.LastFrame ||
+                                           refFrameSpan[1] == Constants.LastFrame
                             ? 1
                             : 0);
                     }
@@ -321,21 +329,22 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 {
                     // Intra/Inter or Inter/Intra
                     ref ModeInfo edgeMi = ref aboveIntra ? ref xd.LeftMi.Value : ref xd.AboveMi.Value;
+                    Span<sbyte> refFrameSpan = edgeMi.RefFrame.AsSpan();
                     if (!edgeMi.HasSecondRef())
                     {
-                        if (edgeMi.RefFrame[0] == Constants.LastFrame)
+                        if (refFrameSpan[0] == Constants.LastFrame)
                         {
                             predContext = 3;
                         }
                         else
                         {
-                            predContext = 4 * (edgeMi.RefFrame[0] == Constants.GoldenFrame ? 1 : 0);
+                            predContext = 4 * (refFrameSpan[0] == Constants.GoldenFrame ? 1 : 0);
                         }
                     }
                     else
                     {
-                        predContext = 1 + (2 * (edgeMi.RefFrame[0] == Constants.GoldenFrame ||
+                        predContext = 1 + (2 * (refFrameSpan[0] == Constants.GoldenFrame ||
-                                                edgeMi.RefFrame[1] == Constants.GoldenFrame
+                                                refFrameSpan[1] == Constants.GoldenFrame
                             ? 1
                             : 0));
                     }
@@ -345,10 +354,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                     // Inter/Inter
                     bool aboveHasSecond = xd.AboveMi.Value.HasSecondRef();
                     bool leftHasSecond = xd.LeftMi.Value.HasSecondRef();
-                    sbyte above0 = xd.AboveMi.Value.RefFrame[0];
+                    Span<sbyte> aRefFrameSpan = xd.AboveMi.Value.RefFrame.AsSpan();
-                    sbyte above1 = xd.AboveMi.Value.RefFrame[1];
+                    sbyte above0 = aRefFrameSpan[0];
-                    sbyte left0 = xd.LeftMi.Value.RefFrame[0];
+                    sbyte above1 = aRefFrameSpan[1];
-                    sbyte left1 = xd.LeftMi.Value.RefFrame[1];
+                    Span<sbyte> lRefFrameSpan = xd.LeftMi.Value.RefFrame.AsSpan();
+                    sbyte left0 = lRefFrameSpan[0];
+                    sbyte left1 = lRefFrameSpan[1];
 
                     if (aboveHasSecond && leftHasSecond)
                     {
@@ -407,19 +418,20 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             {
                 // One edge available
                 ref ModeInfo edgeMi = ref !xd.AboveMi.IsNull ? ref xd.AboveMi.Value : ref xd.LeftMi.Value;
+                Span<sbyte> refFrameSpan = edgeMi.RefFrame.AsSpan();
 
-                if (!edgeMi.IsInterBlock() || (edgeMi.RefFrame[0] == Constants.LastFrame && !edgeMi.HasSecondRef()))
+                if (!edgeMi.IsInterBlock() || (refFrameSpan[0] == Constants.LastFrame && !edgeMi.HasSecondRef()))
                 {
                     predContext = 2;
                 }
                 else if (!edgeMi.HasSecondRef())
                 {
-                    predContext = 4 * (edgeMi.RefFrame[0] == Constants.GoldenFrame ? 1 : 0);
+                    predContext = 4 * (refFrameSpan[0] == Constants.GoldenFrame ? 1 : 0);
                 }
                 else
                 {
-                    predContext = 3 * (edgeMi.RefFrame[0] == Constants.GoldenFrame ||
+                    predContext = 3 * (refFrameSpan[0] == Constants.GoldenFrame ||
-                                       edgeMi.RefFrame[1] == Constants.GoldenFrame
+                                       refFrameSpan[1] == Constants.GoldenFrame
                         ? 1
                         : 0);
                 }

src/Ryujinx.Graphics.Nvdec.Vp9/Prob.cs

@@ -37,7 +37,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             return (byte)BitUtils.RoundPowerOfTwo((prob1 * (256 - factor)) + (prob2 * factor), 8);
         }
 
-        public static byte MergeProbs(byte preProb, ref Array2<uint> ct, uint countSat, uint maxUpdateFactor)
+        public static byte MergeProbs(byte preProb, ReadOnlySpan<uint> ct, uint countSat, uint maxUpdateFactor)
         {
             byte prob = GetBinaryProb(ct[0], ct[1]);
             uint count = Math.Min(ct[0] + ct[1], countSat);
@@ -53,7 +53,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
 
         private const int ModeMvCountSat = 20;
 
-        public static byte ModeMvMergeProbs(byte preProb, ref Array2<uint> ct)
+        public static byte ModeMvMergeProbs(byte preProb, ReadOnlySpan<uint> ct)
         {
             uint den = ct[0] + ct[1];
             if (den == 0)
@@ -81,7 +81,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
             Array2<uint> ct = new();
             ct[0] = leftCount;
             ct[1] = rightCount;
-            probs[(int)(i >> 1)] = ModeMvMergeProbs(preProbs[(int)(i >> 1)], ref ct);
+            probs[(int)(i >> 1)] = ModeMvMergeProbs(preProbs[(int)(i >> 1)], ct.AsSpan());
             return leftCount + rightCount;
         }
 

src/Ryujinx.Graphics.Nvdec.Vp9/ReconInter.cs

@@ -164,7 +164,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
         }
 
         public static void SetupDstPlanes(
-            ref Array3<MacroBlockDPlane> planes,
+            Span<MacroBlockDPlane> planes,
             ref Surface src,
             int miRow,
             int miCol)
@@ -205,9 +205,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9
                 strides[1] = src.UvStride;
                 strides[2] = src.UvStride;
 
+                Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
+
                 for (int i = 0; i < Constants.MaxMbPlane; ++i)
                 {
-                    ref MacroBlockDPlane pd = ref xd.Plane[i];
+                    ref MacroBlockDPlane pd = ref planeSpan[i];
                     SetupPredPlanes(ref pd.Pre[idx], buffers[i], strides[i], miRow, miCol, sf, pd.SubsamplingX,
                         pd.SubsamplingY);
                 }

src/Ryujinx.Graphics.Nvdec.Vp9/Types/LoopFilter.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Memory;
+using System;
 
 namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 {
@@ -29,12 +30,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             ModeRefDeltaEnabled = true;
             ModeRefDeltaUpdate = true;
             
-            RefDeltas[Constants.IntraFrame] = 1;
+            Span<sbyte> refDeltasSpan = RefDeltas.AsSpan();
-            RefDeltas[Constants.LastFrame] = 0;
+            Span<sbyte> modeDeltasSpan = ModeDeltas.AsSpan();
-            RefDeltas[Constants.GoldenFrame] = -1;
+
-            RefDeltas[Constants.AltRefFrame] = -1;
+            refDeltasSpan[Constants.IntraFrame] = 1;
-            ModeDeltas[0] = 0;
+            refDeltasSpan[Constants.LastFrame] = 0;
-            ModeDeltas[1] = 0;
+            refDeltasSpan[Constants.GoldenFrame] = -1;
+            refDeltasSpan[Constants.AltRefFrame] = -1;
+            modeDeltasSpan[0] = 0;
+            modeDeltasSpan[1] = 0;
         }
     }
 }

src/Ryujinx.Graphics.Nvdec.Vp9/Types/MacroBlockD.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Nvdec.Vp9.Common;
 using Ryujinx.Graphics.Video;
+using System;
 
 namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 {
@@ -147,10 +148,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public void SetupBlockPlanes(int ssX, int ssY)
         {
+            Span<MacroBlockDPlane> planeSpan = Plane.AsSpan();
+            
             for (int i = 0; i < Constants.MaxMbPlane; i++)
             {
-                Plane[i].SubsamplingX = i != 0 ? ssX : 0;
+                planeSpan[i].SubsamplingX = i != 0 ? ssX : 0;
-                Plane[i].SubsamplingY = i != 0 ? ssY : 0;
+                planeSpan[i].SubsamplingY = i != 0 ? ssY : 0;
             }
         }
 
@@ -159,11 +162,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             int aboveIdx = miCol * 2;
             int leftIdx = (miRow * 2) & 15;
             
+            Span<MacroBlockDPlane> planeSpan = Plane.AsSpan();
+            Span<ArrayPtr<sbyte>> aboveContextSpan = AboveContext.AsSpan();
+            Span<Array16<sbyte>> leftContextSpan = LeftContext.AsSpan();
+
             for (int i = 0; i < Constants.MaxMbPlane; ++i)
             {
-                ref MacroBlockDPlane pd = ref Plane[i];
+                ref MacroBlockDPlane pd = ref planeSpan[i];
-                pd.AboveContext = AboveContext[i].Slice(aboveIdx >> pd.SubsamplingX);
+                pd.AboveContext = aboveContextSpan[i].Slice(aboveIdx >> pd.SubsamplingX);
-                pd.LeftContext = new ArrayPtr<sbyte>(ref LeftContext[i][leftIdx >> pd.SubsamplingY],
+                pd.LeftContext = new ArrayPtr<sbyte>(ref leftContextSpan[i][leftIdx >> pd.SubsamplingY],
                     16 - (leftIdx >> pd.SubsamplingY));
             }
         }
@@ -182,9 +189,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public unsafe void DecResetSkipContext()
         {
+            Span<MacroBlockDPlane> planeSpan = Plane.AsSpan();
+            
             for (int i = 0; i < Constants.MaxMbPlane; i++)
             {
-                ref MacroBlockDPlane pd = ref Plane[i];
+                ref MacroBlockDPlane pd = ref planeSpan[i];
                 MemoryUtil.Fill(pd.AboveContext.ToPointer(), (sbyte)0, pd.N4W);
                 MemoryUtil.Fill(pd.LeftContext.ToPointer(), (sbyte)0, pd.N4H);
             }

src/Ryujinx.Graphics.Nvdec.Vp9/Types/ModeInfo.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Memory;
+using System;
 using System.Diagnostics;
 
 namespace Ryujinx.Graphics.Nvdec.Vp9.Types
@@ -65,36 +66,41 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public Mv MvPredQ4(int idx)
         {
+            Span<BModeInfo> bmiSpan = Bmi.AsSpan();
+            
             Mv res = new()
             {
                 Row = (short)ReconInter.RoundMvCompQ4(
-                    Bmi[0].Mv[idx].Row + Bmi[1].Mv[idx].Row +
+                    bmiSpan[0].Mv[idx].Row + bmiSpan[1].Mv[idx].Row +
-                    Bmi[2].Mv[idx].Row + Bmi[3].Mv[idx].Row),
+                    bmiSpan[2].Mv[idx].Row + bmiSpan[3].Mv[idx].Row),
                 Col = (short)ReconInter.RoundMvCompQ4(
-                    Bmi[0].Mv[idx].Col + Bmi[1].Mv[idx].Col +
+                    bmiSpan[0].Mv[idx].Col + bmiSpan[1].Mv[idx].Col +
-                    Bmi[2].Mv[idx].Col + Bmi[3].Mv[idx].Col)
+                    bmiSpan[2].Mv[idx].Col + bmiSpan[3].Mv[idx].Col)
             };
             return res;
         }
 
         public Mv MvPredQ2(int idx, int block0, int block1)
         {
+            Span<BModeInfo> bmiSpan = Bmi.AsSpan();
+            
             Mv res = new()
             {
                 Row = (short)ReconInter.RoundMvCompQ2(
-                    Bmi[block0].Mv[idx].Row +
+                    bmiSpan[block0].Mv[idx].Row +
-                    Bmi[block1].Mv[idx].Row),
+                    bmiSpan[block1].Mv[idx].Row),
                 Col = (short)ReconInter.RoundMvCompQ2(
-                    Bmi[block0].Mv[idx].Col +
+                    bmiSpan[block0].Mv[idx].Col +
-                    Bmi[block1].Mv[idx].Col)
+                    bmiSpan[block1].Mv[idx].Col)
             };
             return res;
         }
 
         // Performs mv sign inversion if indicated by the reference frame combination.
-        public Mv ScaleMv(int refr, sbyte thisRefFrame, ref Array4<sbyte> refSignBias)
+        public Mv ScaleMv(int refr, sbyte thisRefFrame, Span<sbyte> refSignBias)
         {
             Mv mv = Mv[refr];
+            
             if (refSignBias[RefFrame[refr]] != refSignBias[thisRefFrame])
             {
                 mv.Row *= -1;

src/Ryujinx.Graphics.Nvdec.Vp9/Types/Mv.cs

@@ -99,10 +99,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             }
             else
             {
+                Span<Array2<uint>> bitsSpan = counts.Bits[comp].AsSpan();
+                
                 int b = c + Constants.Class0Bits - 1; // Number of bits
                 for (int i = 0; i < b; ++i)
                 {
-                    counts.Bits[comp][i][(d >> i) & 1] += (uint)incr;
+                    bitsSpan[i][(d >> i) & 1] += (uint)incr;
                 }
 
                 counts.Fp[comp][f] += (uint)incr;

src/Ryujinx.Graphics.Nvdec.Vp9/Types/Segmentation.cs

@@ -29,7 +29,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public Array8<uint> FeatureMask;
         public int AqAvOffset;
 
-        public static byte GetPredProbSegId(ref Array3<byte> segPredProbs, ref MacroBlockD xd)
+        public static byte GetPredProbSegId(ReadOnlySpan<byte> segPredProbs, ref MacroBlockD xd)
         {
             return segPredProbs[xd.GetPredContextSegId()];
         }
@@ -105,9 +105,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             UpdateMap = rb.ReadBit() != 0;
             if (UpdateMap)
             {
+                Span<byte> segTreeProbSpan = fc.SegTreeProb.AsSpan();
+                Span<byte> segPredProbSpan = fc.SegPredProb.AsSpan();
+                
                 for (int i = 0; i < SegTreeProbs; i++)
                 {
-                    fc.SegTreeProb[i] = rb.ReadBit() != 0
+                    segTreeProbSpan[i] = rb.ReadBit() != 0
                         ? (byte)rb.ReadLiteral(8)
                         : (byte)Prob.MaxProb;
                 }
@@ -117,7 +120,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 {
                     for (int i = 0; i < PredictionProbs; i++)
                     {
-                        fc.SegPredProb[i] = rb.ReadBit() != 0
+                        segPredProbSpan[i] = rb.ReadBit() != 0
                             ? (byte)rb.ReadLiteral(8)
                             : (byte)Prob.MaxProb;
                     }
@@ -126,7 +129,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 {
                     for (int i = 0; i < PredictionProbs; i++)
                     {
-                        fc.SegPredProb[i] = Prob.MaxProb;
+                        segPredProbSpan[i] = Prob.MaxProb;
                     }
                 }
             }

src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Common.cs

@@ -155,9 +155,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public bool CompoundReferenceAllowed()
         {
+            Span<sbyte> refFrameSignBiasSpan = RefFrameSignBias.AsSpan();
+            
             for (int i = 1; i < Constants.RefsPerFrame; ++i)
             {
-                if (RefFrameSignBias[i + 1] != RefFrameSignBias[1])
+                if (refFrameSignBiasSpan[i + 1] != refFrameSignBiasSpan[1])
                 {
                     return true;
                 }
@@ -173,13 +175,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public readonly int GetFreeFb()
         {
-            ref Array12<RefCntBuffer> frameBufs = ref BufferPool.Value.FrameBufs;
+            Span<RefCntBuffer> frameBuffs = BufferPool.Value.FrameBufs.AsSpan();
 
             int i;
 
             for (i = 0; i < Constants.FrameBuffers; ++i)
             {
-                if (frameBufs[i].RefCount == 0)
+                if (frameBuffs[i].RefCount == 0)
                 {
                     break;
                 }
@@ -187,7 +189,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
             if (i != Constants.FrameBuffers)
             {
-                frameBufs[i].RefCount = 1;
+                frameBuffs[i].RefCount = 1;
             }
             else
             {
@@ -240,25 +242,29 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         private void AllocSegMap(MemoryAllocator allocator, int segMapSize)
         {
+            Span<ArrayPtr<byte>> segMapArraySpan = SegMapArray.AsSpan();
+            
             for (int i = 0; i < Constants.NumPingPongBuffers; ++i)
             {
-                SegMapArray[i] = allocator.Allocate<byte>(segMapSize);
+                segMapArraySpan[i] = allocator.Allocate<byte>(segMapSize);
             }
 
             // Init the index.
             SegMapIdx = 0;
             PrevSegMapIdx = 1;
 
-            CurrentFrameSegMap = SegMapArray[SegMapIdx];
+            CurrentFrameSegMap = segMapArraySpan[SegMapIdx];
-            LastFrameSegMap = SegMapArray[PrevSegMapIdx];
+            LastFrameSegMap = segMapArraySpan[PrevSegMapIdx];
         }
 
         private void FreeSegMap(MemoryAllocator allocator)
         {
+            Span<ArrayPtr<byte>> segMapArraySpan = SegMapArray.AsSpan();
+            
             for (int i = 0; i < Constants.NumPingPongBuffers; ++i)
             {
-                allocator.Free(SegMapArray[i]);
+                allocator.Free(segMapArraySpan[i]);
-                SegMapArray[i] = ArrayPtr<byte>.Null;
+                segMapArraySpan[i] = ArrayPtr<byte>.Null;
             }
 
             CurrentFrameSegMap = ArrayPtr<byte>.Null;
@@ -366,18 +372,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         internal void InitMacroBlockD(ref MacroBlockD xd, ArrayPtr<int> dqcoeff)
         {
+            Span<MacroBlockDPlane> planeSpan = xd.Plane.AsSpan();
+            Span<ArrayPtr<sbyte>> aboveContextSpan = xd.AboveContext.AsSpan();
+            
             for (int i = 0; i < Constants.MaxMbPlane; ++i)
             {
-                xd.Plane[i].DqCoeff = dqcoeff;
+                planeSpan[i].DqCoeff = dqcoeff;
-                xd.AboveContext[i] = AboveContext.Slice(i * 2 * TileInfo.MiColsAlignedToSb(MiCols));
+                aboveContextSpan[i] = AboveContext.Slice(i * 2 * TileInfo.MiColsAlignedToSb(MiCols));
 
                 if (i == 0)
                 {
-                    MemoryUtil.Copy(ref xd.Plane[i].SegDequant, ref YDequant);
+                    MemoryUtil.Copy(ref planeSpan[i].SegDequant, ref YDequant);
                 }
                 else
                 {
-                    MemoryUtil.Copy(ref xd.Plane[i].SegDequant, ref UvDequant);
+                    MemoryUtil.Copy(ref planeSpan[i].SegDequant, ref UvDequant);
                 }
 
                 xd.Fc = new Ptr<Vp9EntropyProbs>(ref Fc.Value);
@@ -395,32 +404,43 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             // Build y/uv dequant values based on segmentation.
             if (Seg.Enabled)
             {
+                Span<Array2<short>> yDequantSpan1 = YDequant.AsSpan();
+                Span<Array2<short>> uvDequantSpan1 = UvDequant.AsSpan();
+                
                 for (int i = 0; i < Constants.MaxSegments; ++i)
                 {
+                    Span<short> yDequantSpan2 = yDequantSpan1[i].AsSpan();
+                    Span<short> uvDequantSpan2 = uvDequantSpan1[i].AsSpan();
+                    
                     int qindex = Seg.GetQIndex(i, BaseQindex);
-                    YDequant[i][0] = QuantCommon.DcQuant(qindex, YDcDeltaQ, BitDepth);
+                    yDequantSpan2[0] = QuantCommon.DcQuant(qindex, YDcDeltaQ, BitDepth);
-                    YDequant[i][1] = QuantCommon.AcQuant(qindex, 0, BitDepth);
+                    yDequantSpan2[1] = QuantCommon.AcQuant(qindex, 0, BitDepth);
-                    UvDequant[i][0] = QuantCommon.DcQuant(qindex, UvDcDeltaQ, BitDepth);
+                    uvDequantSpan2[0] = QuantCommon.DcQuant(qindex, UvDcDeltaQ, BitDepth);
-                    UvDequant[i][1] = QuantCommon.AcQuant(qindex, UvAcDeltaQ, BitDepth);
+                    uvDequantSpan2[1] = QuantCommon.AcQuant(qindex, UvAcDeltaQ, BitDepth);
                 }
             }
             else
             {
+                Span<short> yDequantSpan = YDequant[0].AsSpan();
+                Span<short> uvDequantSpan = UvDequant[0].AsSpan();
+                
                 int qindex = BaseQindex;
                 // When segmentation is disabled, only the first value is used.  The
                 // remaining are don't cares.
-                YDequant[0][0] = QuantCommon.DcQuant(qindex, YDcDeltaQ, BitDepth);
+                yDequantSpan[0] = QuantCommon.DcQuant(qindex, YDcDeltaQ, BitDepth);
-                YDequant[0][1] = QuantCommon.AcQuant(qindex, 0, BitDepth);
+                yDequantSpan[1] = QuantCommon.AcQuant(qindex, 0, BitDepth);
-                UvDequant[0][0] = QuantCommon.DcQuant(qindex, UvDcDeltaQ, BitDepth);
+                uvDequantSpan[0] = QuantCommon.DcQuant(qindex, UvDcDeltaQ, BitDepth);
-                UvDequant[0][1] = QuantCommon.AcQuant(qindex, UvAcDeltaQ, BitDepth);
+                uvDequantSpan[1] = QuantCommon.AcQuant(qindex, UvAcDeltaQ, BitDepth);
             }
         }
 
         public void SetupScaleFactors()
         {
+            Span<RefBuffer> frameRefsSpan = FrameRefs.AsSpan();
+            
             for (int i = 0; i < Constants.RefsPerFrame; ++i)
             {
-                ref RefBuffer refBuf = ref FrameRefs[i];
+                ref RefBuffer refBuf = ref frameRefsSpan[i];
                 refBuf.Sf.SetupScaleFactorsForFrame(refBuf.Buf.Width, refBuf.Buf.Height, Width, Height);
             }
         }
@@ -431,26 +451,34 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
             if (ReferenceMode == ReferenceMode.Select)
             {
+                Span<byte> compInterProbSpan = fc.CompInterProb.AsSpan();
+                
                 for (int i = 0; i < Constants.CompInterContexts; ++i)
                 {
-                    r.DiffUpdateProb(ref fc.CompInterProb[i]);
+                    r.DiffUpdateProb(ref compInterProbSpan[i]);
                 }
             }
 
             if (ReferenceMode != ReferenceMode.Compound)
             {
+                Span<Array2<byte>> singleRefProbSpan1 = fc.SingleRefProb.AsSpan();
+                
                 for (int i = 0; i < Constants.RefContexts; ++i)
                 {
-                    r.DiffUpdateProb(ref fc.SingleRefProb[i][0]);
+                    Span<byte> singleRefProbSpan2 = singleRefProbSpan1[i].AsSpan();
-                    r.DiffUpdateProb(ref fc.SingleRefProb[i][1]);
+                    
+                    r.DiffUpdateProb(ref singleRefProbSpan2[0]);
+                    r.DiffUpdateProb(ref singleRefProbSpan2[1]);
                 }
             }
 
             if (ReferenceMode != ReferenceMode.Single)
             {
+                Span<byte> compRefProbSpan = fc.CompRefProb.AsSpan();
+                
                 for (int i = 0; i < Constants.RefContexts; ++i)
                 {
-                    r.DiffUpdateProb(ref fc.CompRefProb[i]);
+                    r.DiffUpdateProb(ref compRefProbSpan[i]);
                 }
             }
         }
@@ -469,99 +497,124 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public void SetupCompoundReferenceMode()
         {
-            if (RefFrameSignBias[Constants.LastFrame] == RefFrameSignBias[Constants.GoldenFrame])
+            Span<sbyte> refFrameSignBiasSpan = RefFrameSignBias.AsSpan();
+            Span<sbyte> compVarRefSpan = CompVarRef.AsSpan();
+            
+            if (refFrameSignBiasSpan[Constants.LastFrame] == refFrameSignBiasSpan[Constants.GoldenFrame])
             {
                 CompFixedRef = Constants.AltRefFrame;
-                CompVarRef[0] = Constants.LastFrame;
+                compVarRefSpan[0] = Constants.LastFrame;
-                CompVarRef[1] = Constants.GoldenFrame;
+                compVarRefSpan[1] = Constants.GoldenFrame;
             }
-            else if (RefFrameSignBias[Constants.LastFrame] == RefFrameSignBias[Constants.AltRefFrame])
+            else if (refFrameSignBiasSpan[Constants.LastFrame] == refFrameSignBiasSpan[Constants.AltRefFrame])
             {
                 CompFixedRef = Constants.GoldenFrame;
-                CompVarRef[0] = Constants.LastFrame;
+                compVarRefSpan[0] = Constants.LastFrame;
-                CompVarRef[1] = Constants.AltRefFrame;
+                compVarRefSpan[1] = Constants.AltRefFrame;
             }
             else
             {
                 CompFixedRef = Constants.LastFrame;
-                CompVarRef[0] = Constants.GoldenFrame;
+                compVarRefSpan[0] = Constants.GoldenFrame;
-                CompVarRef[1] = Constants.AltRefFrame;
+                compVarRefSpan[1] = Constants.AltRefFrame;
             }
         }
 
         public readonly void InitMvProbs()
         {
-            Fc.Value.Joints[0] = 32;
+            Span<byte> jointsSpan = Fc.Value.Joints.AsSpan();
-            Fc.Value.Joints[1] = 64;
+            Span<byte> signSpan = Fc.Value.Sign.AsSpan();
-            Fc.Value.Joints[2] = 96;
+            Span<Array10<byte>> classesSpan = Fc.Value.Classes.AsSpan();
+            Span<byte> classes0Span = classesSpan[0].AsSpan();
+            Span<byte> classes1Span = classesSpan[1].AsSpan();
+            Span<Array1<byte>> class0Span = Fc.Value.Class0.AsSpan();
+            Span<Array10<byte>> bitsSpan = Fc.Value.Bits.AsSpan();
+            Span<byte> bits0Span = bitsSpan[0].AsSpan();
+            Span<byte> bits1Span = bitsSpan[1].AsSpan();
+            Span<Array2<Array3<byte>>> class0FpSpan = Fc.Value.Class0Fp.AsSpan();
+            Span<Array3<byte>> class0Fp0Span = class0FpSpan[0].AsSpan();
+            Span<Array3<byte>> class0Fp1Span = class0FpSpan[1].AsSpan();
+            Span<byte> class0Fp00Span = class0Fp0Span[0].AsSpan();
+            Span<byte> class0Fp01Span = class0Fp0Span[1].AsSpan();
+            Span<byte> class0Fp10Span = class0Fp1Span[0].AsSpan();
+            Span<byte> class0Fp11Span = class0Fp1Span[1].AsSpan();
+            Span<Array3<byte>> fpSpan = Fc.Value.Fp.AsSpan();
+            Span<byte> fp0Span = fpSpan[0].AsSpan();
+            Span<byte> fp1Span = fpSpan[1].AsSpan();
+            Span<byte> class0HpSpan = Fc.Value.Class0Hp.AsSpan();
+            Span<byte> hpSpan = Fc.Value.Hp.AsSpan();
             
-            Fc.Value.Sign[0] = 128;
+            jointsSpan[0] = 32;
-            Fc.Value.Classes[0][0] = 224;
+            jointsSpan[1] = 64;
-            Fc.Value.Classes[0][1] = 144;
+            jointsSpan[2] = 96;
-            Fc.Value.Classes[0][2] = 192;
-            Fc.Value.Classes[0][3] = 168;
-            Fc.Value.Classes[0][4] = 192;
-            Fc.Value.Classes[0][5] = 176;
-            Fc.Value.Classes[0][6] = 192;
-            Fc.Value.Classes[0][7] = 198;
-            Fc.Value.Classes[0][8] = 198;
-            Fc.Value.Classes[0][9] = 245;
-            Fc.Value.Class0[0][0] = 216;
-            Fc.Value.Bits[0][0] = 136;
-            Fc.Value.Bits[0][1] = 140;
-            Fc.Value.Bits[0][2] = 148;
-            Fc.Value.Bits[0][3] = 160;
-            Fc.Value.Bits[0][4] = 176;
-            Fc.Value.Bits[0][5] = 192;
-            Fc.Value.Bits[0][6] = 224;
-            Fc.Value.Bits[0][7] = 234;
-            Fc.Value.Bits[0][8] = 234;
-            Fc.Value.Bits[0][9] = 240;
-            Fc.Value.Class0Fp[0][0][0] = 128;
-            Fc.Value.Class0Fp[0][0][1] = 128;
-            Fc.Value.Class0Fp[0][0][2] = 64;
-            Fc.Value.Class0Fp[0][1][0] = 96;
-            Fc.Value.Class0Fp[0][1][1] = 112;
-            Fc.Value.Class0Fp[0][1][2] = 64;
-            Fc.Value.Fp[0][0] = 64;
-            Fc.Value.Fp[0][1] = 96;
-            Fc.Value.Fp[0][2] = 64;
-            Fc.Value.Class0Hp[0] = 160;
-            Fc.Value.Hp[0] = 128;
 
-            Fc.Value.Sign[1] = 128;
+            signSpan[0] = 128;
-            Fc.Value.Classes[1][0] = 216;
+            classes0Span[0] = 224;
-            Fc.Value.Classes[1][1] = 128;
+            classes0Span[1] = 144;
-            Fc.Value.Classes[1][2] = 176;
+            classes0Span[2] = 192;
-            Fc.Value.Classes[1][3] = 160;
+            classes0Span[3] = 168;
-            Fc.Value.Classes[1][4] = 176;
+            classes0Span[4] = 192;
-            Fc.Value.Classes[1][5] = 176;
+            classes0Span[5] = 176;
-            Fc.Value.Classes[1][6] = 192;
+            classes0Span[6] = 192;
-            Fc.Value.Classes[1][7] = 198;
+            classes0Span[7] = 198;
-            Fc.Value.Classes[1][8] = 198;
+            classes0Span[8] = 198;
-            Fc.Value.Classes[1][9] = 208;
+            classes0Span[9] = 245;
-            Fc.Value.Class0[1][0] = 208;
+            class0Span[0][0] = 216;
-            Fc.Value.Bits[1][0] = 136;
+            bits0Span[0] = 136;
-            Fc.Value.Bits[1][1] = 140;
+            bits0Span[1] = 140;
-            Fc.Value.Bits[1][2] = 148;
+            bits0Span[2] = 148;
-            Fc.Value.Bits[1][3] = 160;
+            bits0Span[3] = 160;
-            Fc.Value.Bits[1][4] = 176;
+            bits0Span[4] = 176;
-            Fc.Value.Bits[1][5] = 192;
+            bits0Span[5] = 192;
-            Fc.Value.Bits[1][6] = 224;
+            bits0Span[6] = 224;
-            Fc.Value.Bits[1][7] = 234;
+            bits0Span[7] = 234;
-            Fc.Value.Bits[1][8] = 234;
+            bits0Span[8] = 234;
-            Fc.Value.Bits[1][9] = 240;
+            bits0Span[9] = 240;
-            Fc.Value.Class0Fp[1][0][0] = 128;
+            class0Fp00Span[0] = 128;
-            Fc.Value.Class0Fp[1][0][1] = 128;
+            class0Fp00Span[1] = 128;
-            Fc.Value.Class0Fp[1][0][2] = 64;
+            class0Fp00Span[2] = 64;
-            Fc.Value.Class0Fp[1][1][0] = 96;
+            class0Fp01Span[0] = 96;
-            Fc.Value.Class0Fp[1][1][1] = 112;
+            class0Fp01Span[1] = 112;
-            Fc.Value.Class0Fp[1][1][2] = 64;
+            class0Fp01Span[2] = 64;
-            Fc.Value.Fp[1][0] = 64;
+            fp0Span[0] = 64;
-            Fc.Value.Fp[1][1] = 96;
+            fp0Span[1] = 96;
-            Fc.Value.Fp[1][2] = 64;
+            fp0Span[2] = 64;
-            Fc.Value.Class0Hp[1] = 160;
+            class0HpSpan[0] = 160;
-            Fc.Value.Hp[1] = 128;
+            hpSpan[0] = 128;
+
+            signSpan[1] = 128;
+            classes1Span[0] = 216;
+            classes1Span[1] = 128;
+            classes1Span[2] = 176;
+            classes1Span[3] = 160;
+            classes1Span[4] = 176;
+            classes1Span[5] = 176;
+            classes1Span[6] = 192;
+            classes1Span[7] = 198;
+            classes1Span[8] = 198;
+            classes1Span[9] = 208;
+            class0Span[1][0] = 208;
+            bits1Span[0] = 136;
+            bits1Span[1] = 140;
+            bits1Span[2] = 148;
+            bits1Span[3] = 160;
+            bits1Span[4] = 176;
+            bits1Span[5] = 192;
+            bits1Span[6] = 224;
+            bits1Span[7] = 234;
+            bits1Span[8] = 234;
+            bits1Span[9] = 240;
+            class0Fp10Span[0] = 128;
+            class0Fp10Span[1] = 128;
+            class0Fp10Span[2] = 64;
+            class0Fp11Span[0] = 96;
+            class0Fp11Span[1] = 112;
+            class0Fp11Span[2] = 64;
+            fp1Span[0] = 64;
+            fp1Span[1] = 96;
+            fp1Span[2] = 64;
+            class0HpSpan[1] = 160;
+            hpSpan[1] = 128;
         }
 
         public void AdaptMvProbs(bool allowHp)
@@ -576,41 +629,74 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 counts.Joints.AsSpan(),
                 fc.Joints.AsSpan());
 
+            Span<byte> fSignSpan = fc.Sign.AsSpan();
+            Span<byte> pSignSpan = preFc.Sign.AsSpan();
+            Span<Array2<uint>> cSignSpan = counts.Sign.AsSpan();
+            Span<Array10<byte>> fClassesSpan = fc.Classes.AsSpan();
+            Span<Array10<byte>> pClassesSpan = preFc.Classes.AsSpan();
+            Span<Array11<uint>> cClassesSpan = counts.Classes.AsSpan();
+            Span<Array1<byte>> fClass0Span = fc.Class0.AsSpan();
+            Span<Array1<byte>> pClass0Span = preFc.Class0.AsSpan();
+            Span<Array2<uint>> cClass0Span = counts.Class0.AsSpan();
+            Span<Array10<byte>> fBitsSpan1 = fc.Bits.AsSpan();
+            Span<Array10<byte>> pBitsSpan1 = preFc.Bits.AsSpan();
+            Span<Array10<Array2<uint>>> cBitsSpan1 = counts.Bits.AsSpan();
+            Span<Array2<Array3<byte>>> fClass0FpSpan1 = fc.Class0Fp.AsSpan();
+            Span<Array2<Array3<byte>>> pClass0FpSpan1 = preFc.Class0Fp.AsSpan();
+            Span<Array2<Array4<uint>>> cClass0FpSpan1 = counts.Class0Fp.AsSpan();
+            Span<Array3<byte>> fFpSpan = fc.Fp.AsSpan();
+            Span<Array3<byte>> pFpSpan = preFc.Fp.AsSpan();
+            Span<Array4<uint>> cFpSpan = counts.Fp.AsSpan();
+            Span<byte> fClass0HpSpan = fc.Class0Hp.AsSpan();
+            Span<byte> pClass0HpSpan = preFc.Class0Hp.AsSpan();
+            Span<Array2<uint>> cClass0HpSpan = counts.Class0Hp.AsSpan();
+            Span<byte> fHpSpan = fc.Hp.AsSpan();
+            Span<byte> pHpSpan = preFc.Hp.AsSpan();
+            Span<Array2<uint>> cHpSpan = counts.Hp.AsSpan();
+
             for (int i = 0; i < 2; ++i)
             {
-                fc.Sign[i] = Prob.ModeMvMergeProbs(preFc.Sign[i], ref counts.Sign[i]);
+                fSignSpan[i] = Prob.ModeMvMergeProbs(pSignSpan[i], cSignSpan[i].AsSpan());
                 Prob.VpxTreeMergeProbs(
                     EntropyMv.ClassTree,
-                    preFc.Classes[i].AsSpan(),
+                    pClassesSpan[i].AsSpan(),
-                    counts.Classes[i].AsSpan(),
+                    cClassesSpan[i].AsSpan(),
-                    fc.Classes[i].AsSpan());
+                    fClassesSpan[i].AsSpan());
                 Prob.VpxTreeMergeProbs(
                     EntropyMv.Class0Tree,
-                    preFc.Class0[i].AsSpan(),
+                    pClass0Span[i].AsSpan(),
-                    counts.Class0[i].AsSpan(),
+                    cClass0Span[i].AsSpan(),
-                    fc.Class0[i].AsSpan());
+                    fClass0Span[i].AsSpan());
+                
+                Span<byte> fBitsSpan2 = fBitsSpan1[i].AsSpan();
+                Span<byte> pBitsSpan2 = pBitsSpan1[i].AsSpan();
+                Span<Array2<uint>> cBitsSpan2 = cBitsSpan1[i].AsSpan();
 
                 for (int j = 0; j < EntropyMv.OffsetBits; ++j)
                 {
-                    fc.Bits[i][j] = Prob.ModeMvMergeProbs(preFc.Bits[i][j], ref counts.Bits[i][j]);
+                    fBitsSpan2[j] = Prob.ModeMvMergeProbs(pBitsSpan2[j], cBitsSpan2[j].AsSpan());
                 }
 
+                Span<Array3<byte>> fClass0FpSpan2 = fClass0FpSpan1[i].AsSpan();
+                Span<Array3<byte>> pClass0FpSpan2 = pClass0FpSpan1[i].AsSpan();
+                Span<Array4<uint>> cClass0FpSpan2 = cClass0FpSpan1[i].AsSpan();
+
                 for (int j = 0; j < EntropyMv.Class0Size; ++j)
                 {
                     Prob.VpxTreeMergeProbs(
                         EntropyMv.FpTree,
-                        preFc.Class0Fp[i][j].AsSpan(),
+                        pClass0FpSpan2[j].AsSpan(),
-                        counts.Class0Fp[i][j].AsSpan(),
+                        cClass0FpSpan2[j].AsSpan(),
-                        fc.Class0Fp[i][j].AsSpan());
+                        fClass0FpSpan2[j].AsSpan());
                 }
 
-                Prob.VpxTreeMergeProbs(EntropyMv.FpTree, preFc.Fp[i].AsSpan(), counts.Fp[i].AsSpan(),
+                Prob.VpxTreeMergeProbs(EntropyMv.FpTree, pFpSpan[i].AsSpan(), cFpSpan[i].AsSpan(),
-                    fc.Fp[i].AsSpan());
+                    fFpSpan[i].AsSpan());
 
                 if (allowHp)
                 {
-                    fc.Class0Hp[i] = Prob.ModeMvMergeProbs(preFc.Class0Hp[i], ref counts.Class0Hp[i]);
+                    fClass0HpSpan[i] = Prob.ModeMvMergeProbs(pClass0HpSpan[i], cClass0HpSpan[i].AsSpan());
-                    fc.Hp[i] = Prob.ModeMvMergeProbs(preFc.Hp[i], ref counts.Hp[i]);
+                    fHpSpan[i] = Prob.ModeMvMergeProbs(pHpSpan[i], cHpSpan[i].AsSpan());
                 }
             }
         }
@@ -769,75 +855,115 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             ref Vp9EntropyProbs preFc = ref FrameContexts[(int)FrameContextIdx];
             ref Vp9BackwardUpdates counts = ref Counts.Value;
 
+            Span<byte> fIntraInterProbSpan = fc.IntraInterProb.AsSpan();
+            Span<byte> pIntraInterProbSpan = preFc.IntraInterProb.AsSpan();
+            Span<Array2<uint>> cIntraInterSpan = counts.IntraInter.AsSpan();
+
             for (int i = 0; i < Constants.IntraInterContexts; i++)
             {
-                fc.IntraInterProb[i] = Prob.ModeMvMergeProbs(preFc.IntraInterProb[i], ref counts.IntraInter[i]);
+                fIntraInterProbSpan[i] = Prob.ModeMvMergeProbs(pIntraInterProbSpan[i], cIntraInterSpan[i].AsSpan());
             }
             
+            Span<byte> fCompInterProbSpan = fc.CompInterProb.AsSpan();
+            Span<byte> pCompInterProbSpan = preFc.CompInterProb.AsSpan();
+            Span<Array2<uint>> cCompInterSpan = counts.CompInter.AsSpan();
+
             for (int i = 0; i < Constants.CompInterContexts; i++)
             {
-                fc.CompInterProb[i] = Prob.ModeMvMergeProbs(preFc.CompInterProb[i], ref counts.CompInter[i]);
+                fCompInterProbSpan[i] = Prob.ModeMvMergeProbs(pCompInterProbSpan[i], cCompInterSpan[i].AsSpan());
             }
             
+            Span<byte> fCompRefProbSpan = fc.CompRefProb.AsSpan();
+            Span<byte> pCompRefProbSpan = preFc.CompRefProb.AsSpan();
+            Span<Array2<uint>> cCompRefSpan = counts.CompRef.AsSpan();
+
             for (int i = 0; i < Constants.RefContexts; i++)
             {
-                fc.CompRefProb[i] = Prob.ModeMvMergeProbs(preFc.CompRefProb[i], ref counts.CompRef[i]);
+                fCompRefProbSpan[i] = Prob.ModeMvMergeProbs(pCompRefProbSpan[i], cCompRefSpan[i].AsSpan());
             }
             
+            Span<Array2<byte>> fSingleRefProbSpan1 = fc.SingleRefProb.AsSpan();
+            Span<Array2<byte>> pSingleRefProbSpan1 = preFc.SingleRefProb.AsSpan();
+            Span<Array2<Array2<uint>>> cSingleRefSpan1 = counts.SingleRef.AsSpan();
+
             for (int i = 0; i < Constants.RefContexts; i++)
             {
+                Span<byte> fSingleRefProbSpan2 = fSingleRefProbSpan1[i].AsSpan();
+                Span<byte> pSingleRefProbSpan2 = pSingleRefProbSpan1[i].AsSpan();
+                Span<Array2<uint>> cSingleRefSpan2 = cSingleRefSpan1[i].AsSpan();
+                
                 for (int j = 0; j < 2; j++)
                 {
-                    fc.SingleRefProb[i][j] =
+                    fSingleRefProbSpan2[j] =
-                        Prob.ModeMvMergeProbs(preFc.SingleRefProb[i][j], ref counts.SingleRef[i][j]);
+                        Prob.ModeMvMergeProbs(pSingleRefProbSpan2[j], cSingleRefSpan2[j].AsSpan());
                 }
             }
             
+            Span<Array3<byte>> fInterModeProbSpan = fc.InterModeProb.AsSpan();
+            Span<Array3<byte>> pInterModeProbSpan = preFc.InterModeProb.AsSpan();
+            Span<Array4<uint>> cInterModeSpan = counts.InterMode.AsSpan();
+
             for (int i = 0; i < Constants.InterModeContexts; i++)
             {
                 Prob.VpxTreeMergeProbs(
                     EntropyMode.InterModeTree,
-                    preFc.InterModeProb[i].AsSpan(),
+                    pInterModeProbSpan[i].AsSpan(),
-                    counts.InterMode[i].AsSpan(),
+                    cInterModeSpan[i].AsSpan(),
-                    fc.InterModeProb[i].AsSpan());
+                    fInterModeProbSpan[i].AsSpan());
             }
             
+            Span<Array9<byte>> fYModeProbSpan = fc.YModeProb.AsSpan();
+            Span<Array9<byte>> pYModeProbSpan = preFc.YModeProb.AsSpan();
+            Span<Array10<uint>> cYModeSpan = counts.YMode.AsSpan();
+
             for (int i = 0; i < EntropyMode.BlockSizeGroups; i++)
             {
                 Prob.VpxTreeMergeProbs(
                     EntropyMode.IntraModeTree,
-                    preFc.YModeProb[i].AsSpan(),
+                    pYModeProbSpan[i].AsSpan(),
-                    counts.YMode[i].AsSpan(),
+                    cYModeSpan[i].AsSpan(),
-                    fc.YModeProb[i].AsSpan());
+                    fYModeProbSpan[i].AsSpan());
             }
             
+            Span<Array9<byte>> fUvModeProbSpan = fc.UvModeProb.AsSpan();
+            Span<Array9<byte>> pUvModeProbSpan = preFc.UvModeProb.AsSpan();
+            Span<Array10<uint>> cUvModeSpan = counts.UvMode.AsSpan();
+
             for (int i = 0; i < Constants.IntraModes; ++i)
             {
                 Prob.VpxTreeMergeProbs(
                     EntropyMode.IntraModeTree,
-                    preFc.UvModeProb[i].AsSpan(),
+                    pUvModeProbSpan[i].AsSpan(),
-                    counts.UvMode[i].AsSpan(),
+                    cUvModeSpan[i].AsSpan(),
-                    fc.UvModeProb[i].AsSpan());
+                    fUvModeProbSpan[i].AsSpan());
             }
             
+            Span<Array3<byte>> fPartitionProbSpan = fc.PartitionProb.AsSpan();
+            Span<Array3<byte>> pPartitionProbSpan = preFc.PartitionProb.AsSpan();
+            Span<Array4<uint>> cPartitionSpan = counts.Partition.AsSpan();
+
             for (int i = 0; i < Constants.PartitionContexts; i++)
             {
                 Prob.VpxTreeMergeProbs(
                     EntropyMode.PartitionTree,
-                    preFc.PartitionProb[i].AsSpan(),
+                    pPartitionProbSpan[i].AsSpan(),
-                    counts.Partition[i].AsSpan(),
+                    cPartitionSpan[i].AsSpan(),
-                    fc.PartitionProb[i].AsSpan());
+                    fPartitionProbSpan[i].AsSpan());
             }
 
             if (InterpFilter == Constants.Switchable)
             {
+                Span<Array2<byte>> fSwitchableInterpProbSpan = fc.SwitchableInterpProb.AsSpan();
+                Span<Array2<byte>> pSwitchableInterpProbSpan = preFc.SwitchableInterpProb.AsSpan();
+                Span<Array3<uint>> cSwitchableInterpSpan = counts.SwitchableInterp.AsSpan();
+                
                 for (int i = 0; i < Constants.SwitchableFilterContexts; i++)
                 {
                     Prob.VpxTreeMergeProbs(
                         EntropyMode.SwitchableInterpTree,
-                        preFc.SwitchableInterpProb[i].AsSpan(),
+                        pSwitchableInterpProbSpan[i].AsSpan(),
-                        counts.SwitchableInterp[i].AsSpan(),
+                        cSwitchableInterpSpan[i].AsSpan(),
-                        fc.SwitchableInterpProb[i].AsSpan());
+                        fSwitchableInterpProbSpan[i].AsSpan());
                 }
             }
 
@@ -847,33 +973,61 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 Array2<Array2<uint>> branchCt16X16P = new();
                 Array3<Array2<uint>> branchCt32X32P = new();
                 
+                Span<Array2<uint>> branchCt8X8PSpan = branchCt8X8P.AsSpan();
+                Span<Array2<uint>> branchCt16X16PSpan = branchCt16X16P.AsSpan();
+                Span<Array2<uint>> branchCt32X32PSpan = branchCt32X32P.AsSpan();
+                
+                Span<Array2<uint>> tx8x8Span = counts.Tx8x8.AsSpan();
+                Span<Array2<uint>> tx16x16Span = counts.Tx8x8.AsSpan();
+                Span<Array2<uint>> tx32x32Span = counts.Tx8x8.AsSpan();
+
+                //There is no need for a Span2, as there is only ever 1 iteration
+                Span<Array1<byte>> fTx8x8ProbSpan = fc.Tx8x8Prob.AsSpan();
+                Span<Array1<byte>> pTx8x8ProbSpan = preFc.Tx8x8Prob.AsSpan();
+                
+                Span<Array2<byte>> fTx16x16ProbSpan1 = fc.Tx16x16Prob.AsSpan();
+                Span<Array2<byte>> pTx16x16ProbSpan1 = preFc.Tx16x16Prob.AsSpan();
+                
+                Span<Array3<byte>> fTx32x32ProbSpan1 = fc.Tx32x32Prob.AsSpan();
+                Span<Array3<byte>> pTx32x32ProbSpan1 = preFc.Tx32x32Prob.AsSpan();
+
                 for (int i = 0; i < EntropyMode.TxSizeContexts; ++i)
                 {
-                    EntropyMode.TxCountsToBranchCounts8X8(counts.Tx8x8[i].AsSpan(), ref branchCt8X8P);
+                    EntropyMode.TxCountsToBranchCounts8X8(tx8x8Span[i].AsSpan(), branchCt8X8P.AsSpan());
                     for (int j = 0; j < (int)TxSize.TxSizes - 3; ++j)
                     {
-                        fc.Tx8x8Prob[i][j] = Prob.ModeMvMergeProbs(preFc.Tx8x8Prob[i][j], ref branchCt8X8P[j]);
+                        fTx8x8ProbSpan[i][j] = Prob.ModeMvMergeProbs(pTx8x8ProbSpan[i][j], branchCt8X8PSpan[j].AsSpan());
                     }
                     
-                    EntropyMode.TxCountsToBranchCounts16X16(counts.Tx16x16[i].AsSpan(), ref branchCt16X16P);
+                    Span<byte> fTx16x16ProbSpan2 = fTx16x16ProbSpan1[i].AsSpan();
+                    Span<byte> pTx16x16ProbSpan2 = pTx16x16ProbSpan1[i].AsSpan();
+
+                    EntropyMode.TxCountsToBranchCounts16X16(tx16x16Span[i].AsSpan(), branchCt16X16P.AsSpan());
                     for (int j = 0; j < (int)TxSize.TxSizes - 2; ++j)
                     {
-                        fc.Tx16x16Prob[i][j] =
+                        fTx16x16ProbSpan2[j] =
-                            Prob.ModeMvMergeProbs(preFc.Tx16x16Prob[i][j], ref branchCt16X16P[j]);
+                            Prob.ModeMvMergeProbs(pTx16x16ProbSpan2[j], branchCt16X16PSpan[j].AsSpan());
                     }
                     
-                    EntropyMode.TxCountsToBranchCounts32X32(counts.Tx32x32[i].AsSpan(), ref branchCt32X32P);
+                    Span<byte> fTx32x32ProbSpan2 = fTx32x32ProbSpan1[i].AsSpan();
+                    Span<byte> pTx32x32ProbSpan2 = pTx32x32ProbSpan1[i].AsSpan();
+
+                    EntropyMode.TxCountsToBranchCounts32X32(tx32x32Span[i].AsSpan(), branchCt32X32P.AsSpan());
                     for (int j = 0; j < (int)TxSize.TxSizes - 1; ++j)
                     {
-                        fc.Tx32x32Prob[i][j] =
+                        fTx32x32ProbSpan2[j] =
-                            Prob.ModeMvMergeProbs(preFc.Tx32x32Prob[i][j], ref branchCt32X32P[j]);
+                            Prob.ModeMvMergeProbs(pTx32x32ProbSpan2[j], branchCt32X32PSpan[j].AsSpan());
                     }
                 }
             }
             
+            Span<byte> fSkipProbSpan = fc.SkipProb.AsSpan();
+            Span<byte> pSkipProbSpan = preFc.SkipProb.AsSpan();
+            Span<Array2<uint>> cSkipSpan = counts.Skip.AsSpan();
+
             for (int i = 0; i < Constants.SkipContexts; ++i)
             {
-                fc.SkipProb[i] = Prob.ModeMvMergeProbs(preFc.SkipProb[i], ref counts.Skip[i]);
+                fSkipProbSpan[i] = Prob.ModeMvMergeProbs(pSkipProbSpan[i], cSkipSpan[i].AsSpan());
             }
         }
 
@@ -916,13 +1070,19 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             {
                 ref MvRef mv = ref PrevFrameMvs[i];
 
-                mv.Mv[0].Row = mvs[i].Mvs[0].Row;
+                Span<Mv> mvSpan = mv.Mv.AsSpan();
-                mv.Mv[0].Col = mvs[i].Mvs[0].Col;
+                Span<Vp9Mv> mvsSpan = mvs[i].Mvs.AsSpan();
-                mv.Mv[1].Row = mvs[i].Mvs[1].Row;
-                mv.Mv[1].Col = mvs[i].Mvs[1].Col;
 
-                mv.RefFrame[0] = (sbyte)mvs[i].RefFrames[0];
+                mvSpan[0].Row = mvsSpan[0].Row;
-                mv.RefFrame[1] = (sbyte)mvs[i].RefFrames[1];
+                mvSpan[0].Col = mvsSpan[0].Col;
+                mvSpan[1].Row = mvsSpan[1].Row;
+                mvSpan[1].Col = mvsSpan[1].Col;
+
+                Span<sbyte> refFrameSpan = mv.RefFrame.AsSpan();
+                Span<int> refFramesSpan = mvs[i].RefFrames.AsSpan();
+                
+                refFrameSpan[0] = (sbyte)refFramesSpan[0];
+                refFrameSpan[1] = (sbyte)refFramesSpan[1];
             }
         }
 
@@ -938,46 +1098,75 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             {
                 ref MvRef mv = ref CurFrameMvs[i];
                 
-                mvs[i].Mvs[0].Row = mv.Mv[0].Row;
+                Span<Mv> mvSpan = mv.Mv.AsSpan();
-                mvs[i].Mvs[0].Col = mv.Mv[0].Col;
+                Span<Vp9Mv> mvsSpan = mvs[i].Mvs.AsSpan();
-                mvs[i].Mvs[1].Row = mv.Mv[1].Row;
-                mvs[i].Mvs[1].Col = mv.Mv[1].Col;
 
-                mvs[i].RefFrames[0] = mv.RefFrame[0];
+                mvsSpan[0].Row = mvSpan[0].Row;
-                mvs[i].RefFrames[1] = mv.RefFrame[1];
+                mvsSpan[0].Col = mvSpan[0].Col;
+                mvsSpan[1].Row = mvSpan[1].Row;
+                mvsSpan[1].Col = mvSpan[1].Col;
+                
+                Span<sbyte> refFrameSpan = mv.RefFrame.AsSpan();
+                Span<int> refFramesSpan = mvs[i].RefFrames.AsSpan();
+
+                refFramesSpan[0] = refFrameSpan[0];
+                refFramesSpan[1] = refFrameSpan[1];
             }
         }
 
         private void AdaptCoefProbs(byte txSize, uint countSat, uint updateFactor)
         {
             ref Vp9EntropyProbs preFc = ref FrameContexts[(int)FrameContextIdx];
-            ref Array2<Array2<Array6<Array6<Array3<byte>>>>> probs = ref Fc.Value.CoefProbs[txSize];
+            Span<Array2<Array6<Array6<Array3<byte>>>>> probsSpan1 = Fc.Value.CoefProbs[txSize].AsSpan();
-            ref Array2<Array2<Array6<Array6<Array3<byte>>>>> preProbs = ref preFc.CoefProbs[txSize];
+            Span<Array2<Array6<Array6<Array3<byte>>>>> preProbsSpan1 = preFc.CoefProbs[txSize].AsSpan();
-            ref Array2<Array2<Array6<Array6<Array4<uint>>>>> counts = ref Counts.Value.Coef[txSize];
+            Span<Array2<Array6<Array6<Array4<uint>>>>> countsSpan1 = Counts.Value.Coef[txSize].AsSpan();
-            ref Array2<Array2<Array6<Array6<uint>>>> eobCounts = ref Counts.Value.EobBranch[txSize];
+            Span<Array2<Array6<Array6<uint>>>> eobCountsSpan1 = Counts.Value.EobBranch[txSize].AsSpan();
 
             for (int i = 0; i < Constants.PlaneTypes; ++i)
             {
+                Span<Array6<Array6<Array3<byte>>>> probsSpan2 = probsSpan1[i].AsSpan();
+                Span<Array6<Array6<Array3<byte>>>> preProbsSpan2 = preProbsSpan1[i].AsSpan();
+                Span<Array6<Array6<Array4<uint>>>> countsSpan2 = countsSpan1[i].AsSpan();
+                Span<Array6<Array6<uint>>> eobCountsSpan2 = eobCountsSpan1[i].AsSpan();
+                
                 for (int j = 0; j < Entropy.RefTypes; ++j)
                 {
+                    Span<Array6<Array3<byte>>> probsSpan3 = probsSpan2[j].AsSpan();
+                    Span<Array6<Array3<byte>>> preProbsSpan3 = preProbsSpan2[j].AsSpan();
+                    Span<Array6<Array4<uint>>> countsSpan3 = countsSpan2[j].AsSpan();
+                    Span<Array6<uint>> eobCountsSpan3 = eobCountsSpan2[j].AsSpan();
+                    
                     for (int k = 0; k < Entropy.CoefBands; ++k)
                     {
+                        Span<Array3<byte>> probsSpan4 = probsSpan3[k].AsSpan();
+                        Span<Array3<byte>> preProbsSpan4 = preProbsSpan3[k].AsSpan();
+                        Span<Array4<uint>> countsSpan4 = countsSpan3[k].AsSpan();
+                        Span<uint> eobCountsSpan4 = eobCountsSpan3[k].AsSpan();
+                        
                         for (int l = 0; l < Entropy.BAND_COEFF_CONTEXTS(k); ++l)
                         {
-                            int n0 = (int)counts[i][j][k][l][Entropy.ZeroToken];
+                            Span<byte> probsSpan5 = probsSpan4[l].AsSpan();
-                            int n1 = (int)counts[i][j][k][l][Entropy.OneToken];
+                            Span<byte> preProbsSpan5 = preProbsSpan4[l].AsSpan();
-                            int n2 = (int)counts[i][j][k][l][Entropy.TwoToken];
+                            Span<uint> countsSpan5 = countsSpan4[l].AsSpan();
-                            int neob = (int)counts[i][j][k][l][Entropy.EobModelToken];
+                            
+                            int n0 = (int)countsSpan5[Entropy.ZeroToken];
+                            int n1 = (int)countsSpan5[Entropy.OneToken];
+                            int n2 = (int)countsSpan5[Entropy.TwoToken];
+                            int neob = (int)countsSpan5[Entropy.EobModelToken];
                             Array3<Array2<uint>> branchCt = new();
-                            branchCt[0][0] = (uint)neob;
+                            Span<Array2<uint>> branchCtSpan = branchCt.AsSpan();
-                            branchCt[0][1] = (uint)(eobCounts[i][j][k][l] - neob);
+                            Span<uint> branchCt0Span = branchCtSpan[0].AsSpan();
-                            branchCt[1][0] = (uint)n0;
+                            Span<uint> branchCt1Span = branchCtSpan[1].AsSpan();
-                            branchCt[1][1] = (uint)(n1 + n2);
+                            Span<uint> branchCt2Span = branchCtSpan[2].AsSpan();
-                            branchCt[2][0] = (uint)n1;
+                            branchCt0Span[0] = (uint)neob;
-                            branchCt[2][1] = (uint)n2;
+                            branchCt0Span[1] = (uint)(eobCountsSpan4[l] - neob);
+                            branchCt1Span[0] = (uint)n0;
+                            branchCt1Span[1] = (uint)(n1 + n2);
+                            branchCt2Span[0] = (uint)n1;
+                            branchCt2Span[1] = (uint)n2;
                             for (int m = 0; m < Entropy.UnconstrainedNodes; ++m)
                             {
-                                probs[i][j][k][l][m] = Prob.MergeProbs(preProbs[i][j][k][l][m], ref branchCt[m],
+                                probsSpan5[m] = Prob.MergeProbs(preProbsSpan5[m], branchCt[m].AsSpan(),
                                     countSat, updateFactor);
                             }
                         }

src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Decoder.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Nvdec.Vp9.Common;
 using Ryujinx.Graphics.Video;
+using System;
 using System.Diagnostics;
 
 namespace Ryujinx.Graphics.Nvdec.Vp9.Types
@@ -16,20 +17,20 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public int NeedResync; // Wait for key/intra-only frame.
         public int HoldRefBuf; // Hold the reference buffer.
 
-        private static void DecreaseRefCount(int idx, ref Array12<RefCntBuffer> frameBufs, ref BufferPool pool)
+        private static void DecreaseRefCount(int idx, Span<RefCntBuffer> frameBuffs, ref BufferPool pool)
         {
-            if (idx >= 0 && frameBufs[idx].RefCount > 0)
+            if (idx >= 0 && frameBuffs[idx].RefCount > 0)
             {
-                --frameBufs[idx].RefCount;
+                --frameBuffs[idx].RefCount;
                 // A worker may only get a free framebuffer index when calling GetFreeFb.
                 // But the private buffer is not set up until finish decoding header.
                 // So any error happens during decoding header, the frame_bufs will not
                 // have valid priv buffer.
-                if (frameBufs[idx].Released == 0 && frameBufs[idx].RefCount == 0 &&
+                if (frameBuffs[idx].Released == 0 && frameBuffs[idx].RefCount == 0 &&
-                    !frameBufs[idx].RawFrameBuffer.Priv.IsNull)
+                    !frameBuffs[idx].RawFrameBuffer.Priv.IsNull)
                 {
-                    FrameBuffers.ReleaseFrameBuffer(pool.CbPriv, ref frameBufs[idx].RawFrameBuffer);
+                    FrameBuffers.ReleaseFrameBuffer(pool.CbPriv, ref frameBuffs[idx].RawFrameBuffer);
-                    frameBufs[idx].Released = 1;
+                    frameBuffs[idx].Released = 1;
                 }
             }
         }
@@ -43,22 +44,32 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             cm.CheckMemError(ref cm.FrameContexts,
                 allocator.Allocate<Vp9EntropyProbs>(Constants.FrameContexts));
 
+            Span<Array10<Array9<byte>>> cKfYModeProbSpan1 = cm.Fc.Value.KfYModeProb.AsSpan();
+            
             for (int i = 0; i < EntropyMode.KfYModeProb.Length; i++)
             {
+                Span<Array9<byte>> cKfYModeProbSpan2 = cKfYModeProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < EntropyMode.KfYModeProb[i].Length; j++)
                 {
+                    Span<byte> cKfYModeProbSpan3 = cKfYModeProbSpan2[j].AsSpan();
+                    
                     for (int k = 0; k < EntropyMode.KfYModeProb[i][j].Length; k++)
                     {
-                        cm.Fc.Value.KfYModeProb[i][j][k] = EntropyMode.KfYModeProb[i][j][k];
+                        cKfYModeProbSpan3[k] = EntropyMode.KfYModeProb[i][j][k];
                     }
                 }
             }
             
+            Span<Array9<byte>> cKfUvModeProbSpan1 = cm.Fc.Value.KfUvModeProb.AsSpan();
+
             for (int i = 0; i < EntropyMode.KfUvModeProb.Length; i++)
             {
+                Span<byte> cKfUvModeProbSpan2 = cKfUvModeProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < EntropyMode.KfUvModeProb[i].Length; j++)
                 {
-                    cm.Fc.Value.KfUvModeProb[i][j] = EntropyMode.KfUvModeProb[i][j];
+                    cKfUvModeProbSpan2[j] = EntropyMode.KfUvModeProb[i][j];
                 }
             }
 
@@ -89,11 +100,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 [12, 3, 3] // a/l both split
             ];
             
+            Span<Array3<byte>> cKfPartitionProbSpan1 = cm.Fc.Value.KfPartitionProb.AsSpan();
+
             for (int i = 0; i < kfPartitionProbs.Length; i++)
             {
+                Span<byte> cKfPartitionProbSpan2 = cKfPartitionProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < kfPartitionProbs[i].Length; j++)
                 {
-                    cm.Fc.Value.KfPartitionProb[i][j] = kfPartitionProbs[i][j];
+                    cKfPartitionProbSpan2[j] = kfPartitionProbs[i][j];
                 }
             }
 
@@ -101,11 +116,14 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
             NeedResync = 1;
 
+            Span<int> refFrameMapSpan = cm.RefFrameMap.AsSpan();
+            Span<int> nextRefFrameMapSpan = cm.NextRefFrameMap.AsSpan();
+
             // Initialize the references to not point to any frame buffers.
             for (int i = 0; i < 8; i++)
             {
-                cm.RefFrameMap[i] = -1;
+                refFrameMapSpan[i] = -1;
-                cm.NextRefFrameMap[i] = -1;
+                nextRefFrameMapSpan[i] = -1;
             }
 
             cm.CurrentVideoFrame = 0;
@@ -124,30 +142,34 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             int refIndex = 0, mask;
             ref Vp9Common cm = ref Common;
             ref BufferPool pool = ref cm.BufferPool.Value;
-            ref Array12<RefCntBuffer> frameBufs = ref cm.BufferPool.Value.FrameBufs;
+            Span<RefCntBuffer> frameBufs = cm.BufferPool.Value.FrameBufs.AsSpan();
+            
+            Span<int> refFrameMapSpan = cm.RefFrameMap.AsSpan();
+            Span<int> nextRefFrameMapSpan = cm.NextRefFrameMap.AsSpan();
+            Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
 
             for (mask = RefreshFrameFlags; mask != 0; mask >>= 1)
             {
-                int oldIdx = cm.RefFrameMap[refIndex];
+                int oldIdx = refFrameMapSpan[refIndex];
                 // Current thread releases the holding of reference frame.
-                DecreaseRefCount(oldIdx, ref frameBufs, ref pool);
+                DecreaseRefCount(oldIdx, frameBufs, ref pool);
 
                 // Release the reference frame in reference map.
                 if ((mask & 1) != 0)
                 {
-                    DecreaseRefCount(oldIdx, ref frameBufs, ref pool);
+                    DecreaseRefCount(oldIdx, frameBufs, ref pool);
                 }
 
-                cm.RefFrameMap[refIndex] = cm.NextRefFrameMap[refIndex];
+                refFrameMapSpan[refIndex] = nextRefFrameMapSpan[refIndex];
                 ++refIndex;
             }
 
             // Current thread releases the holding of reference frame.
             for (; refIndex < Constants.RefFrames && cm.ShowExistingFrame == 0; ++refIndex)
             {
-                int oldIdx = cm.RefFrameMap[refIndex];
+                int oldIdx = refFrameMapSpan[refIndex];
-                DecreaseRefCount(oldIdx, ref frameBufs, ref pool);
+                DecreaseRefCount(oldIdx, frameBufs, ref pool);
-                cm.RefFrameMap[refIndex] = cm.NextRefFrameMap[refIndex];
+                refFrameMapSpan[refIndex] = nextRefFrameMapSpan[refIndex];
             }
 
             HoldRefBuf = 0;
@@ -158,7 +180,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             // Invalidate these references until the next frame starts.
             for (refIndex = 0; refIndex < 3; refIndex++)
             {
-                cm.FrameRefs[refIndex].Idx = RefBuffer.InvalidIdx;
+                frameRefsSpan[refIndex].Idx = RefBuffer.InvalidIdx;
             }
         }
 
@@ -166,7 +188,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         {
             ref Vp9Common cm = ref Common;
             ref BufferPool pool = ref cm.BufferPool.Value;
-            ref Array12<RefCntBuffer> frameBufs = ref cm.BufferPool.Value.FrameBufs;
+            Span<RefCntBuffer> frameBufs = cm.BufferPool.Value.FrameBufs.AsSpan();
             ArrayPtr<byte> source = psource;
             CodecErr retcode = 0;
             cm.Error.ErrorCode = CodecErr.Ok;
@@ -178,9 +200,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 // any of the reference buffers, but we act conservative and
                 // mark only the last buffer as corrupted.
                 
-                if (cm.FrameRefs[0].Idx > 0)
+                Span<RefBuffer> frameRefsSpan = cm.FrameRefs.AsSpan();
+
+                if (frameRefsSpan[0].Idx > 0)
                 {
-                    cm.FrameRefs[0].Buf.Corrupted = 1;
+                    frameRefsSpan[0].Buf.Corrupted = 1;
                 }
             }
 
@@ -279,8 +303,9 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             ArrayPtr<byte> dataStart = data;
             CodecErr res;
             Array8<uint> frameSizes = new();
+            Span<uint> frameSizesSpan = frameSizes.AsSpan();
             
-            res = Decoder.ParseSuperframeIndex(data, (ulong)data.Length, ref frameSizes, out int frameCount);
+            res = Decoder.ParseSuperframeIndex(data, (ulong)data.Length, frameSizesSpan, out int frameCount);
             if (res != CodecErr.Ok)
             {
                 return res;
@@ -292,7 +317,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 for (int i = 0; i < frameCount; ++i)
                 {
                     ArrayPtr<byte> dataStartCopy = dataStart;
-                    uint frameSize = frameSizes[i];
+                    uint frameSize = frameSizesSpan[i];
                     if (frameSize > (uint)dataStart.Length)
                     {
                         return CodecErr.CorruptFrame;
@@ -343,7 +368,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             return data[0];
         }
 
-        public static CodecErr ParseSuperframeIndex(ArrayPtr<byte> data, ulong dataSz, ref Array8<uint> sizes, out int count)
+        public static CodecErr ParseSuperframeIndex(ArrayPtr<byte> data, ulong dataSz, Span<uint> sizes, out int count)
         {
             // A chunk ending with a byte matching 0xc0 is an invalid chunk unless
             // it is a super frame index. If the last byte of real video compression

src/Ryujinx.Graphics.Nvdec/Types/Vp9/BackwardUpdates.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Video;
+using System;
 
 namespace Ryujinx.Graphics.Nvdec.Types.Vp9
 {
@@ -34,14 +35,23 @@ namespace Ryujinx.Graphics.Nvdec.Types.Vp9
         {
             InterModeCounts = new Array7<Array3<Array2<uint>>>();
             
+            Span<Array3<Array2<uint>>> interModeCountsSpan1 = InterModeCounts.AsSpan();
+            Span<Array4<uint>> interModeSpan1 = counts.InterMode.AsSpan();
+
             for (int i = 0; i < 7; i++)
             {
-                InterModeCounts[i][0][0] = counts.InterMode[i][2];
+                Span<Array2<uint>> interModeCountsSpan2 = interModeCountsSpan1[i].AsSpan();
-                InterModeCounts[i][0][1] = counts.InterMode[i][0] + counts.InterMode[i][1] + counts.InterMode[i][3];
+                Span<uint> interModeCountsSpan20 = interModeCountsSpan2[0].AsSpan();
-                InterModeCounts[i][1][0] = counts.InterMode[i][0];
+                Span<uint> interModeCountsSpan21 = interModeCountsSpan2[1].AsSpan();
-                InterModeCounts[i][1][1] = counts.InterMode[i][1] + counts.InterMode[i][3];
+                Span<uint> interModeCountsSpan22 = interModeCountsSpan2[2].AsSpan();
-                InterModeCounts[i][2][0] = counts.InterMode[i][1];
+                Span<uint> interModeSpan2 = interModeSpan1[i].AsSpan();
-                InterModeCounts[i][2][1] = counts.InterMode[i][3];
+                
+                interModeCountsSpan20[0] = interModeSpan2[2];
+                interModeCountsSpan20[1] = interModeSpan2[0] + interModeSpan2[1] + interModeSpan2[3];
+                interModeCountsSpan21[0] = interModeSpan2[0];
+                interModeCountsSpan21[1] = interModeSpan2[1] + interModeSpan2[3];
+                interModeCountsSpan22[0] = interModeSpan2[1];
+                interModeCountsSpan22[1] = interModeSpan2[3];
             }
 
             YModeCounts = counts.YMode;

src/Ryujinx.Graphics.Nvdec/Types/Vp9/EntropyProbs.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Video;
+using System;
 
 namespace Ryujinx.Graphics.Nvdec.Types.Vp9
 {
@@ -46,13 +47,22 @@ namespace Ryujinx.Graphics.Nvdec.Types.Vp9
 
         public void Convert(ref Vp9EntropyProbs fc)
         {
+            Span<Array10<Array9<byte>>> kfYModeProbSpan1 = fc.KfYModeProb.AsSpan();
+            Span<Array10<Array8<byte>>> kfYModeProbE0ToE7Span1 = KfYModeProbE0ToE7.AsSpan();
+            
             for (int i = 0; i < 10; i++)
             {
+                Span<Array9<byte>> kfYModeProbSpan2 = kfYModeProbSpan1[i].AsSpan();
+                Span<Array8<byte>> kfYModeProbE0ToE7Span2 = kfYModeProbE0ToE7Span1[i].AsSpan();
+                
                 for (int j = 0; j < 10; j++)
                 {
+                    Span<byte> kfYModeProbSpan3 = kfYModeProbSpan2[j].AsSpan();
+                    Span<byte> kfYModeProbE0ToE7Span3 = kfYModeProbE0ToE7Span2[j].AsSpan();
+                    
                     for (int k = 0; k < 9; k++)
                     {
-                        fc.KfYModeProb[i][j][k] = k < 8 ? KfYModeProbE0ToE7[i][j][k] : KfYModeProbE8[i][j];
+                        kfYModeProbSpan3[k] = k < 8 ? kfYModeProbE0ToE7Span3[k] : KfYModeProbE8[i][j];
                     }
                 }
             }
@@ -60,22 +70,38 @@ namespace Ryujinx.Graphics.Nvdec.Types.Vp9
             fc.SegTreeProb = SegTreeProbs;
             fc.SegPredProb = SegPredProbs;
             
+            Span<Array3<byte>> interModeProbSpan1 = fc.InterModeProb.AsSpan();
+            Span<Array4<byte>> gInterModeProbSpan1 = InterModeProb.AsSpan();
+
             for (int i = 0; i < 7; i++)
             {
+                Span<byte> interModeProbSpan2 = interModeProbSpan1[i].AsSpan();
+                Span<byte> gInterModeProbSpan2 = gInterModeProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < 3; j++)
                 {
-                    fc.InterModeProb[i][j] = InterModeProb[i][j];
+                    interModeProbSpan2[j] = gInterModeProbSpan2[j];
                 }
             }
 
             fc.IntraInterProb = IntraInterProb;
 
+            Span<Array9<byte>> kfUvModeProbSpan1 = fc.KfUvModeProb.AsSpan();
+            Span<Array8<byte>> kfUvModeProbE0ToE7Span1 = KfUvModeProbE0ToE7.AsSpan();
+            Span<Array9<byte>> uvModeProbSpan1 = fc.UvModeProb.AsSpan();
+            Span<Array8<byte>> uvModeProbE0ToE7Span1 = UvModeProbE0ToE7.AsSpan();
+            
             for (int i = 0; i < 10; i++)
             {
+                Span<byte> kfUvModeProbSpan2 = kfUvModeProbSpan1[i].AsSpan();
+                Span<byte> kfUvModeProbE0ToE7Span2 = kfUvModeProbE0ToE7Span1[i].AsSpan();
+                Span<byte> uvModeProbSpan2 = uvModeProbSpan1[i].AsSpan();
+                Span<byte> uvModeProbE0ToE7Span2 = uvModeProbE0ToE7Span1[i].AsSpan();
+                
                 for (int j = 0; j < 9; j++)
                 {
-                    fc.KfUvModeProb[i][j] = j < 8 ? KfUvModeProbE0ToE7[i][j] : KfUvModeProbE8[i];
+                    kfUvModeProbSpan2[j] = j < 8 ? kfUvModeProbE0ToE7Span2[j] : KfUvModeProbE8[i];
-                    fc.UvModeProb[i][j] = j < 8 ? UvModeProbE0ToE7[i][j] : UvModeProbE8[i];
+                    uvModeProbSpan2[j] = j < 8 ? uvModeProbE0ToE7Span2[j] : UvModeProbE8[i];
                 }
             }
 
@@ -83,20 +109,36 @@ namespace Ryujinx.Graphics.Nvdec.Types.Vp9
             fc.Tx16x16Prob = Tx16x16Prob;
             fc.Tx32x32Prob = Tx32x32Prob;
             
+            Span<Array9<byte>> yModeProbSpan1 = fc.YModeProb.AsSpan();
+            Span<Array8<byte>> yModeProbE0ToE7Span1 = YModeProbE0ToE7.AsSpan();
+
             for (int i = 0; i < 4; i++)
             {
+                Span<byte> yModeProbSpan2 = yModeProbSpan1[i].AsSpan();
+                Span<byte> yModeProbE0ToE7Span2 = yModeProbE0ToE7Span1[i].AsSpan();
+                
                 for (int j = 0; j < 9; j++)
                 {
-                    fc.YModeProb[i][j] = j < 8 ? YModeProbE0ToE7[i][j] : YModeProbE8[i];
+                    yModeProbSpan2[j] = j < 8 ? yModeProbE0ToE7Span2[j] : YModeProbE8[i];
                 }
             }
             
+            Span<Array3<byte>> kfPartitionProbSpan1 = fc.KfPartitionProb.AsSpan();
+            Span<Array4<byte>> gKfPartitionProbSpan1 = KfPartitionProb.AsSpan();
+            Span<Array3<byte>> partitionProbSpan1 = fc.PartitionProb.AsSpan();
+            Span<Array4<byte>> gPartitionProbSpan1 = PartitionProb.AsSpan();
+
             for (int i = 0; i < 16; i++)
             {
+                Span<byte> kfPartitionProbSpan2 = kfPartitionProbSpan1[i].AsSpan();
+                Span<byte> gKfPartitionProbSpan2 = gKfPartitionProbSpan1[i].AsSpan();
+                Span<byte> partitionProbSpan2 = partitionProbSpan1[i].AsSpan();
+                Span<byte> gPartitionProbSpan2 = gPartitionProbSpan1[i].AsSpan();
+                
                 for (int j = 0; j < 3; j++)
                 {
-                    fc.KfPartitionProb[i][j] = KfPartitionProb[i][j];
+                    kfPartitionProbSpan2[j] = gKfPartitionProbSpan2[j];
-                    fc.PartitionProb[i][j] = PartitionProb[i][j];
+                    partitionProbSpan2[j] = gPartitionProbSpan2[j];
                 }
             }
 
@@ -117,19 +159,37 @@ namespace Ryujinx.Graphics.Nvdec.Types.Vp9
             fc.SingleRefProb = SingleRefProb;
             fc.CompRefProb = CompRefProb;
             
+            Span<Array2<Array2<Array6<Array6<Array3<byte>>>>>> coefProbsSpan1 = fc.CoefProbs.AsSpan();
+            Span<Array2<Array2<Array6<Array6<Array4<byte>>>>>> gCoefProbsSpan1 = CoefProbs.AsSpan();
+
             for (int i = 0; i < 4; i++)
             {
+                Span<Array2<Array6<Array6<Array3<byte>>>>> coefProbsSpan2 = coefProbsSpan1[i].AsSpan();
+                Span<Array2<Array6<Array6<Array4<byte>>>>> gCoefProbsSpan2 = gCoefProbsSpan1[i].AsSpan();
+                
                 for (int j = 0; j < 2; j++)
                 {
+                    Span<Array6<Array6<Array3<byte>>>> coefProbsSpan3 = coefProbsSpan2[j].AsSpan();
+                    Span<Array6<Array6<Array4<byte>>>> gCoefProbsSpan3 = gCoefProbsSpan2[j].AsSpan();
+                    
                     for (int k = 0; k < 2; k++)
                     {
+                        Span<Array6<Array3<byte>>> coefProbsSpan4 = coefProbsSpan3[k].AsSpan();
+                        Span<Array6<Array4<byte>>> gCoefProbsSpan4 = gCoefProbsSpan3[k].AsSpan();
+                        
                         for (int l = 0; l < 6; l++)
                         {
+                            Span<Array3<byte>> coefProbsSpan5 = coefProbsSpan4[l].AsSpan();
+                            Span<Array4<byte>> gCoefProbsSpan5 = gCoefProbsSpan4[l].AsSpan();
+                            
                             for (int m = 0; m < 6; m++)
                             {
+                                Span<byte> coefProbsSpan6 = coefProbsSpan5[m].AsSpan();
+                                Span<byte> gCoefProbsSpan6 = gCoefProbsSpan5[m].AsSpan();
+                                
                                 for (int n = 0; n < 3; n++)
                                 {
-                                    fc.CoefProbs[i][j][k][l][m][n] = CoefProbs[i][j][k][l][m][n];
+                                    coefProbsSpan6[n] = gCoefProbsSpan6[n];
                                 }
                             }
                         }

src/Ryujinx.Graphics.Shader/AttributeType.cs

@@ -3,6 +3,7 @@ using System;
 
 namespace Ryujinx.Graphics.Shader
 {
+    [Flags]
     public enum AttributeType : byte
     {
         // Generic types.

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

@@ -17,12 +17,12 @@ namespace Ryujinx.Graphics.Vic.Image
             ResourceManager rm,
             ref SlotConfig config,
             ref SlotSurfaceConfig surfaceConfig,
-            ref Array8<PlaneOffsets> offsets)
+            Span<PlaneOffsets> offsets)
         {
             switch (surfaceConfig.SlotPixelFormat)
             {
                 case PixelFormat.Y8___V8U8_N420:
-                    return ReadNv12(rm, ref config, ref surfaceConfig, ref offsets);
+                    return ReadNv12(rm, ref config, ref surfaceConfig, offsets);
             }
 
             Logger.Error?.Print(LogClass.Vic, $"Unsupported pixel format \"{surfaceConfig.SlotPixelFormat}\".");
@@ -37,9 +37,9 @@ namespace Ryujinx.Graphics.Vic.Image
             ResourceManager rm,
             ref SlotConfig config,
             ref SlotSurfaceConfig surfaceConfig,
-            ref Array8<PlaneOffsets> offsets)
+            Span<PlaneOffsets> offsets)
         {
-            InputSurface input = ReadSurface(rm, ref config, ref surfaceConfig, ref offsets, 1, 2);
+            InputSurface input = ReadSurface(rm, ref config, ref surfaceConfig, offsets, 1, 2);
 
             int width = input.Width;
             int height = input.Height;
@@ -273,7 +273,7 @@ namespace Ryujinx.Graphics.Vic.Image
             ResourceManager rm,
             ref SlotConfig config,
             ref SlotSurfaceConfig surfaceConfig,
-            ref Array8<PlaneOffsets> offsets,
+            Span<PlaneOffsets> offsets,
             int bytesPerPixel,
             int planes)
         {
@@ -301,17 +301,17 @@ namespace Ryujinx.Graphics.Vic.Image
 
             if (planes > 0)
             {
-                surface.SetBuffer0(ReadBuffer(rm, ref config, ref offsets, linear, 0, lw, lh, bytesPerPixel, gobBlocksInY));
+                surface.SetBuffer0(ReadBuffer(rm, ref config, offsets, linear, 0, lw, lh, bytesPerPixel, gobBlocksInY));
             }
 
             if (planes > 1)
             {
-                surface.SetBuffer1(ReadBuffer(rm, ref config, ref offsets, linear, 1, cw, ch, planes == 2 ? 2 : 1, gobBlocksInY));
+                surface.SetBuffer1(ReadBuffer(rm, ref config, offsets, linear, 1, cw, ch, planes == 2 ? 2 : 1, gobBlocksInY));
             }
 
             if (planes > 2)
             {
-                surface.SetBuffer2(ReadBuffer(rm, ref config, ref offsets, linear, 2, cw, ch, 1, gobBlocksInY));
+                surface.SetBuffer2(ReadBuffer(rm, ref config, offsets, linear, 2, cw, ch, 1, gobBlocksInY));
             }
 
             return surface;
@@ -320,7 +320,7 @@ namespace Ryujinx.Graphics.Vic.Image
         private static RentedBuffer ReadBuffer(
             ResourceManager rm,
             scoped ref SlotConfig config,
-            scoped ref Array8<PlaneOffsets> offsets,
+            Span<PlaneOffsets> offsets,
             bool linear,
             int plane,
             int width,

src/Ryujinx.Graphics.Vic/VicDevice.cs

@@ -35,18 +35,21 @@ namespace Ryujinx.Graphics.Vic
                 config.OutputSurfaceConfig.OutSurfaceWidth + 1,
                 config.OutputSurfaceConfig.OutSurfaceHeight + 1);
 
-            for (int i = 0; i < config.SlotStruct.Length; i++)
+            Span<SlotStruct> slotStructSpan = config.SlotStruct.AsSpan();
+            Span<Array8<PlaneOffsets>> setSurfacexSlotxSpan = _state.State.SetSurfacexSlotx.AsSpan();
+
+            for (int i = 0; i < slotStructSpan.Length; i++)
             {
-                ref SlotStruct slot = ref config.SlotStruct[i];
+                ref SlotStruct slot = ref slotStructSpan[i];
 
                 if (!slot.SlotConfig.SlotEnable)
                 {
                     continue;
                 }
 
-                ref Array8<PlaneOffsets> offsets = ref _state.State.SetSurfacexSlotx[i];
+                Span<PlaneOffsets> offsets = setSurfacexSlotxSpan[i].AsSpan();
 
-                using Surface src = SurfaceReader.Read(_rm, ref slot.SlotConfig, ref slot.SlotSurfaceConfig, ref offsets);
+                using Surface src = SurfaceReader.Read(_rm, ref slot.SlotConfig, ref slot.SlotSurfaceConfig, offsets);
 
                 int x1 = config.OutputConfig.TargetRectLeft;
                 int y1 = config.OutputConfig.TargetRectTop;

src/Ryujinx.Graphics.Vulkan/BitMapStruct.cs

@@ -27,12 +27,16 @@ namespace Ryujinx.Graphics.Vulkan
         {
             bool result = false;
             
-            int masks = _masks.Length;
+            Span<long> masksSpan = _masks.AsSpan();
+            Span<long> fMasksSpan = from._masks.AsSpan();
+            Span<long> iMasksSpan = into._masks.AsSpan();
+
+            int masks = masksSpan.Length;
             for (int i = 0; i < masks; i++)
             {
-                long fromMask = from._masks[i];
+                long fromMask = fMasksSpan[i];
-                long unsetMask = (~fromMask) & (fromMask ^ _masks[i]);
+                long unsetMask = (~fromMask) & (fromMask ^ masksSpan[i]);
-                into._masks[i] = unsetMask;
+                iMasksSpan[i] = unsetMask;
 
                 result |= unsetMask != 0;
             }
@@ -49,11 +53,11 @@ namespace Ryujinx.Graphics.Vulkan
                 // Iterate the set bits in the result, and signal them.
 
                 int offset = 0;
-                int masks = _masks.Length;
+                Span<long> rMasksSpan = result._masks.AsSpan();
-                ref T resultMasks = ref result._masks;
+                int masks = rMasksSpan.Length;
                 for (int i = 0; i < masks; i++)
                 {
-                    long value = resultMasks[i];
+                    long value = rMasksSpan[i];
                     while (value != 0)
                     {
                         int bit = BitOperations.TrailingZeroCount((ulong)value);
@@ -75,10 +79,11 @@ namespace Ryujinx.Graphics.Vulkan
             // Iterate the set bits in the result, and signal them.
 
             int offset = 0;
-            int masks = _masks.Length;
+            Span<long> masksSpan = _masks.AsSpan();
+            int masks = masksSpan.Length;
             for (int i = 0; i < masks; i++)
             {
-                long value = _masks[i];
+                long value = masksSpan[i];
                 while (value != 0)
                 {
                     int bit = BitOperations.TrailingZeroCount((ulong)value);
@@ -94,9 +99,11 @@ namespace Ryujinx.Graphics.Vulkan
 
         public bool AnySet()
         {
-            for (int i = 0; i < _masks.Length; i++)
+            Span<long> masksSpan = _masks.AsSpan();
+            
+            for (int i = 0; i < masksSpan.Length; i++)
             {
-                if (_masks[i] != 0)
+                if (masksSpan[i] != 0)
                 {
                     return true;
                 }
@@ -140,9 +147,11 @@ namespace Ryujinx.Graphics.Vulkan
                 return true;
             }
             
+            Span<long> masksSpan = _masks.AsSpan();
+
             for (int i = startIndex + 1; i < endIndex; i++)
             {
-                if (_masks[i] != 0)
+                if (masksSpan[i] != 0)
                 {
                     return true;
                 }
@@ -201,20 +210,22 @@ namespace Ryujinx.Graphics.Vulkan
             int endBit = end & IntMask;
             long endMask = (long)(ulong.MaxValue >> (IntMask - endBit));
             
+            Span<long> masksSpan = _masks.AsSpan();
+
             if (startIndex == endIndex)
             {
-                _masks[startIndex] |= startMask & endMask;
+                masksSpan[startIndex] |= startMask & endMask;
             }
             else
             {
-                _masks[startIndex] |= startMask;
+                masksSpan[startIndex] |= startMask;
 
                 for (int i = startIndex + 1; i < endIndex; i++)
                 {
-                    _masks[i] |= -1L;
+                    masksSpan[i] |= -1L;
                 }
 
-                _masks[endIndex] |= endMask;
+                masksSpan[endIndex] |= endMask;
             }
         }
 
@@ -222,13 +233,13 @@ namespace Ryujinx.Graphics.Vulkan
         {
             BitMapStruct<T> result = new();
 
-            ref T masks = ref _masks;
+            Span<long> masksSpan = _masks.AsSpan();
-            ref T otherMasks = ref other._masks;
+            Span<long> oMasksSpan = other._masks.AsSpan();
-            ref T newMasks = ref result._masks;
+            Span<long> nMasksSpan = result._masks.AsSpan();
 
-            for (int i = 0; i < masks.Length; i++)
+            for (int i = 0; i < masksSpan.Length; i++)
             {
-                newMasks[i] = masks[i] | otherMasks[i];
+                nMasksSpan[i] = masksSpan[i] | oMasksSpan[i];
             }
 
             return result;
@@ -246,17 +257,21 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void Clear()
         {
-            for (int i = 0; i < _masks.Length; i++)
+            Span<long> masksSpan = _masks.AsSpan();
+            
+            for (int i = 0; i < masksSpan.Length; i++)
             {
-                _masks[i] = 0;
+                masksSpan[i] = 0;
             }
         }
 
         public void ClearInt(int start, int end)
         {
+            Span<long> masksSpan = _masks.AsSpan();
+            
             for (int i = start; i <= end; i++)
             {
-                _masks[i] = 0;
+                masksSpan[i] = 0;
             }
         }
     }

src/Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs

@@ -680,7 +680,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             ShaderCollection program = _program;
 
-            if (_dirty.HasFlag(DirtyFlags.Uniform))
+            if ((_dirty & DirtyFlags.Uniform) == DirtyFlags.Uniform)
             {
                 if (program.UsePushDescriptors)
                 {
@@ -692,12 +692,12 @@ namespace Ryujinx.Graphics.Vulkan
                 }
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Storage))
+            if ((_dirty & DirtyFlags.Storage) == DirtyFlags.Storage)
             {
                 UpdateAndBind(cbs, program, PipelineBase.StorageSetIndex, pbp);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Texture))
+            if ((_dirty & DirtyFlags.Texture) == DirtyFlags.Texture)
             {
                 if (program.UpdateTexturesWithoutTemplate)
                 {
@@ -709,7 +709,7 @@ namespace Ryujinx.Graphics.Vulkan
                 }
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Image))
+            if ((_dirty & DirtyFlags.Image) == DirtyFlags.Image)
             {
                 UpdateAndBind(cbs, program, PipelineBase.ImageSetIndex, pbp);
             }

src/Ryujinx.Graphics.Vulkan/PipelineBase.cs

@@ -710,9 +710,11 @@ namespace Ryujinx.Graphics.Vulkan
 
         public void SetBlendState(AdvancedBlendDescriptor blend)
         {
+            Span<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan = _newState.Internal.ColorBlendAttachmentState.AsSpan();
+            
             for (int index = 0; index < Constants.MaxRenderTargets; index++)
             {
-                ref PipelineColorBlendAttachmentState vkBlend = ref _newState.Internal.ColorBlendAttachmentState[index];
+                ref PipelineColorBlendAttachmentState vkBlend = ref colorBlendAttachmentStateSpan[index];
 
                 if (index == 0)
                 {
@@ -986,9 +988,11 @@ namespace Ryujinx.Graphics.Vulkan
             int count = Math.Min(Constants.MaxRenderTargets, componentMask.Length);
             int writtenAttachments = 0;
             
+            Span<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan = _newState.Internal.ColorBlendAttachmentState.AsSpan();
+
             for (int i = 0; i < count; i++)
             {
-                ref PipelineColorBlendAttachmentState vkBlend = ref _newState.Internal.ColorBlendAttachmentState[i];
+                ref PipelineColorBlendAttachmentState vkBlend = ref colorBlendAttachmentStateSpan[i];
                 ColorComponentFlags newMask = (ColorComponentFlags)componentMask[i];
 
                 // When color write mask is 0, remove all blend state to help the pipeline cache.
@@ -1167,6 +1171,8 @@ namespace Ryujinx.Graphics.Vulkan
             int count = Math.Min(Constants.MaxVertexAttributes, vertexAttribs.Length);
             uint dirtyVbSizes = 0;
             
+            Span<VertexInputAttributeDescription> vertexAttributeDescriptionsSpan = _newState.Internal.VertexAttributeDescriptions.AsSpan();
+
             for (int i = 0; i < count; i++)
             {
                 VertexAttribDescriptor attribute = vertexAttribs[i];
@@ -1179,7 +1185,7 @@ namespace Ryujinx.Graphics.Vulkan
                     dirtyVbSizes |= 1u << rawIndex;
                 }
 
-                _newState.Internal.VertexAttributeDescriptions[i] = new VertexInputAttributeDescription(
+                vertexAttributeDescriptionsSpan[i] = new VertexInputAttributeDescription(
                     (uint)i,
                     (uint)bufferIndex,
                     formatCapabilities.ConvertToVertexVkFormat(attribute.Format),
@@ -1214,7 +1220,9 @@ namespace Ryujinx.Graphics.Vulkan
             int validCount = 1;
 
             BufferHandle lastHandle = default;
-            Auto<DisposableBuffer> lastBuffer = default;
+            Auto<DisposableBuffer> lastBuffer = null;
+            
+            Span<VertexInputBindingDescription> vertexBindingDescriptionsSpan = _newState.Internal.VertexBindingDescriptions.AsSpan();
 
             for (int i = 0; i < count; i++)
             {
@@ -1236,7 +1244,7 @@ namespace Ryujinx.Graphics.Vulkan
                         int binding = i + 1;
                         int descriptorIndex = validCount++;
 
-                        _newState.Internal.VertexBindingDescriptions[descriptorIndex] = new VertexInputBindingDescription(
+                        vertexBindingDescriptionsSpan[descriptorIndex] = new VertexInputBindingDescription(
                             (uint)binding,
                             (uint)vertexBuffer.Stride,
                             inputRate);
@@ -1405,6 +1413,9 @@ namespace Ryujinx.Graphics.Vulkan
 
                 // Look for textures that are masked out.
 
+                Span<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan =
+                    _newState.Internal.ColorBlendAttachmentState.AsSpan();
+
                 for (int i = 0; i < colors.Length; i++)
                 {
                     if (colors[i] == null)
@@ -1412,7 +1423,7 @@ namespace Ryujinx.Graphics.Vulkan
                         continue;
                     }
 
-                    ref PipelineColorBlendAttachmentState vkBlend = ref _newState.Internal.ColorBlendAttachmentState[i];
+                    ref PipelineColorBlendAttachmentState vkBlend = ref colorBlendAttachmentStateSpan[i];
 
                     for (int j = 0; j < i; j++)
                     {
@@ -1421,7 +1432,7 @@ namespace Ryujinx.Graphics.Vulkan
                         if (colors[i] == colors[j])
                         {
                             // Prefer the binding with no write mask.
-                            ref PipelineColorBlendAttachmentState vkBlend2 = ref _newState.Internal.ColorBlendAttachmentState[j];
+                            ref PipelineColorBlendAttachmentState vkBlend2 = ref colorBlendAttachmentStateSpan[j];
                             if (vkBlend.ColorWriteMask == 0)
                             {
                                 colors[i] = null;

src/Ryujinx.Graphics.Vulkan/PipelineConverter.cs

@@ -2,7 +2,8 @@ using Ryujinx.Common;
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
 using System;
-using Format = Silk.NET.Vulkan.Format;
+using VulkanFormat = Silk.NET.Vulkan.Format;
+using GALFormat = Ryujinx.Graphics.GAL.Format;
 using PolygonMode = Silk.NET.Vulkan.PolygonMode;
 
 namespace Ryujinx.Graphics.Vulkan
@@ -23,7 +24,7 @@ namespace Ryujinx.Graphics.Vulkan
             AttachmentReference* attachmentReferences = stackalloc AttachmentReference[MaxAttachments];
 
             Span<int> attachmentIndices = stackalloc int[MaxAttachments];
-            Span<Format> attachmentFormats = stackalloc Format[MaxAttachments];
+            Span<VulkanFormat> attachmentFormats = stackalloc VulkanFormat[MaxAttachments];
 
             int attachmentCount = 0;
             int colorCount = 0;
@@ -32,14 +33,17 @@ namespace Ryujinx.Graphics.Vulkan
             bool isNotMsOrSupportsStorage = gd.Capabilities.SupportsShaderStorageImageMultisample ||
                  !state.DepthStencilFormat.IsImageCompatible();
 
-            for (int i = 0; i < state.AttachmentEnable.Length; i++)
+            Span<bool> attachmentEnableSpan = state.AttachmentEnable.AsSpan();
+            Span<GALFormat> attachmentFormatsSpan = state.AttachmentFormats.AsSpan();
+
+            for (int i = 0; i < attachmentEnableSpan.Length; i++)
             {
-                if (state.AttachmentEnable[i])
+                if (attachmentEnableSpan[i])
                 {
                     bool isNotMsOrSupportsStorageAttachments = gd.Capabilities.SupportsShaderStorageImageMultisample ||
-                         !state.AttachmentFormats[i].IsImageCompatible();
+                         !attachmentFormatsSpan[i].IsImageCompatible();
 
-                    attachmentFormats[attachmentCount] = gd.FormatCapabilities.ConvertToVkFormat(state.AttachmentFormats[i], isNotMsOrSupportsStorageAttachments);
+                    attachmentFormats[attachmentCount] = gd.FormatCapabilities.ConvertToVkFormat(attachmentFormatsSpan[i], isNotMsOrSupportsStorageAttachments);
 
                     attachmentIndices[attachmentCount++] = i;
                     colorCount++;
@@ -222,13 +226,15 @@ namespace Ryujinx.Graphics.Vulkan
             int vbCount = Math.Min(Constants.MaxVertexBuffers, state.VertexBufferCount);
 
             Span<int> vbScalarSizes = stackalloc int[vbCount];
+            Span<VertexAttribDescriptor> vertexAttribsSpan = state.VertexAttribs.AsSpan();
+            Span<VertexInputAttributeDescription> vertexAttributeDescriptionsSpan = pipeline.Internal.VertexAttributeDescriptions.AsSpan();
 
             for (int i = 0; i < vaCount; i++)
             {
-                VertexAttribDescriptor attribute = state.VertexAttribs[i];
+                VertexAttribDescriptor attribute = vertexAttribsSpan[i];
                 int bufferIndex = attribute.IsZero ? 0 : attribute.BufferIndex + 1;
 
-                pipeline.Internal.VertexAttributeDescriptions[i] = new VertexInputAttributeDescription(
+                vertexAttributeDescriptionsSpan[i] = new VertexInputAttributeDescription(
                     (uint)i,
                     (uint)bufferIndex,
                     gd.FormatCapabilities.ConvertToVertexVkFormat(attribute.Format),
@@ -243,9 +249,12 @@ namespace Ryujinx.Graphics.Vulkan
             int descriptorIndex = 1;
             pipeline.Internal.VertexBindingDescriptions[0] = new VertexInputBindingDescription(0, 0, VertexInputRate.Vertex);
 
+            Span<BufferPipelineDescriptor> vertexBuffersSpan = state.VertexBuffers.AsSpan();
+            Span<VertexInputBindingDescription> vertexBindingDescriptionsSpan = pipeline.Internal.VertexBindingDescriptions.AsSpan();
+            
             for (int i = 0; i < vbCount; i++)
             {
-                BufferPipelineDescriptor vertexBuffer = state.VertexBuffers[i];
+                BufferPipelineDescriptor vertexBuffer = vertexBuffersSpan[i];
 
                 if (vertexBuffer.Enable)
                 {
@@ -259,7 +268,7 @@ namespace Ryujinx.Graphics.Vulkan
                     }
 
                     // TODO: Support divisor > 1
-                    pipeline.Internal.VertexBindingDescriptions[descriptorIndex++] = new VertexInputBindingDescription(
+                    vertexBindingDescriptionsSpan[descriptorIndex++] = new VertexInputBindingDescription(
                         (uint)i + 1,
                         (uint)alignedStride,
                         inputRate);
@@ -268,15 +277,19 @@ namespace Ryujinx.Graphics.Vulkan
 
             pipeline.VertexBindingDescriptionsCount = (uint)descriptorIndex;
 
+            Span<BlendDescriptor> blendDescriptorsSpan = state.BlendDescriptors.AsSpan();
+            Span<uint> colorWriteMaskSpan = state.ColorWriteMask.AsSpan();
+            Span<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan = pipeline.Internal.ColorBlendAttachmentState.AsSpan();
+            
             // NOTE: Viewports, Scissors are dynamic.
 
             for (int i = 0; i < Constants.MaxRenderTargets; i++)
             {
-                BlendDescriptor blend = state.BlendDescriptors[i];
+                BlendDescriptor blend = blendDescriptorsSpan[i];
 
-                if (blend.Enable && state.ColorWriteMask[i] != 0)
+                if (blend.Enable && colorWriteMaskSpan[i] != 0)
                 {
-                    pipeline.Internal.ColorBlendAttachmentState[i] = new PipelineColorBlendAttachmentState(
+                    colorBlendAttachmentStateSpan[i] = new PipelineColorBlendAttachmentState(
                         blend.Enable,
                         blend.ColorSrcFactor.Convert(),
                         blend.ColorDstFactor.Convert(),
@@ -284,12 +297,12 @@ namespace Ryujinx.Graphics.Vulkan
                         blend.AlphaSrcFactor.Convert(),
                         blend.AlphaDstFactor.Convert(),
                         blend.AlphaOp.Convert(),
-                        (ColorComponentFlags)state.ColorWriteMask[i]);
+                        (ColorComponentFlags)colorWriteMaskSpan[i]);
                 }
                 else
                 {
-                    pipeline.Internal.ColorBlendAttachmentState[i] = new PipelineColorBlendAttachmentState(
+                    colorBlendAttachmentStateSpan[i] = new PipelineColorBlendAttachmentState(
-                        colorWriteMask: (ColorComponentFlags)state.ColorWriteMask[i]);
+                        colorWriteMask: (ColorComponentFlags)colorWriteMaskSpan[i]);
                 }
             }
 
@@ -298,22 +311,26 @@ namespace Ryujinx.Graphics.Vulkan
             uint attachmentIntegerFormatMask = 0;
             bool allFormatsFloatOrSrgb = true;
             
+            Span<bool> attachmentEnableSpan = state.AttachmentEnable.AsSpan();
+            Span<GALFormat> attachmentFormatsSpan = state.AttachmentFormats.AsSpan();
+            Span<VulkanFormat> pAttachmentFormatsSpan = pipeline.Internal.AttachmentFormats.AsSpan();
+
             for (int i = 0; i < Constants.MaxRenderTargets; i++)
             {
-                if (state.AttachmentEnable[i])
+                if (attachmentEnableSpan[i])
                 {
                     bool isNotMsOrSupportsStorage = gd.Capabilities.SupportsShaderStorageImageMultisample ||
-                         !state.AttachmentFormats[i].IsImageCompatible();
+                         !attachmentFormatsSpan[i].IsImageCompatible();
 
-                    pipeline.Internal.AttachmentFormats[attachmentCount++] = gd.FormatCapabilities.ConvertToVkFormat(state.AttachmentFormats[i], isNotMsOrSupportsStorage);
+                    pAttachmentFormatsSpan[attachmentCount++] = gd.FormatCapabilities.ConvertToVkFormat(attachmentFormatsSpan[i], isNotMsOrSupportsStorage);
                     maxColorAttachmentIndex = i;
 
-                    if (state.AttachmentFormats[i].IsInteger())
+                    if (attachmentFormatsSpan[i].IsInteger())
                     {
                         attachmentIntegerFormatMask |= 1u << i;
                     }
 
-                    allFormatsFloatOrSrgb &= state.AttachmentFormats[i].IsFloatOrSrgb();
+                    allFormatsFloatOrSrgb &= attachmentFormatsSpan[i].IsFloatOrSrgb();
                 }
             }
 
@@ -322,7 +339,7 @@ namespace Ryujinx.Graphics.Vulkan
                 bool isNotMsOrSupportsStorage = !state.DepthStencilFormat.IsImageCompatible() ||
                      gd.Capabilities.SupportsShaderStorageImageMultisample;
 
-                pipeline.Internal.AttachmentFormats[attachmentCount++] = gd.FormatCapabilities.ConvertToVkFormat(state.DepthStencilFormat, isNotMsOrSupportsStorage);
+                pAttachmentFormatsSpan[attachmentCount++] = gd.FormatCapabilities.ConvertToVkFormat(state.DepthStencilFormat, isNotMsOrSupportsStorage);
             }
 
             pipeline.ColorBlendAttachmentStateCount = (uint)(maxColorAttachmentIndex + 1);

src/Ryujinx.Graphics.Vulkan/PipelineDynamicState.cs

@@ -121,32 +121,32 @@ namespace Ryujinx.Graphics.Vulkan
         {
             Vk api = gd.Api;
 
-            if (_dirty.HasFlag(DirtyFlags.Blend))
+            if ((_dirty & DirtyFlags.Blend) == DirtyFlags.Blend)
             {
                 RecordBlend(api, commandBuffer);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.DepthBias))
+            if ((_dirty & DirtyFlags.DepthBias) == DirtyFlags.DepthBias)
             {
                 RecordDepthBias(api, commandBuffer);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Scissor))
+            if ((_dirty & DirtyFlags.Scissor) == DirtyFlags.Scissor)
             {
                 RecordScissor(api, commandBuffer);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Stencil))
+            if ((_dirty & DirtyFlags.Stencil) == DirtyFlags.Stencil)
             {
                 RecordStencilMasks(api, commandBuffer);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.Viewport))
+            if ((_dirty & DirtyFlags.Viewport) == DirtyFlags.Viewport)
             {
                 RecordViewport(api, commandBuffer);
             }
 
-            if (_dirty.HasFlag(DirtyFlags.FeedbackLoop) && gd.Capabilities.SupportsDynamicAttachmentFeedbackLoop)
+            if ((_dirty & DirtyFlags.FeedbackLoop) == DirtyFlags.FeedbackLoop && gd.Capabilities.SupportsDynamicAttachmentFeedbackLoop)
             {
                 RecordFeedbackLoop(gd.DynamicFeedbackLoopApi, commandBuffer);
             }

src/Ryujinx.Graphics.Vulkan/PipelineState.cs

@@ -521,6 +521,9 @@ namespace Ryujinx.Graphics.Vulkan
 
                 uint blendEnables = 0;
                 
+                Span<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan =
+                    Internal.ColorBlendAttachmentState.AsSpan();
+
                 if (gd.IsMoltenVk && Internal.AttachmentIntegerFormatMask != 0)
                 {
                     // Blend can't be enabled for integer formats, so let's make sure it is disabled.
@@ -530,12 +533,12 @@ namespace Ryujinx.Graphics.Vulkan
                     {
                         int i = BitOperations.TrailingZeroCount(attachmentIntegerFormatMask);
 
-                        if (Internal.ColorBlendAttachmentState[i].BlendEnable)
+                        if (colorBlendAttachmentStateSpan[i].BlendEnable)
                         {
                             blendEnables |= 1u << i;
                         }
 
-                        Internal.ColorBlendAttachmentState[i].BlendEnable = false;
+                        colorBlendAttachmentStateSpan[i].BlendEnable = false;
                         attachmentIntegerFormatMask &= ~(1u << i);
                     }
                 }
@@ -656,7 +659,7 @@ namespace Ryujinx.Graphics.Vulkan
                 {
                     int i = BitOperations.TrailingZeroCount(blendEnables);
 
-                    Internal.ColorBlendAttachmentState[i].BlendEnable = true;
+                    colorBlendAttachmentStateSpan[i].BlendEnable = true;
                     blendEnables &= ~(1u << i);
                 }
             }
@@ -675,14 +678,21 @@ namespace Ryujinx.Graphics.Vulkan
             // To work around this, we reduce the format to something that doesn't exceed the stride if possible.
             // The assumption is that the exceeding components are not actually accessed on the shader.
 
+            Span<VertexInputAttributeDescription> vertexAttributeDescriptionsSpan =
+                Internal.VertexAttributeDescriptions.AsSpan();
+            Span<VertexInputBindingDescription> vertexBindingDescriptionsSpan =
+                Internal.VertexBindingDescriptions.AsSpan();
+            Span<VertexInputAttributeDescription> vertexAttributeDescriptions2Span =
+                _vertexAttributeDescriptions2.AsSpan();
+
             for (int index = 0; index < VertexAttributeDescriptionsCount; index++)
             {
-                VertexInputAttributeDescription attribute = Internal.VertexAttributeDescriptions[index];
+                VertexInputAttributeDescription attribute = vertexAttributeDescriptionsSpan[index];
                 int vbIndex = GetVertexBufferIndex(attribute.Binding);
 
                 if (vbIndex >= 0)
                 {
-                    ref VertexInputBindingDescription vb = ref Internal.VertexBindingDescriptions[vbIndex];
+                    ref VertexInputBindingDescription vb = ref vertexBindingDescriptionsSpan[vbIndex];
 
                     Format format = attribute.Format;
 
@@ -707,15 +717,18 @@ namespace Ryujinx.Graphics.Vulkan
                     }
                 }
 
-                _vertexAttributeDescriptions2[index] = attribute;
+                vertexAttributeDescriptions2Span[index] = attribute;
             }
         }
 
         private int GetVertexBufferIndex(uint binding)
         {
+            Span<VertexInputBindingDescription> vertexBindingDescriptionsSpan =
+                Internal.VertexBindingDescriptions.AsSpan();
+            
             for (int index = 0; index < VertexBindingDescriptionsCount; index++)
             {
-                if (Internal.VertexBindingDescriptions[index].Binding == binding)
+                if (vertexBindingDescriptionsSpan[index].Binding == binding)
                 {
                     return index;
                 }

src/Ryujinx.Graphics.Vulkan/PipelineUid.cs

@@ -87,36 +87,44 @@ namespace Ryujinx.Graphics.Vulkan
                            Id7 * 23 ^
                            Id8 * 23;
             
+            ReadOnlySpan<VertexInputAttributeDescription> vertexAttributeDescriptionsSpan = VertexAttributeDescriptions.AsSpan();
+
             for (int i = 0; i < (int)VertexAttributeDescriptionsCount; i++)
             {
-                hash64 ^= VertexAttributeDescriptions[i].Binding * 23;
+                hash64 ^= vertexAttributeDescriptionsSpan[i].Binding * 23;
-                hash64 ^= (uint)VertexAttributeDescriptions[i].Format * 23;
+                hash64 ^= (uint)vertexAttributeDescriptionsSpan[i].Format * 23;
-                hash64 ^= VertexAttributeDescriptions[i].Location * 23;
+                hash64 ^= vertexAttributeDescriptionsSpan[i].Location * 23;
-                hash64 ^= VertexAttributeDescriptions[i].Offset * 23;
+                hash64 ^= vertexAttributeDescriptionsSpan[i].Offset * 23;
             }
             
+            ReadOnlySpan<VertexInputBindingDescription> vertexBindingDescriptionsSpan = VertexBindingDescriptions.AsSpan();
+
             for (int i = 0; i < (int)VertexBindingDescriptionsCount; i++)
             {
-                hash64 ^= VertexBindingDescriptions[i].Binding * 23;
+                hash64 ^= vertexBindingDescriptionsSpan[i].Binding * 23;
-                hash64 ^= (uint)VertexBindingDescriptions[i].InputRate * 23;
+                hash64 ^= (uint)vertexBindingDescriptionsSpan[i].InputRate * 23;
-                hash64 ^= VertexBindingDescriptions[i].Stride * 23;
+                hash64 ^= vertexBindingDescriptionsSpan[i].Stride * 23;
             }
             
+            ReadOnlySpan<PipelineColorBlendAttachmentState> colorBlendAttachmentStateSpan = ColorBlendAttachmentState.AsSpan();
+
             for (int i = 0; i < (int)ColorBlendAttachmentStateCount; i++)
             {
-                hash64 ^= ColorBlendAttachmentState[i].BlendEnable * 23;
+                hash64 ^= colorBlendAttachmentStateSpan[i].BlendEnable * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].SrcColorBlendFactor * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].SrcColorBlendFactor * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].DstColorBlendFactor * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].DstColorBlendFactor * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].ColorBlendOp * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].ColorBlendOp * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].SrcAlphaBlendFactor * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].SrcAlphaBlendFactor * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].DstAlphaBlendFactor * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].DstAlphaBlendFactor * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].AlphaBlendOp * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].AlphaBlendOp * 23;
-                hash64 ^= (uint)ColorBlendAttachmentState[i].ColorWriteMask * 23;
+                hash64 ^= (uint)colorBlendAttachmentStateSpan[i].ColorWriteMask * 23;
             }
             
+            ReadOnlySpan<Format> attachmentFormatsSpan = AttachmentFormats.AsSpan();
+
             for (int i = 0; i < (int)ColorBlendAttachmentStateCount; i++)
             {
-                hash64 ^= (uint)AttachmentFormats[i] * 23;
+                hash64 ^= (uint)attachmentFormatsSpan[i] * 23;
             }
 
             return (int)hash64 ^ ((int)(hash64 >> 32) * 17);

src/Ryujinx.HLE/HOS/Kernel/Threading/KScheduler.cs

@@ -578,7 +578,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                     {
                         KThread selectedSuggestedCore = context.Schedulers[suggestedCore]._state.SelectedThread;
 
-                        if (selectedSuggestedCore == suggested || (selectedSuggestedCore != null && selectedSuggestedCore.DynamicPriority < 2))
+                        if (selectedSuggestedCore == suggested || selectedSuggestedCore is { DynamicPriority: < 2 })
                         {
                             continue;
                         }

src/Ryujinx.HLE/HOS/Kernel/Threading/KThread.cs

@@ -1,3 +1,4 @@
+using ARMeilleure.State;
 using Ryujinx.Common.Logging;
 using Ryujinx.Cpu;
 using Ryujinx.HLE.Debugger;
@@ -685,16 +686,19 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             ThreadContext context = new();
             
+            Span<ulong> registersSpan = context.Registers.AsSpan();
+            Span<V128> fpuRegistersSpan = context.FpuRegisters.AsSpan();
+
             if (Owner.Flags.HasFlag(ProcessCreationFlags.Is64Bit))
             {
-                for (int i = 0; i < context.Registers.Length; i++)
+                for (int i = 0; i < registersSpan.Length; i++)
                 {
-                    context.Registers[i] = Context.GetX(i);
+                    registersSpan[i] = Context.GetX(i);
                 }
 
-                for (int i = 0; i < context.FpuRegisters.Length; i++)
+                for (int i = 0; i < fpuRegistersSpan.Length; i++)
                 {
-                    context.FpuRegisters[i] = Context.GetV(i);
+                    fpuRegistersSpan[i] = Context.GetV(i);
                 }
 
                 context.Fp = Context.GetX(29);
@@ -708,12 +712,12 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             {
                 for (int i = 0; i < MaxRegistersAArch32; i++)
                 {
-                    context.Registers[i] = (uint)Context.GetX(i);
+                    registersSpan[i] = (uint)Context.GetX(i);
                 }
 
                 for (int i = 0; i < MaxFpuRegistersAArch32; i++)
                 {
-                    context.FpuRegisters[i] = Context.GetV(i);
+                    fpuRegistersSpan[i] = Context.GetV(i);
                 }
 
                 context.Pc = (uint)Context.Pc;

src/Ryujinx.HLE/HOS/Services/Fatal/IService.cs

@@ -75,17 +75,21 @@ namespace Ryujinx.HLE.HOS.Services.Fatal
                     {
                         errorReport.AppendLine("\tStackTrace:");
 
+                        Span<ulong> stackTraceSpan = cpuContext64.StackTrace.AsSpan();
+
                         for (int i = 0; i < cpuContext64.StackTraceSize; i++)
                         {
-                            errorReport.AppendLine($"\t\t0x{cpuContext64.StackTrace[i]:x16}");
+                            errorReport.AppendLine($"\t\t0x{stackTraceSpan[i]:x16}");
                         }
                     }
 
                     errorReport.AppendLine("\tRegisters:");
                     
-                    for (int i = 0; i < cpuContext64.X.Length; i++)
+                    Span<ulong> xSpan = cpuContext64.X.AsSpan();
+
+                    for (int i = 0; i < xSpan.Length; i++)
                     {
-                        errorReport.AppendLine($"\t\tX[{i:d2}]:\t0x{cpuContext64.X[i]:x16}");
+                        errorReport.AppendLine($"\t\tX[{i:d2}]:\t0x{xSpan[i]:x16}");
                     }
 
                     errorReport.AppendLine();
@@ -110,17 +114,21 @@ namespace Ryujinx.HLE.HOS.Services.Fatal
                     {
                         errorReport.AppendLine("\tStackTrace:");
                         
+                        Span<uint> stackTraceSpan = cpuContext32.StackTrace.AsSpan();
+
                         for (int i = 0; i < cpuContext32.StackTraceSize; i++)
                         {
-                            errorReport.AppendLine($"\t\t0x{cpuContext32.StackTrace[i]:x16}");
+                            errorReport.AppendLine($"\t\t0x{stackTraceSpan[i]:x16}");
                         }
                     }
 
                     errorReport.AppendLine("\tRegisters:");
                     
-                    for (int i = 0; i < cpuContext32.X.Length; i++)
+                    Span<uint> xSpan = cpuContext32.X.AsSpan();
+
+                    for (int i = 0; i < xSpan.Length; i++)
                     {
-                        errorReport.AppendLine($"\t\tX[{i:d2}]:\t0x{cpuContext32.X[i]:x16}");
+                        errorReport.AppendLine($"\t\tX[{i:d2}]:\t0x{xSpan[i]:x16}");
                     }
 
                     errorReport.AppendLine();

src/Ryujinx.HLE/HOS/Services/Hid/HidDevices/NpadDevices.cs

@@ -94,6 +94,8 @@ namespace Ryujinx.HLE.HOS.Services.Hid
             primaryIndex = PlayerIndex.Unknown;
             configuredCount = 0;
 
+            Span<NpadState> nPadsSpan = _device.Hid.SharedMemory.Npads.AsSpan();
+
             for (int i = 0; i < MaxControllers; ++i)
             {
                 ControllerType npad = _configuredTypes[i];
@@ -103,7 +105,7 @@ namespace Ryujinx.HLE.HOS.Services.Hid
                     continue;
                 }
 
-                ControllerType currentType = (ControllerType)_device.Hid.SharedMemory.Npads[i].InternalState.StyleSet;
+                ControllerType currentType = (ControllerType)nPadsSpan[i].InternalState.StyleSet;
 
                 if (currentType != ControllerType.None && (npad & acceptedTypes) != 0 && _supportedPlayers[i])
                 {

src/Ryujinx.HLE/HOS/Services/Hid/HidDevices/TouchDevice.cs

@@ -23,12 +23,14 @@ namespace Ryujinx.HLE.HOS.Services.Hid
             {
                 newState.TouchesCount = points.Length;
 
-                int pointsLength = Math.Min(points.Length, newState.Touches.Length);
+                Span<TouchState> touchesSpan = newState.Touches.AsSpan();
+                
+                int pointsLength = Math.Min(points.Length, touchesSpan.Length);
 
                 for (int i = 0; i < pointsLength; ++i)
                 {
                     TouchPoint pi = points[i];
-                    newState.Touches[i] = new TouchState
+                    touchesSpan[i] = new TouchState
                     {
                         DeltaTime = newState.SamplingNumber,
                         Attribute = pi.Attribute,

src/Ryujinx.HLE/HOS/Services/Hid/Types/SharedMemory/Common/RingLifo.cs

@@ -50,11 +50,13 @@ namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Common
 
             ulong index = ReadCurrentIndex();
             
+            Span<AtomicStorage<T>> storageSpan = _storage.AsSpan();
+
             while (true)
             {
                 int inputEntryIndex = (int)((index + MaxEntries + 1 - countAvailaible) % MaxEntries);
 
-                ref AtomicStorage<T> result = ref _storage[inputEntryIndex];
+                ref AtomicStorage<T> result = ref storageSpan[inputEntryIndex];
 
                 ulong samplingNumber0 = result.ReadSamplingNumberAtomic();
                 ulong samplingNumber1 = result.ReadSamplingNumberAtomic();
@@ -92,14 +94,16 @@ namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Common
 
             AtomicStorage<T>[] result = new AtomicStorage<T>[countAvailaible];
             
+            Span<AtomicStorage<T>> storageSpan = _storage.AsSpan();
+
             for (ulong i = 0; i < countAvailaible; i++)
             {
                 int inputEntryIndex = (int)((index + MaxEntries + 1 - countAvailaible + i) % MaxEntries);
                 int outputEntryIndex = (int)(countAvailaible - i - 1);
 
-                ulong samplingNumber0 = _storage[inputEntryIndex].ReadSamplingNumberAtomic();
+                ulong samplingNumber0 = storageSpan[inputEntryIndex].ReadSamplingNumberAtomic();
-                result[outputEntryIndex] = _storage[inputEntryIndex];
+                result[outputEntryIndex] = storageSpan[inputEntryIndex];
-                ulong samplingNumber1 = _storage[inputEntryIndex].ReadSamplingNumberAtomic();
+                ulong samplingNumber1 = storageSpan[inputEntryIndex].ReadSamplingNumberAtomic();
 
                 if (samplingNumber0 != samplingNumber1 && (i > 0 && (result[outputEntryIndex].SamplingNumber - result[outputEntryIndex].SamplingNumber) != 1))
                 {

src/Ryujinx.HLE/HOS/Services/Hid/Types/SharedMemory/SharedMemory.cs

@@ -6,6 +6,7 @@ using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Keyboard;
 using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Mouse;
 using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Npad;
 using Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.TouchScreen;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory
@@ -62,9 +63,11 @@ namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory
                 Keyboard = RingLifo<KeyboardState>.Create(),
             };
             
-            for (int i = 0; i < result.Npads.Length; i++)
+            Span<NpadState> npadsSpan = result.Npads.AsSpan();
+
+            for (int i = 0; i < npadsSpan.Length; i++)
             {
-                result.Npads[i] = NpadState.Create();
+                npadsSpan[i] = NpadState.Create();
             }
 
             return result;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/NodeLatestUpdate.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Memory;
+using System;
 using System.Runtime.InteropServices;
 using System.Threading;
 
@@ -19,20 +20,24 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.Types
         {
             lock (_lock)
             {
+                Span<NodeLatestUpdate> arraySpan = array.AsSpan();
+                Span<NodeInfo> beforeNodesSpan = beforeNodes.AsSpan();
+                Span<NodeInfo> afterNodesSpan = afterNodes.AsSpan();
+                
                 for (int i = 0; i < 8; i++)
                 {
-                    if (beforeNodes[i].IsConnected == 0)
+                    if (beforeNodesSpan[i].IsConnected == 0)
                     {
-                        if (afterNodes[i].IsConnected != 0)
+                        if (afterNodesSpan[i].IsConnected != 0)
                         {
-                            array[i].State |= NodeLatestUpdateFlags.Connect;
+                            arraySpan[i].State |= NodeLatestUpdateFlags.Connect;
                         }
                     }
                     else
                     {
-                        if (afterNodes[i].IsConnected == 0)
+                        if (afterNodesSpan[i].IsConnected == 0)
                         {
-                            array[i].State |= NodeLatestUpdateFlags.Disconnect;
+                            arraySpan[i].State |= NodeLatestUpdateFlags.Disconnect;
                         }
                     }
                 }
@@ -45,14 +50,16 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 
             lock (_lock)
             {
+                Span<NodeLatestUpdate> arraySpan = array.AsSpan();
+                
                 for (int i = 0; i < number; i++)
                 {
                     result[i].Reserved = new Array7<byte>();
 
                     if (i < LdnConst.NodeCountMax)
                     {
-                        result[i].State = array[i].State;
+                        result[i].State = arraySpan[i].State;
-                        array[i].State = NodeLatestUpdateFlags.None;
+                        arraySpan[i].State = NodeLatestUpdateFlags.None;
                     }
                 }
             }

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LanDiscovery.cs

@@ -77,9 +77,11 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
                 },
             };
 
+            Span<NodeInfo> nodesSpan = networkInfo.Ldn.Nodes.AsSpan();
+
             for (int i = 0; i < LdnConst.NodeCountMax; i++)
             {
-                networkInfo.Ldn.Nodes[i] = new NodeInfo
+                nodesSpan[i] = new NodeInfo
                 {
                     MacAddress = new Array6<byte>(),
                     UserName = new Array33<byte>(),
@@ -230,10 +232,12 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
 
                 NetworkInfo.Ldn.Nodes = new Array8<NodeInfo>();
                 
+                Span<NodeInfo> nodesSpan = NetworkInfo.Ldn.Nodes.AsSpan();
+
                 for (int i = 0; i < LdnConst.NodeCountMax; i++)
                 {
-                    NetworkInfo.Ldn.Nodes[i].NodeId = (byte)i;
+                    nodesSpan[i].NodeId = (byte)i;
-                    NetworkInfo.Ldn.Nodes[i].IsConnected = 0;
+                    nodesSpan[i].IsConnected = 0;
                 }
             }
         }
@@ -408,11 +412,11 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
 
         private int LocateEmptyNode()
         {
-            Array8<NodeInfo> nodes = NetworkInfo.Ldn.Nodes;
+            Span<NodeInfo> nodesSpan = NetworkInfo.Ldn.Nodes.AsSpan();
 
-            for (int i = 1; i < nodes.Length; i++)
+            for (int i = 1; i < nodesSpan.Length; i++)
             {
-                if (nodes[i].IsConnected == 0)
+                if (nodesSpan[i].IsConnected == 0)
                 {
                     return i;
                 }

src/Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostAsGpu/NvHostAsGpuDeviceFile.cs

@@ -335,9 +335,11 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostAsGpu
                 writeEntries = (uint)_pageSizes.Length;
             }
 
+            Span<VaRegion> regionsSpan = arguments.Regions.AsSpan();
+
             for (uint i = 0; i < writeEntries; i++)
             {
-                ref VaRegion region = ref arguments.Regions[(int)i];
+                ref VaRegion region = ref regionsSpan[(int)i];
 
                 VmRegion vmRegion = _vmRegions[i];
                 uint pageSize = _pageSizes[i];

src/Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/AddrInfo4.cs

@@ -30,21 +30,21 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres.Types
         {
             Port = IPAddress.HostToNetworkOrder(Port);
 
-            RawIpv4AddressNetworkEndianSwap(ref Address);
+            RawIpv4AddressNetworkEndianSwap(Address.AsSpan());
         }
 
         public void ToHostOrder()
         {
             Port = IPAddress.NetworkToHostOrder(Port);
 
-            RawIpv4AddressNetworkEndianSwap(ref Address);
+            RawIpv4AddressNetworkEndianSwap(Address.AsSpan());
         }
 
-        public static void RawIpv4AddressNetworkEndianSwap(ref Array4<byte> address)
+        public static void RawIpv4AddressNetworkEndianSwap(Span<byte> address)
         {
             if (BitConverter.IsLittleEndian)
             {
-                address.AsSpan().Reverse();
+                address.Reverse();
             }
         }
     }

src/Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/AddrInfoSerialized.cs

@@ -73,7 +73,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres.Types
             {
                 // Nintendo hardcode 4 bytes in that case here.
                 Array4<byte> address = MemoryMarshal.Read<Array4<byte>>(buffer);
-                AddrInfo4.RawIpv4AddressNetworkEndianSwap(ref address);
+                AddrInfo4.RawIpv4AddressNetworkEndianSwap(address.AsSpan());
 
                 rawIPv4Address = address;
 
@@ -115,7 +115,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres.Types
             else
             {
                 Array4<byte> rawIPv4Address = RawIPv4Address.Value;
-                AddrInfo4.RawIpv4AddressNetworkEndianSwap(ref rawIPv4Address);
+                AddrInfo4.RawIpv4AddressNetworkEndianSwap(rawIPv4Address.AsSpan());
 
                 MemoryMarshal.Write(buffer, in rawIPv4Address);
 

src/Ryujinx.HLE/HOS/Tamper/AtmosphereCompiler.cs

@@ -50,7 +50,7 @@ namespace Ryujinx.HLE.HOS.Tamper
                 Logger.Error?.Print(LogClass.TamperMachine, ex.ToString());
             }
 
-            Logger.Error?.Print(LogClass.TamperMachine, "There was a problem while compiling the Atmosphere cheat");
+            Logger.Error?.Print(LogClass.TamperMachine, $"There was a problem while compiling the Atmosphere cheat '{name}'");
 
             return null;
         }
@@ -126,7 +126,7 @@ namespace Ryujinx.HLE.HOS.Tamper
                         DebugLog.Emit(instruction, context);
                         break;
                     default:
-                        throw new TamperCompilationException($"Code type {codeType} not implemented in Atmosphere cheat");
+                        throw new TamperCompilationException($"Code type {codeType} not implemented in Atmosphere cheat compiler");
                 }
             }
 

src/Ryujinx.HLE/HOS/Tamper/CodeEmitters/EndConditionalBlock.cs

@@ -40,7 +40,8 @@ namespace Ryujinx.HLE.HOS.Tamper.CodeEmitters
             }
 
             // Use the conditional begin instruction stored in the stack.
-            byte[] upperInstruction = context.CurrentBlock.BaseInstruction;
+            byte[] upperInstruction = context.CurrentBlock.BaseInstruction 
+                                      ?? throw new TamperCompilationException($"Base instruction in current block was null; termination type '{terminationType}'");
             CodeType codeType = InstructionHelper.GetCodeType(upperInstruction);
 
             // Pop the current block of operations from the stack so control instructions

src/Ryujinx.HLE/Switch.cs

@@ -20,6 +20,18 @@ namespace Ryujinx.HLE
 {
     public class Switch : IDisposable
     {
+        /// <summary>
+        /// Currently running emulated Switch, if there is one.
+        /// <para>
+        /// Proper usage of this property null checks it before use, unless the caller is certain that the emulation is running.
+        /// </para>
+        /// <para>
+        /// In case the emulation is running, there might be a way to directly pass the <see cref="Switch" /> instance, which is preferred.
+        /// </para>
+        /// <para>
+        /// The instance is set to <c>this</c> on any <see cref="Switch" /> instantiation, and set to <c>null</c> on any <see cref="Switch" /> disposal.
+        /// </para>
+        /// </summary>
         public static Switch Shared { get; private set; }
 
         public HleConfiguration Configuration { get; }

src/Ryujinx.HLE/UI/Input/NpadReader.cs

@@ -62,10 +62,10 @@ namespace Ryujinx.HLE.UI.Input
 
         public void Update(bool supressEvents = false)
         {
-            ref Array10<NpadState> npads = ref _device.Hid.SharedMemory.Npads;
+            int npadsCount = _device.Hid.SharedMemory.Npads.Length;
 
             // Process each input individually.
-            for (int npadIndex = 0; npadIndex < npads.Length; npadIndex++)
+            for (int npadIndex = 0; npadIndex < npadsCount; npadIndex++)
             {
                 UpdateNpad(npadIndex, supressEvents);
             }

src/Ryujinx.Input/GamepadStateSnapshot.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Memory;
+using System;
 using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Input
@@ -48,7 +49,7 @@ namespace Ryujinx.Input
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public (float, float) GetStick(StickInputId inputId)
         {
-            Array2<float> result = _joysticksState[(int)inputId];
+            Span<float> result = _joysticksState[(int)inputId].AsSpan();
 
             return (result[0], result[1]);
         }
@@ -62,8 +63,9 @@ namespace Ryujinx.Input
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetStick(StickInputId inputId, float x, float y)
         {
-            _joysticksState[(int)inputId][0] = x;
+            Span<float> stateSpan = _joysticksState[(int)inputId].AsSpan();
-            _joysticksState[(int)inputId][1] = y;
+            stateSpan[0] = x;
+            stateSpan[1] = y;
         }
     }
 }

src/Ryujinx.Input/IGamepad.cs

@@ -104,25 +104,28 @@ namespace Ryujinx.Input
         {
             // NOTE: Update Array size if JoystickInputId is changed.
             Array3<Array2<float>> joysticksState = default;
+            Span<Array2<float>> joysticksStateSpan = joysticksState.AsSpan();
 
             for (StickInputId inputId = StickInputId.Left; inputId < StickInputId.Count; inputId++)
             {
                 (float state0, float state1) = gamepad.GetStick(inputId);
 
                 Array2<float> state = default;
+                Span<float> stateSpan = state.AsSpan();
 
-                state[0] = state0;
+                stateSpan[0] = state0;
-                state[1] = state1;
+                stateSpan[1] = state1;
 
-                joysticksState[(int)inputId] = state;
+                joysticksStateSpan[(int)inputId] = state;
             }
 
             // NOTE: Update Array size if GamepadInputId is changed.
             Array28<bool> buttonsState = default;
+            Span<bool> buttonsStateSpan = buttonsState.AsSpan();
 
             for (GamepadButtonInputId inputId = GamepadButtonInputId.A; inputId < GamepadButtonInputId.Count; inputId++)
             {
-                buttonsState[(int)inputId] = gamepad.IsPressed(inputId);
+                buttonsStateSpan[(int)inputId] = gamepad.IsPressed(inputId);
             }
 
             return new GamepadStateSnapshot(joysticksState, buttonsState);

src/Ryujinx.Memory/Range/NonOverlappingRangeList.cs

@@ -10,7 +10,7 @@ namespace Ryujinx.Memory.Range
     /// A range list that assumes ranges are non-overlapping, with list items that can be split in two to avoid overlaps.
     /// </summary>
     /// <typeparam name="T">Type of the range.</typeparam>
-    public class NonOverlappingRangeList<T> : RangeListBase<T> where T : INonOverlappingRange
+    public unsafe class NonOverlappingRangeList<T> : RangeListBase<T> where T : class, INonOverlappingRange
     {
         private readonly Dictionary<ulong, RangeItem<T>> _quickAccess = new(AddressEqualityComparer.Comparer);
         private readonly Dictionary<ulong, RangeItem<T>> _fastQuickAccess = new(AddressEqualityComparer.Comparer);
@@ -87,6 +87,43 @@ namespace Ryujinx.Memory.Range
             return false;
         }
         
+        /// <summary>
+        /// Updates an item's end address on the list. Address must be the same.
+        /// </summary>
+        /// <param name="item">The RangeItem to be updated</param>
+        /// <returns>True if the item was located and updated, false otherwise</returns>
+        protected override bool Update(RangeItem<T> item)
+        {
+            int index = BinarySearch(item.Address);
+
+            RangeItem<T> rangeItem = new(item.Value) { Previous = item.Previous, Next = item.Next };
+                
+            if (index > 0)
+            {
+                Items[index - 1].Next = rangeItem;
+            }
+
+            if (index < Count - 1)
+            {
+                Items[index + 1].Previous = rangeItem;
+            }
+                
+            foreach (ulong addr in item.QuickAccessAddresses)
+            {
+                _quickAccess.Remove(addr);
+                _fastQuickAccess.Remove(addr);
+            }
+                
+            Items[index] = rangeItem;
+
+            if (item.Address != rangeItem.Address)
+                _quickAccess.Remove(item.Address);
+            
+            _quickAccess[rangeItem.Address] = rangeItem;
+
+            return true;
+        }
+        
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void Insert(int index, RangeItem<T> item)
         {
@@ -193,37 +230,35 @@ namespace Ryujinx.Memory.Range
                 return;
             }
             
-            int startIndex = BinarySearch(startItem.Address);
+            (int startIndex, int endIndex) = BinarySearchEdges(startItem.Address, endItem.EndAddress);
-            int endIndex = BinarySearch(endItem.Address);
             
-            if (endIndex < Count - 1)
+            for (int i = startIndex; i < endIndex; i++)
             {
-                Items[endIndex + 1].Previous = startIndex > 0 ? Items[startIndex - 1] : null;
+                _quickAccess.Remove(Items[i].Address);
-            }
+                foreach (ulong addr in Items[i].QuickAccessAddresses)
-
-            if (startIndex > 0)
-            {
-                Items[startIndex - 1].Next = endIndex < Count - 1 ? Items[endIndex + 1] : null;
-            }
-            
-            
-            if (endIndex < Count - 1)
-            {
-                Array.Copy(Items, endIndex + 1, Items, startIndex, Count - endIndex - 1);
-            }
-            
-            Count -= endIndex - startIndex + 1;
-
-            while (startItem != endItem.Next)
-            {
-                _quickAccess.Remove(startItem.Address);
-                foreach (ulong addr in startItem.QuickAccessAddresses)
                 {
                     _quickAccess.Remove(addr);
                     _fastQuickAccess.Remove(addr);
                 }
-                startItem = startItem.Next;
             }
+            
+            if (endIndex < Count)
+            {
+                Items[endIndex].Previous = startIndex > 0 ? Items[startIndex - 1] : null;
+            }
+
+            if (startIndex > 0)
+            {
+                Items[startIndex - 1].Next = endIndex < Count ? Items[endIndex] : null;
+            }
+            
+            
+            if (endIndex < Count)
+            {
+                Array.Copy(Items, endIndex, Items, startIndex, Count - endIndex);
+            }
+            
+            Count -= endIndex - startIndex;
         }
         
         /// <summary>
@@ -240,19 +275,22 @@ namespace Ryujinx.Memory.Range
                 return;
             }
             
-            RangeItem<T> startItem = Items[startIndex];
-            
             int endIndex = startIndex;
             
-            while (startItem is not null && startItem.Address < address + size)
+            while (Items[endIndex] is not null && Items[endIndex].Address < address + size)
             {
-                _quickAccess.Remove(startItem.Address);
+                _quickAccess.Remove(Items[endIndex].Address);
-                foreach (ulong addr in startItem.QuickAccessAddresses)
+                foreach (ulong addr in Items[endIndex].QuickAccessAddresses)
                 {
                     _quickAccess.Remove(addr);
                     _fastQuickAccess.Remove(addr);
                 }
-                startItem = startItem.Next;
+
+                if (endIndex == Count - 1)
+                {
+                    break;
+                }
+                
                 endIndex++;
             }
             

src/Ryujinx.Memory/Range/RangeList.cs

@@ -6,37 +6,6 @@ using System.Threading;
 
 namespace Ryujinx.Memory.Range
 {
-    public class RangeItem<TValue>(TValue value) where TValue : IRange
-    {
-        public RangeItem<TValue> Next;
-        public RangeItem<TValue> Previous;
-        
-        public readonly ulong Address = value.Address;
-        public readonly ulong EndAddress = value.Address + value.Size;
-
-        public readonly TValue Value = value;
-
-        public readonly List<ulong> QuickAccessAddresses = [];
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool OverlapsWith(ulong address, ulong endAddress)
-        {
-            return Address < endAddress && address < EndAddress;
-        }
-    }
-    
-    class AddressEqualityComparer : IEqualityComparer<ulong>
-    {
-        public bool Equals(ulong u1, ulong u2)
-        {
-            return u1 == u2;
-        }
-
-        public int GetHashCode(ulong value) => (int)(value >> 5);
-        
-        public static readonly AddressEqualityComparer Comparer = new();
-    }
-    
     /// <summary>
     /// Result of an Overlaps Finder function. WARNING: if the result is from the optimized
     /// Overlaps Finder, the StartIndex will be -1 even when the result isn't empty
@@ -112,12 +81,73 @@ namespace Ryujinx.Memory.Range
                 {
                     if (Items[index].Value.Equals(item))
                     {
+                        RangeItem<T> rangeItem = new(item) { Previous = Items[index].Previous, Next = Items[index].Next };
+                        
+                        if (index > 0)
+                        {
+                            Items[index - 1].Next = rangeItem;
+                        }
+
+                        if (index < Count - 1)
+                        {
+                            Items[index + 1].Previous = rangeItem;
+                        }
+                        
                         foreach (ulong address in Items[index].QuickAccessAddresses)
                         {
                             _quickAccess.Remove(address);
                         }
                         
-                        Items[index] = new RangeItem<T>(item);
+                        Items[index] = rangeItem;
+
+                        return true;
+                    }
+
+                    if (Items[index].Address > item.Address)
+                    {
+                        break;
+                    }
+
+                    index++;
+                }
+            }
+
+            return false;
+        }
+        
+        /// <summary>
+        /// Updates an item's end address on the list. Address must be the same.
+        /// </summary>
+        /// <param name="item">The RangeItem to be updated</param>
+        /// <returns>True if the item was located and updated, false otherwise</returns>
+        protected override bool Update(RangeItem<T> item)
+        {
+            int index = BinarySearch(item.Address);
+
+            if (index >= 0)
+            {
+                while (index < Count)
+                {
+                    if (Items[index].Equals(item))
+                    {
+                        RangeItem<T> rangeItem = new(item.Value) { Previous = item.Previous, Next = item.Next };
+                        
+                        if (index > 0)
+                        {
+                            Items[index - 1].Next = rangeItem;
+                        }
+
+                        if (index < Count - 1)
+                        {
+                            Items[index + 1].Previous = rangeItem;
+                        }
+                        
+                        foreach (ulong address in item.QuickAccessAddresses)
+                        {
+                            _quickAccess.Remove(address);
+                        }
+                        
+                        Items[index] = rangeItem;
 
                         return true;
                     }
@@ -209,43 +239,46 @@ namespace Ryujinx.Memory.Range
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override void RemoveRange(RangeItem<T> startItem, RangeItem<T> endItem)
         {
-            if (endItem.Next is not null)
+            if (startItem is null)
             {
-                endItem.Next.Previous = startItem.Previous;
+                return;
             }
 
-            if (startItem.Previous is not null)
+            if (startItem == endItem)
             {
-                startItem.Previous.Next = endItem.Next;
+                Remove(startItem.Value);
+                return;
             }
             
-            RangeItem<T> current = startItem;
+            int startIndex = BinarySearch(startItem.Address);
-            while (current != endItem.Next)
+            int endIndex = BinarySearch(endItem.Address);
+            
+            for (int i = startIndex; i <= endIndex; i++)
             {
-                foreach (ulong address in current.QuickAccessAddresses)
+                _quickAccess.Remove(Items[i].Address);
+                foreach (ulong addr in Items[i].QuickAccessAddresses)
                 {
-                    _quickAccess.Remove(address);
+                    _quickAccess.Remove(addr);
+                }
             }
             
-                current = current.Next;
+            if (endIndex < Count - 1)
+            {
+                Items[endIndex + 1].Previous = startIndex > 0 ? Items[startIndex - 1] : null;
             }
 
-            RangeItem<T>[] array = [];
+            if (startIndex > 0)
-            OverlapResult<T> overlapResult = FindOverlaps(startItem.Address, endItem.EndAddress, ref array);
+            {
+                Items[startIndex - 1].Next = endIndex < Count - 1 ? Items[endIndex + 1] : null;
+            }
             
-            if (overlapResult.EndIndex < Count)
+            
+            if (endIndex < Count - 1)
             {
-                Array.Copy(Items, overlapResult.EndIndex, Items, overlapResult.StartIndex, Count - overlapResult.EndIndex);
+                Array.Copy(Items, endIndex + 1, Items, startIndex, Count - endIndex - 1);
-                Count -= overlapResult.Count;
-            }
-            else if (overlapResult.EndIndex == Count)
-            {
-                Count = overlapResult.StartIndex;
-            }
-            else
-            {
-                Debug.Assert(false);
             }
+            
+            Count -= endIndex - startIndex + 1;
         }
 
         /// <summary>