[Ryujinx.Graphics.Nvdec.Vp9] Address dotnet-format issues (#5371)

* dotnet format style --severity info

Some changes were manually reverted.

* dotnet format analyzers --serverity info

Some changes have been minimally adapted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0060 warnings

* Address or silence dotnet format IDE1006 warnings

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Address IDE0251 warnings

* Address a few disabled IDE0060 warnings

* Silence IDE0060 in .editorconfig

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Fix empty lines before return

Co-authored-by: Ac_K <Acoustik666@gmail.com>

* Add trailing commas, remove redundant code and remove static modifier from Surface.HighBd

* Fix naming rule violations

* Fix naming rule violations

* Fix empty line before return

* Fix comment style

Co-authored-by: Ac_K <Acoustik666@gmail.com>

* Remove comment alignment

* Address review feedback

* Separate comments by 2 spaces and fix other formatting issues

* Make HighBd an auto-property

* Replace if-chain with if-else-chain

* Fix new naming rule violations

---------

Co-authored-by: Ac_K <Acoustik666@gmail.com>

21 files changed, 213 insertions, 215 deletions

diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BModeInfo.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BModeInfo.cs
index 9e1cd8b4..4c8e33c3 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BModeInfo.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BModeInfo.cs
@@ -5,6 +5,6 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
     internal struct BModeInfo
     {
         public PredictionMode Mode;
-        public Array2<Mv> Mv;  // First, second inter predictor motion vectors
+        public Array2<Mv> Mv; // First, second inter predictor motion vectors
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BlockSize.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BlockSize.cs
index 22a48e20..34fa9487 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BlockSize.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/BlockSize.cs
@@ -16,6 +16,6 @@
         Block64x32 = 11,
         Block64x64 = 12,
         BlockSizes = 13,
-        BlockInvalid = BlockSizes
+        BlockInvalid = BlockSizes,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/FrameType.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/FrameType.cs
index a783999e..3d209303 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/FrameType.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/FrameType.cs
@@ -3,6 +3,6 @@
     internal enum FrameType
     {
         KeyFrame = 0,
-        InterFrame = 1
+        InterFrame = 1,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/LoopFilterThresh.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/LoopFilterThresh.cs
index edd79af4..c0af5495 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/LoopFilterThresh.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/LoopFilterThresh.cs
@@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
     // passed it can be loaded into vector registers.
     internal struct LoopFilterThresh
     {
-#pragma warning disable CS0649
+#pragma warning disable CS0649 // Field is never assigned to
         public Array16<byte> Mblim;
         public Array16<byte> Lim;
         public Array16<byte> HevThr;
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MacroBlockD.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MacroBlockD.cs
index f1111528..5cdc0d2d 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MacroBlockD.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MacroBlockD.cs
@@ -54,7 +54,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public Ptr<InternalErrorInfo> ErrorInfo;
 
-        public int GetPredContextSegId()
+        public readonly int GetPredContextSegId()
         {
             sbyte aboveSip = !AboveMi.IsNull ? AboveMi.Value.SegIdPredicted : (sbyte)0;
             sbyte leftSip = !LeftMi.IsNull ? LeftMi.Value.SegIdPredicted : (sbyte)0;
@@ -62,14 +62,15 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             return aboveSip + leftSip;
         }
 
-        public int GetSkipContext()
+        public readonly int GetSkipContext()
         {
             int aboveSkip = !AboveMi.IsNull ? AboveMi.Value.Skip : 0;
             int leftSkip = !LeftMi.IsNull ? LeftMi.Value.Skip : 0;
+
             return aboveSkip + leftSkip;
         }
 
-        public int GetPredContextSwitchableInterp()
+        public readonly int GetPredContextSwitchableInterp()
         {
             // Note:
             // The mode info data structure has a one element border above and to the
@@ -103,16 +104,18 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         // 1 - intra/inter, inter/intra
         // 2 - intra/--, --/intra
         // 3 - intra/intra
-        public int GetIntraInterContext()
+        public readonly int GetIntraInterContext()
         {
             if (!AboveMi.IsNull && !LeftMi.IsNull)
-            {  // Both edges available
+            { // Both edges available
                 bool aboveIntra = !AboveMi.Value.IsInterBlock();
                 bool leftIntra = !LeftMi.Value.IsInterBlock();
+
                 return leftIntra && aboveIntra ? 3 : (leftIntra || aboveIntra ? 1 : 0);
             }
-            else if (!AboveMi.IsNull || !LeftMi.IsNull)
-            {  // One edge available
+
+            if (!AboveMi.IsNull || !LeftMi.IsNull)
+            { // One edge available
                 return 2 * (!(!AboveMi.IsNull ? AboveMi.Value : LeftMi.Value).IsInterBlock() ? 1 : 0);
             }
             return 0;
@@ -122,7 +125,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         // The mode info data structure has a one element border above and to the
         // left of the entries corresponding to real blocks.
         // The prediction flags in these dummy entries are initialized to 0.
-        public int GetTxSizeContext()
+        public readonly int GetTxSizeContext()
         {
             int maxTxSize = (int)Luts.MaxTxSizeLookup[(int)Mi[0].Value.SbType];
             int aboveCtx = (!AboveMi.IsNull && AboveMi.Value.Skip == 0) ? (int)AboveMi.Value.TxSize : maxTxSize;
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ModeInfo.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ModeInfo.cs
index 8ef281d8..8af7b6f9 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ModeInfo.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ModeInfo.cs
@@ -11,7 +11,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public TxSize TxSize;
         public sbyte Skip;
         public sbyte SegmentId;
-        public sbyte SegIdPredicted;  // Valid only when TemporalUpdate is enabled
+        public sbyte SegIdPredicted; // Valid only when TemporalUpdate is enabled
 
         // Only for Intra blocks
         public PredictionMode UvMode;
@@ -32,10 +32,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             return SbType < BlockSize.Block8x8 ? Bmi[block].Mode : Mode;
         }
 
-        public TxSize GetUvTxSize(ref MacroBlockDPlane pd)
+        public readonly TxSize GetUvTxSize(ref MacroBlockDPlane pd)
         {
             Debug.Assert(SbType < BlockSize.Block8x8 ||
                 Luts.SsSizeLookup[(int)SbType][pd.SubsamplingX][pd.SubsamplingY] != BlockSize.BlockInvalid);
+
             return Luts.UvTxsizeLookup[(int)SbType][(int)TxSize][pd.SubsamplingX][pd.SubsamplingY];
         }
 
@@ -49,9 +50,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             return RefFrame[1] > Constants.IntraFrame;
         }
 
-        private static readonly int[][] IdxNColumnToSubblock = new int[][]
-        {
-            new int[] { 1, 2 }, new int[] { 1, 3 }, new int[] { 3, 2 }, new int[] { 3, 3 }
+        private static readonly int[][] _idxNColumnToSubblock = {
+            new[] { 1, 2 }, new[] { 1, 3 }, new[] { 3, 2 }, new[] { 3, 3 },
         };
 
         // This function returns either the appropriate sub block or block's mv
@@ -59,7 +59,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public Mv GetSubBlockMv(int whichMv, int searchCol, int blockIdx)
         {
             return blockIdx >= 0 && SbType < BlockSize.Block8x8
-                ? Bmi[IdxNColumnToSubblock[blockIdx][searchCol == 0 ? 1 : 0]].Mv[whichMv]
+                ? Bmi[_idxNColumnToSubblock[blockIdx][searchCol == 0 ? 1 : 0]].Mv[whichMv]
                 : Mv[whichMv];
         }
     }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MotionVectorContext.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MotionVectorContext.cs
index 319c8dba..a9a603bf 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MotionVectorContext.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/MotionVectorContext.cs
@@ -9,6 +9,6 @@
         BothNew = 4,
         IntraPlusNonIntra = 5,
         BothIntra = 6,
-        InvalidCase = 9
+        InvalidCase = 9,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Mv.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Mv.cs
index 815bbb32..c78a80d0 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Mv.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Mv.cs
@@ -51,13 +51,13 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
             9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
             9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10
+            9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10,
         };
 
-        public bool UseMvHp()
+        public readonly bool UseMvHp()
         {
-            const int kMvRefThresh = 64;  // Threshold for use of high-precision 1/8 mv
-            return Math.Abs(Row) < kMvRefThresh && Math.Abs(Col) < kMvRefThresh;
+            const int KMvRefThresh = 64; // Threshold for use of high-precision 1/8 mv
+            return Math.Abs(Row) < KMvRefThresh && Math.Abs(Col) < KMvRefThresh;
         }
 
         public static bool MvJointVertical(MvJointType type)
@@ -110,7 +110,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             else
             {
                 int i;
-                int b = c + Constants.Class0Bits - 1;  // Number of bits
+                int b = c + Constants.Class0Bits - 1; // Number of bits
                 for (i = 0; i < b; ++i)
                 {
                     counts.Bits[comp][i][((d >> i) & 1)] += (uint)incr;
@@ -121,19 +121,17 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             }
         }
 
-        private MvJointType GetMvJoint()
+        private readonly MvJointType GetMvJoint()
         {
             if (Row == 0)
             {
                 return Col == 0 ? MvJointType.MvJointZero : MvJointType.MvJointHnzvz;
             }
-            else
-            {
-                return Col == 0 ? MvJointType.MvJointHzvnz : MvJointType.MvJointHnzvnz;
-            }
+
+            return Col == 0 ? MvJointType.MvJointHzvnz : MvJointType.MvJointHnzvnz;
         }
 
-        internal void IncMv(Ptr<Vp9BackwardUpdates> counts)
+        internal readonly void IncMv(Ptr<Vp9BackwardUpdates> counts)
         {
             if (!counts.IsNull)
             {
@@ -158,7 +156,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             Row = (short)Math.Clamp(Row, minRow, maxRow);
         }
 
-        private const int MvBorder = (16 << 3);  // Allow 16 pels in 1/8th pel units
+        private const int MvBorder = (16 << 3); // Allow 16 pels in 1/8th pel units
 
         public void ClampMvRef(ref MacroBlockD xd)
         {
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PartitionType.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PartitionType.cs
index 096f9818..78f4fb26 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PartitionType.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PartitionType.cs
@@ -7,6 +7,6 @@
         PartitionVert,
         PartitionSplit,
         PartitionTypes,
-        PartitionInvalid = PartitionTypes
+        PartitionInvalid = PartitionTypes,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PlaneType.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PlaneType.cs
index 790aa2a0..d6259456 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PlaneType.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PlaneType.cs
@@ -4,6 +4,6 @@
     {
         Y = 0,
         Uv = 1,
-        PlaneTypes
+        PlaneTypes,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PredictionMode.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PredictionMode.cs
index bbb9be9a..fbf54204 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PredictionMode.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/PredictionMode.cs
@@ -2,20 +2,20 @@
 {
     internal enum PredictionMode
     {
-        DcPred = 0,    // Average of above and left pixels
-        VPred = 1,     // Vertical
-        HPred = 2,     // Horizontal
-        D45Pred = 3,   // Directional 45  deg = round(arctan(1 / 1) * 180 / pi)
-        D135Pred = 4,  // Directional 135 deg = 180 - 45
-        D117Pred = 5,  // Directional 117 deg = 180 - 63
-        D153Pred = 6,  // Directional 153 deg = 180 - 27
-        D207Pred = 7,  // Directional 207 deg = 180 + 27
-        D63Pred = 8,   // Directional 63  deg = round(arctan(2 / 1) * 180 / pi)
-        TmPred = 9,    // True-motion
+        DcPred = 0, // Average of above and left pixels
+        VPred = 1, // Vertical
+        HPred = 2, // Horizontal
+        D45Pred = 3, // Directional 45  deg = round(arctan(1 / 1) * 180 / pi)
+        D135Pred = 4, // Directional 135 deg = 180 - 45
+        D117Pred = 5, // Directional 117 deg = 180 - 63
+        D153Pred = 6, // Directional 153 deg = 180 - 27
+        D207Pred = 7, // Directional 207 deg = 180 + 27
+        D63Pred = 8, // Directional 63  deg = round(arctan(2 / 1) * 180 / pi)
+        TmPred = 9, // True-motion
         NearestMv = 10,
         NearMv = 11,
         ZeroMv = 12,
         NewMv = 13,
-        MbModeCount = 14
+        MbModeCount = 14,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ReferenceMode.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ReferenceMode.cs
index 7cbf9f4e..5d9f189d 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ReferenceMode.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ReferenceMode.cs
@@ -5,6 +5,6 @@
         SingleReference = 0,
         CompoundReference = 1,
         ReferenceModeSelect = 2,
-        ReferenceModes = 3
+        ReferenceModes = 3,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ScaleFactors.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ScaleFactors.cs
index 970f9680..ba89d6e3 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ScaleFactors.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/ScaleFactors.cs
@@ -38,263 +38,255 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             int h,
             int bd);
 
-        private static readonly unsafe ConvolveFn[][][] PredictX16Y16 = new ConvolveFn[][][]
-        {
-            new ConvolveFn[][]
+        private static readonly unsafe ConvolveFn[][][] _predictX16Y16 = {
+            new[]
             {
                 new ConvolveFn[]
                 {
                     ConvolveCopy,
-                    ConvolveAvg
+                    ConvolveAvg,
                 },
                 new ConvolveFn[]
                 {
                     Convolve8Vert,
-                    Convolve8AvgVert
-                }
+                    Convolve8AvgVert,
+                },
             },
-            new ConvolveFn[][]
+            new[]
             {
                 new ConvolveFn[]
                 {
                     Convolve8Horiz,
-                    Convolve8AvgHoriz
+                    Convolve8AvgHoriz,
                 },
                 new ConvolveFn[]
                 {
                     Convolve8,
-                    Convolve8Avg
-                }
-            }
+                    Convolve8Avg,
+                },
+            },
         };
 
-        private static readonly unsafe ConvolveFn[][][] PredictX16 = new ConvolveFn[][][]
-        {
-            new ConvolveFn[][]
+        private static readonly unsafe ConvolveFn[][][] _predictX16 = {
+            new[]
             {
                 new ConvolveFn[]
                 {
                     ScaledVert,
-                    ScaledAvgVert
+                    ScaledAvgVert,
                 },
                 new ConvolveFn[]
                 {
                     ScaledVert,
-                    ScaledAvgVert
-                }
+                    ScaledAvgVert,
+                },
             },
-            new ConvolveFn[][]
+            new[]
             {
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
+                    ScaledAvg2D,
                 },
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
-                }
-            }
+                    ScaledAvg2D,
+                },
+            },
         };
 
-        private static readonly unsafe ConvolveFn[][][] PredictY16 = new ConvolveFn[][][]
-        {
-            new ConvolveFn[][]
+        private static readonly unsafe ConvolveFn[][][] _predictY16 = {
+            new[]
             {
                 new ConvolveFn[]
                 {
                     ScaledHoriz,
-                    ScaledAvgHoriz
+                    ScaledAvgHoriz,
                 },
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
-                }
+                    ScaledAvg2D,
+                },
             },
-            new ConvolveFn[][]
+            new[]
             {
                 new ConvolveFn[]
                 {
                     ScaledHoriz,
-                    ScaledAvgHoriz
+                    ScaledAvgHoriz,
                 },
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
-                }
-            }
+                    ScaledAvg2D,
+                },
+            },
         };
 
-        private static readonly unsafe ConvolveFn[][][] Predict = new ConvolveFn[][][]
-        {
-            new ConvolveFn[][]
+        private static readonly unsafe ConvolveFn[][][] _predict = {
+            new[]
             {
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
+                    ScaledAvg2D,
                 },
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
-                }
+                    ScaledAvg2D,
+                },
             },
-            new ConvolveFn[][]
+            new[]
             {
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
+                    ScaledAvg2D,
                 },
                 new ConvolveFn[]
                 {
                     Scaled2D,
-                    ScaledAvg2D
-                }
-            }
+                    ScaledAvg2D,
+                },
+            },
         };
 
-        private static readonly unsafe HighbdConvolveFn[][][] HighbdPredictX16Y16 = new HighbdConvolveFn[][][]
-        {
-            new HighbdConvolveFn[][]
+        private static readonly unsafe HighbdConvolveFn[][][] _highbdPredictX16Y16 = {
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolveCopy,
-                    HighbdConvolveAvg
+                    HighbdConvolveAvg,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Vert,
-                    HighbdConvolve8AvgVert
-                }
+                    HighbdConvolve8AvgVert,
+                },
             },
-            new HighbdConvolveFn[][]
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Horiz,
-                    HighbdConvolve8AvgHoriz
+                    HighbdConvolve8AvgHoriz,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
-            }
+                    HighbdConvolve8Avg,
+                },
+            },
         };
 
-        private static readonly unsafe HighbdConvolveFn[][][] HighbdPredictX16 = new HighbdConvolveFn[][][]
-        {
-            new HighbdConvolveFn[][]
+        private static readonly unsafe HighbdConvolveFn[][][] _highbdPredictX16 = {
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Vert,
-                    HighbdConvolve8AvgVert
+                    HighbdConvolve8AvgVert,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Vert,
-                    HighbdConvolve8AvgVert
-                }
+                    HighbdConvolve8AvgVert,
+                },
             },
-            new HighbdConvolveFn[][]
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
+                    HighbdConvolve8Avg,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
-            }
+                    HighbdConvolve8Avg,
+                },
+            },
         };
 
-        private static readonly unsafe HighbdConvolveFn[][][] HighbdPredictY16 = new HighbdConvolveFn[][][]
-        {
-            new HighbdConvolveFn[][]
+        private static readonly unsafe HighbdConvolveFn[][][] _highbdPredictY16 = {
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Horiz,
-                    HighbdConvolve8AvgHoriz
+                    HighbdConvolve8AvgHoriz,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
+                    HighbdConvolve8Avg,
+                },
             },
-            new HighbdConvolveFn[][]
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8Horiz,
-                    HighbdConvolve8AvgHoriz
+                    HighbdConvolve8AvgHoriz,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
-            }
+                    HighbdConvolve8Avg,
+                },
+            },
         };
 
-        private static readonly unsafe HighbdConvolveFn[][][] HighbdPredict = new HighbdConvolveFn[][][]
-        {
-            new HighbdConvolveFn[][]
+        private static readonly unsafe HighbdConvolveFn[][][] _highbdPredict = {
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
+                    HighbdConvolve8Avg,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
+                    HighbdConvolve8Avg,
+                },
             },
-            new HighbdConvolveFn[][]
+            new[]
             {
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
+                    HighbdConvolve8Avg,
                 },
                 new HighbdConvolveFn[]
                 {
                     HighbdConvolve8,
-                    HighbdConvolve8Avg
-                }
-            }
+                    HighbdConvolve8Avg,
+                },
+            },
         };
 
-        public int XScaleFP;  // Horizontal fixed point scale factor
-        public int YScaleFP;  // Vertical fixed point scale factor
+        public int XScaleFP; // Horizontal fixed point scale factor
+        public int YScaleFP; // Vertical fixed point scale factor
         public int XStepQ4;
         public int YStepQ4;
 
-        public int ScaleValueX(int val)
+        public readonly int ScaleValueX(int val)
         {
             return IsScaled() ? ScaledX(val) : val;
         }
 
-        public int ScaleValueY(int val)
+        public readonly int ScaleValueY(int val)
         {
             return IsScaled() ? ScaledY(val) : val;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void InterPredict(
+        public readonly unsafe void InterPredict(
             int horiz,
             int vert,
             int avg,
@@ -315,12 +307,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 if (YStepQ4 == 16)
                 {
                     // No scaling in either direction.
-                    PredictX16Y16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
+                    _predictX16Y16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
                 }
                 else
                 {
                     // No scaling in x direction. Must always scale in the y direction.
-                    PredictX16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
+                    _predictX16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
                 }
             }
             else
@@ -328,18 +320,18 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 if (YStepQ4 == 16)
                 {
                     // No scaling in the y direction. Must always scale in the x direction.
-                    PredictY16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
+                    _predictY16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
                 }
                 else
                 {
                     // Must always scale in both directions.
-                    Predict[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
+                    _predict[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h);
                 }
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void HighbdInterPredict(
+        public readonly unsafe void HighbdInterPredict(
             int horiz,
             int vert,
             int avg,
@@ -361,12 +353,12 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 if (YStepQ4 == 16)
                 {
                     // No scaling in either direction.
-                    HighbdPredictX16Y16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
+                    _highbdPredictX16Y16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
                 }
                 else
                 {
                     // No scaling in x direction. Must always scale in the y direction.
-                    HighbdPredictX16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
+                    _highbdPredictX16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
                 }
             }
             else
@@ -374,22 +366,22 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 if (YStepQ4 == 16)
                 {
                     // No scaling in the y direction. Must always scale in the x direction.
-                    HighbdPredictY16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
+                    _highbdPredictY16[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
                 }
                 else
                 {
                     // Must always scale in both directions.
-                    HighbdPredict[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
+                    _highbdPredict[horiz][vert][avg](src, srcStride, dst, dstStride, kernel, subpelX, xs, subpelY, ys, w, h, bd);
                 }
             }
         }
 
-        private int ScaledX(int val)
+        private readonly int ScaledX(int val)
         {
             return (int)((long)val * XScaleFP >> RefScaleShift);
         }
 
-        private int ScaledY(int val)
+        private readonly int ScaledY(int val)
         {
             return (int)((long)val * YScaleFP >> RefScaleShift);
         }
@@ -407,20 +399,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         {
             int xOffQ4 = ScaledX(x << SubpelBits) & SubpelMask;
             int yOffQ4 = ScaledY(y << SubpelBits) & SubpelMask;
-            Mv32 res = new Mv32()
+            Mv32 res = new()
             {
                 Row = ScaledY(mv.Row) + yOffQ4,
-                Col = ScaledX(mv.Col) + xOffQ4
+                Col = ScaledX(mv.Col) + xOffQ4,
             };
+
             return res;
         }
 
-        public bool IsValidScale()
+        public readonly bool IsValidScale()
         {
             return XScaleFP != RefInvalidScale && YScaleFP != RefInvalidScale;
         }
 
-        public bool IsScaled()
+        public readonly bool IsScaled()
         {
             return IsValidScale() && (XScaleFP != RefNoScale || YScaleFP != RefNoScale);
         }
@@ -439,6 +432,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             {
                 XScaleFP = RefInvalidScale;
                 YScaleFP = RefInvalidScale;
+
                 return;
             }
 
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/SegLvlFeatures.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/SegLvlFeatures.cs
index c3ea3fd8..8d04d18b 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/SegLvlFeatures.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/SegLvlFeatures.cs
@@ -2,10 +2,10 @@
 {
     internal enum SegLvlFeatures
     {
-        SegLvlAltQ = 0,      // Use alternate Quantizer ....
-        SegLvlAltLf = 1,     // Use alternate loop filter value...
-        SegLvlRefFrame = 2,  // Optional Segment reference frame
-        SegLvlSkip = 3,      // Optional Segment (0,0) + skip mode
-        SegLvlMax = 4        // Number of features supported
+        SegLvlAltQ = 0, // Use alternate Quantizer ....
+        SegLvlAltLf = 1, // Use alternate loop filter value...
+        SegLvlRefFrame = 2, // Optional Segment reference frame
+        SegLvlSkip = 3, // Optional Segment (0,0) + skip mode
+        SegLvlMax = 4, // Number of features supported
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Segmentation.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Segmentation.cs
index 53d1f2cc..c0fbdc51 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Segmentation.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Segmentation.cs
@@ -6,8 +6,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 {
     internal struct Segmentation
     {
-        private static readonly int[] SegFeatureDataSigned = new int[] { 1, 1, 0, 0 };
-        private static readonly int[] SegFeatureDataMax = new int[] { QuantCommon.MaxQ, Vp9.LoopFilter.MaxLoopFilter, 3, 0 };
+        private static readonly int[] _segFeatureDataSigned = { 1, 1, 0, 0 };
+        private static readonly int[] _segFeatureDataMax = { QuantCommon.MaxQ, Vp9.LoopFilter.MaxLoopFilter, 3, 0 };
 
         public bool Enabled;
         public bool UpdateMap;
@@ -26,8 +26,8 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public void ClearAllSegFeatures()
         {
-            MemoryMarshal.CreateSpan(ref FeatureData[0][0], 8 * 4).Fill(0);
-            MemoryMarshal.CreateSpan(ref FeatureMask[0], 8).Fill(0);
+            MemoryMarshal.CreateSpan(ref FeatureData[0][0], 8 * 4).Clear();
+            MemoryMarshal.CreateSpan(ref FeatureMask[0], 8).Clear();
             AqAvOffset = 0;
         }
 
@@ -38,21 +38,21 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         internal static int FeatureDataMax(SegLvlFeatures featureId)
         {
-            return SegFeatureDataMax[(int)featureId];
+            return _segFeatureDataMax[(int)featureId];
         }
 
         internal static int IsSegFeatureSigned(SegLvlFeatures featureId)
         {
-            return SegFeatureDataSigned[(int)featureId];
+            return _segFeatureDataSigned[(int)featureId];
         }
 
         internal void SetSegData(int segmentId, SegLvlFeatures featureId, int segData)
         {
-            Debug.Assert(segData <= SegFeatureDataMax[(int)featureId]);
+            Debug.Assert(segData <= _segFeatureDataMax[(int)featureId]);
             if (segData < 0)
             {
-                Debug.Assert(SegFeatureDataSigned[(int)featureId] != 0);
-                Debug.Assert(-segData <= SegFeatureDataMax[(int)featureId]);
+                Debug.Assert(_segFeatureDataSigned[(int)featureId] != 0);
+                Debug.Assert(-segData <= _segFeatureDataMax[(int)featureId]);
             }
 
             FeatureData[segmentId][(int)featureId] = (short)segData;
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Surface.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Surface.cs
index d5b51bc2..7f34faa5 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Surface.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Surface.cs
@@ -11,11 +11,11 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public ArrayPtr<byte> UBuffer;
         public ArrayPtr<byte> VBuffer;
 
-        public unsafe Plane YPlane => new Plane((IntPtr)YBuffer.ToPointer(), YBuffer.Length);
-        public unsafe Plane UPlane => new Plane((IntPtr)UBuffer.ToPointer(), UBuffer.Length);
-        public unsafe Plane VPlane => new Plane((IntPtr)VBuffer.ToPointer(), VBuffer.Length);
+        public readonly unsafe Plane YPlane => new((IntPtr)YBuffer.ToPointer(), YBuffer.Length);
+        public readonly unsafe Plane UPlane => new((IntPtr)UBuffer.ToPointer(), UBuffer.Length);
+        public readonly unsafe Plane VPlane => new((IntPtr)VBuffer.ToPointer(), VBuffer.Length);
 
-        public FrameField Field => FrameField.Progressive;
+        public readonly FrameField Field => FrameField.Progressive;
 
         public int Width { get; }
         public int Height { get; }
@@ -27,29 +27,31 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public int UvAlignedWidth { get; }
         public int UvAlignedHeight { get; }
         public int UvStride { get; }
-        public bool HighBd => false;
+
+        public bool HighBd { get; }
 
         private readonly IntPtr _pointer;
 
         public Surface(int width, int height)
         {
-            const int border = 32;
-            const int ssX = 1;
-            const int ssY = 1;
-            const bool highbd = false;
+            HighBd = false;
+
+            const int Border = 32;
+            const int SsX = 1;
+            const int SsY = 1;
 
             int alignedWidth = (width + 7) & ~7;
             int alignedHeight = (height + 7) & ~7;
-            int yStride = ((alignedWidth + 2 * border) + 31) & ~31;
-            int yplaneSize = (alignedHeight + 2 * border) * yStride;
-            int uvWidth = alignedWidth >> ssX;
-            int uvHeight = alignedHeight >> ssY;
-            int uvStride = yStride >> ssX;
-            int uvBorderW = border >> ssX;
-            int uvBorderH = border >> ssY;
+            int yStride = ((alignedWidth + 2 * Border) + 31) & ~31;
+            int yplaneSize = (alignedHeight + 2 * Border) * yStride;
+            int uvWidth = alignedWidth >> SsX;
+            int uvHeight = alignedHeight >> SsY;
+            int uvStride = yStride >> SsX;
+            int uvBorderW = Border >> SsX;
+            int uvBorderH = Border >> SsY;
             int uvplaneSize = (uvHeight + 2 * uvBorderH) * uvStride;
 
-            int frameSize = (highbd ? 2 : 1) * (yplaneSize + 2 * uvplaneSize);
+            int frameSize = (HighBd ? 2 : 1) * (yplaneSize + 2 * uvplaneSize);
 
             IntPtr pointer = Marshal.AllocHGlobal(frameSize);
             _pointer = pointer;
@@ -58,23 +60,23 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             AlignedWidth = alignedWidth;
             AlignedHeight = alignedHeight;
             Stride = yStride;
-            UvWidth = (width + ssX) >> ssX;
-            UvHeight = (height + ssY) >> ssY;
+            UvWidth = (width + SsX) >> SsX;
+            UvHeight = (height + SsY) >> SsY;
             UvAlignedWidth = uvWidth;
             UvAlignedHeight = uvHeight;
             UvStride = uvStride;
 
-            ArrayPtr<byte> NewPlane(int start, int size, int border)
+            ArrayPtr<byte> NewPlane(int start, int size, int planeBorder)
             {
-                return new ArrayPtr<byte>(pointer + start + border, size - border);
+                return new ArrayPtr<byte>(pointer + start + planeBorder, size - planeBorder);
             }
 
-            YBuffer = NewPlane(0, yplaneSize, (border * yStride) + border);
+            YBuffer = NewPlane(0, yplaneSize, (Border * yStride) + Border);
             UBuffer = NewPlane(yplaneSize, uvplaneSize, (uvBorderH * uvStride) + uvBorderW);
             VBuffer = NewPlane(yplaneSize + uvplaneSize, uvplaneSize, (uvBorderH * uvStride) + uvBorderW);
         }
 
-        public void Dispose()
+        public readonly void Dispose()
         {
             Marshal.FreeHGlobal(_pointer);
         }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TileInfo.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TileInfo.cs
index 67289c47..232d4ccb 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TileInfo.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TileInfo.cs
@@ -21,6 +21,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         {
             int sbCols = MiColsAlignedToSb(mis) >> Constants.MiBlockSizeLog2;
             int offset = ((idx * sbCols) >> log2) << Constants.MiBlockSizeLog2;
+
             return Math.Min(offset, mis);
         }
 
@@ -44,7 +45,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         // Checks that the given miRow, miCol and search point
         // are inside the borders of the tile.
-        public bool IsInside(int miCol, int miRow, int miRows, ref Position miPos)
+        public readonly bool IsInside(int miCol, int miRow, int miRows, ref Position miPos)
         {
             return !(miRow + miPos.Row < 0 ||
                      miCol + miPos.Col < MiColStart ||
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxMode.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxMode.cs
index db914525..80c963fe 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxMode.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxMode.cs
@@ -2,11 +2,11 @@
 {
     public enum TxMode
     {
-        Only4X4 = 0,      // Only 4x4 transform used
-        Allow8X8 = 1,     // Allow block transform size up to 8x8
-        Allow16X16 = 2,   // Allow block transform size up to 16x16
-        Allow32X32 = 3,   // Allow block transform size up to 32x32
+        Only4X4 = 0, // Only 4x4 transform used
+        Allow8X8 = 1, // Allow block transform size up to 8x8
+        Allow16X16 = 2, // Allow block transform size up to 16x16
+        Allow32X32 = 3, // Allow block transform size up to 32x32
         TxModeSelect = 4, // Transform specified for each block
-        TxModes = 5
+        TxModes = 5,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxSize.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxSize.cs
index 994deb2c..bcc70eba 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxSize.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxSize.cs
@@ -2,10 +2,10 @@
 {
     public enum TxSize
     {
-        Tx4x4 = 0,   // 4x4 transform
-        Tx8x8 = 1,   // 8x8 transform
+        Tx4x4 = 0, // 4x4 transform
+        Tx8x8 = 1, // 8x8 transform
         Tx16x16 = 2, // 16x16 transform
         Tx32x32 = 3, // 32x32 transform
-        TxSizes = 4
+        TxSizes = 4,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxType.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxType.cs
index dbf7251c..1ae436e9 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxType.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/TxType.cs
@@ -2,10 +2,10 @@
 {
     internal enum TxType
     {
-        DctDct = 0,   // DCT  in both horizontal and vertical
-        AdstDct = 1,  // ADST in vertical, DCT in horizontal
-        DctAdst = 2,  // DCT  in vertical, ADST in horizontal
+        DctDct = 0, // DCT  in both horizontal and vertical
+        AdstDct = 1, // ADST in vertical, DCT in horizontal
+        DctAdst = 2, // DCT  in vertical, ADST in horizontal
         AdstAdst = 3, // ADST in both directions
-        TxTypes = 4
+        TxTypes = 4,
     }
 }
diff --git a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Common.cs b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Common.cs
index faadd349..8dd0879e 100644
--- a/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Common.cs
+++ b/src/Ryujinx.Graphics.Nvdec.Vp9/Types/Vp9Common.cs
@@ -88,7 +88,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
         public ArrayPtr<sbyte> AboveSegContext;
         public ArrayPtr<sbyte> AboveContext;
 
-        public bool FrameIsIntraOnly()
+        public readonly bool FrameIsIntraOnly()
         {
             return FrameType == FrameType.KeyFrame || IntraOnly;
         }
@@ -132,7 +132,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             TileWorkerData = allocator.Allocate<TileWorkerData>(tileCols * tileRows + (maxThreads > 1 ? maxThreads : 0));
         }
 
-        public void FreeTileWorkerData(MemoryAllocator allocator)
+        public readonly void FreeTileWorkerData(MemoryAllocator allocator)
         {
             allocator.Free(TileWorkerData);
         }
@@ -257,7 +257,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
             }
         }
 
-        private void SetPartitionProbs(ref MacroBlockD xd)
+        private readonly void SetPartitionProbs(ref MacroBlockD xd)
         {
             xd.PartitionProbs = FrameIsIntraOnly()
                 ? new ArrayPtr<Array3<byte>>(ref Fc.Value.KfPartitionProb[0], 16)
@@ -293,7 +293,7 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
 
         public void SetupSegmentationDequant()
         {
-            const BitDepth bitDepth = BitDepth.Bits8; // TODO: Configurable
+            const BitDepth BitDepth = BitDepth.Bits8; // TODO: Configurable
             // Build y/uv dequant values based on segmentation.
             if (Seg.Enabled)
             {
@@ -301,10 +301,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 for (i = 0; i < Constants.MaxSegments; ++i)
                 {
                     int qIndex = QuantCommon.GetQIndex(ref Seg, i, BaseQindex);
-                    YDequant[i][0] = QuantCommon.DcQuant(qIndex, YDcDeltaQ, bitDepth);
-                    YDequant[i][1] = QuantCommon.AcQuant(qIndex, 0, bitDepth);
-                    UvDequant[i][0] = QuantCommon.DcQuant(qIndex, UvDcDeltaQ, bitDepth);
-                    UvDequant[i][1] = QuantCommon.AcQuant(qIndex, UvAcDeltaQ, bitDepth);
+                    YDequant[i][0] = QuantCommon.DcQuant(qIndex, YDcDeltaQ, BitDepth);
+                    YDequant[i][1] = QuantCommon.AcQuant(qIndex, 0, BitDepth);
+                    UvDequant[i][0] = QuantCommon.DcQuant(qIndex, UvDcDeltaQ, BitDepth);
+                    UvDequant[i][1] = QuantCommon.AcQuant(qIndex, UvAcDeltaQ, BitDepth);
                 }
             }
             else
@@ -312,10 +312,10 @@ namespace Ryujinx.Graphics.Nvdec.Vp9.Types
                 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);
-                YDequant[0][1] = QuantCommon.AcQuant(qIndex, 0, bitDepth);
-                UvDequant[0][0] = QuantCommon.DcQuant(qIndex, UvDcDeltaQ, bitDepth);
-                UvDequant[0][1] = QuantCommon.AcQuant(qIndex, UvAcDeltaQ, bitDepth);
+                YDequant[0][0] = QuantCommon.DcQuant(qIndex, YDcDeltaQ, BitDepth);
+                YDequant[0][1] = QuantCommon.AcQuant(qIndex, 0, BitDepth);
+                UvDequant[0][0] = QuantCommon.DcQuant(qIndex, UvDcDeltaQ, BitDepth);
+                UvDequant[0][1] = QuantCommon.AcQuant(qIndex, UvAcDeltaQ, BitDepth);
             }
         }