Make Astc use safe code

ds5678 · ds5678 · commit 12c6750a8895 · 2023-11-16T19:58:47.000-05:00
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.BlockData.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.BlockData.cs
@@ -1,30 +1,35 @@
-﻿namespace AssetRipper.TextureDecoder.Astc
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
 {
-	public static partial class AstcDecoder
+	private struct BlockData
 	{
-		private unsafe struct BlockData
-		{
-			public int bw;
-			public int bh;
-			public int width;
-			public int height;
-			public int part_num;
-			public int dual_plane;
-			public int plane_selector;
-			public int weight_range;
-			/// <summary>
-			/// max: 120
-			/// </summary>
-			public int weight_num;
-			public fixed int cem[4];
-			public int cem_range;
-			/// <summary>
-			/// max: 32
-			/// </summary>
-			public int endpoint_value_num;
-			public fixed int endpoints[4 * 8];
-			public fixed int weights[144 * 2];
-			public fixed int partition[144];
-		}
+		public int bw;
+		public int bh;
+		public int width;
+		public int height;
+		public int part_num;
+		public int dual_plane;
+		public int plane_selector;
+		public int weight_range;
+		/// <summary>
+		/// max: 120
+		/// </summary>
+		public int weight_num;
+		public IntBuffer4 cem;
+		public int cem_range;
+		/// <summary>
+		/// max: 32
+		/// </summary>
+		public int endpoint_value_num;
+		/// <summary>
+		/// 4 * 8
+		/// </summary>
+		public EndpointBuffer endpoints;
+		/// <summary>
+		/// 144 * 2
+		/// </summary>
+		public IntBuffer288 weights;
+		public IntBuffer144 partition;
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.EndpointBuffer.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.EndpointBuffer.cs
@@ -0,0 +1,16 @@
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
+{
+	[InlineArray(4)]
+	private struct EndpointBuffer
+	{
+		private Endpoint _element0;
+
+		[InlineArray(8)]
+		public struct Endpoint
+		{
+			private int _element0;
+		}
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer144.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer144.cs
@@ -0,0 +1,10 @@
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
+{
+	[InlineArray(144)]
+	private struct IntBuffer144
+	{
+		private int _element0;
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer288.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer288.cs
@@ -0,0 +1,10 @@
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
+{
+	[InlineArray(288)]
+	private struct IntBuffer288
+	{
+		private int _element0;
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer4.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntBuffer4.cs
@@ -0,0 +1,10 @@
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
+{
+	[InlineArray(4)]
+	private struct IntBuffer4
+	{
+		private int _element0;
+	}
+}
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntSeqData.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.IntSeqData.cs
@@ -1,11 +1,10 @@
-﻿namespace AssetRipper.TextureDecoder.Astc
+﻿namespace AssetRipper.TextureDecoder.Astc;
+
+public static partial class AstcDecoder
 {
-	public static partial class AstcDecoder
+	private struct IntSeqData
 	{
-		private struct IntSeqData
-		{
-			public int bits;
-			public int nonbits;
-		}
+		public int bits;
+		public int nonbits;
 	}
 }
diff --git a/AssetRipper.TextureDecoder/Astc/AstcDecoder.cs b/AssetRipper.TextureDecoder/Astc/AstcDecoder.cs
@@ -52,7 +52,7 @@ static void WriteUInt32(Span<byte> buffer, int offsetUInt32, uint value)
 			}
 		}
 
-		private unsafe static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth, int blockHeight, Span<uint> output)
+		private static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth, int blockHeight, Span<uint> output)
 		{
 			if (input[0] == 0xfc && (input[1] & 1) == 1)
 			{
@@ -78,7 +78,7 @@ private unsafe static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth,
 			}
 		}
 
-		private unsafe static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref BlockData pBlock)
+		private static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref BlockData pBlock)
 		{
 			pBlock.dual_plane = (input[1] & 4) >> 2;
 			pBlock.weight_range = (input[0] >> 4 & 1) | (input[1] << 2 & 8);
@@ -231,7 +231,7 @@ private unsafe static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref B
 			}
 		}
 
-		private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockData pBlock)
+		private static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockData pBlock)
 		{
 			Span<IntSeqData> epSeq = stackalloc IntSeqData[32];
 			DecodeIntseq(input, pBlock.part_num == 1 ? 17 : 29, CemTableA[pBlock.cem_range], CemTableB[pBlock.cem_range], pBlock.endpoint_value_num, false, epSeq);
@@ -352,61 +352,40 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 			}
 
 			Span<int> v = ev;
-			for (int cem = 0, cemOff = 0; cem < pBlock.part_num; v = v.Slice((pBlock.cem[cem] / 4 + 1) * 2), cem++, cemOff += 8)
+			for (int cem = 0; cem < pBlock.part_num; v = v.Slice((pBlock.cem[cem] / 4 + 1) * 2), cem++)
 			{
 				switch (pBlock.cem[cem])
 				{
 					case 0:
-						fixed (int* endpoint = &pBlock.endpoints[cemOff])
-						{
-							SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);
-						}
+						SetEndpoint(pBlock.endpoints[cem], v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);
 						break;
 					case 1:
 						{
 							int l0 = (v[0] >> 2) | (v[1] & 0xc0);
 							int l1 = Clamp(l0 + (v[1] & 0x3f));
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpoint(new Span<int>(endpoint, 8), l0, l0, l0, 255, l1, l1, l1, 255);
-							}
+							SetEndpoint(pBlock.endpoints[cem], l0, l0, l0, 255, l1, l1, l1, 255);
 						}
 						break;
 					case 4:
-						fixed (int* endpoint = &pBlock.endpoints[cemOff])
-						{
-							SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);
-						}
+						SetEndpoint(pBlock.endpoints[cem], v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);
 						break;
 					case 5:
 						BitTransferSigned(ref v[1], ref v[0]);
 						BitTransferSigned(ref v[3], ref v[2]);
 						v[1] += v[0];
-						fixed (int* endpoint = &pBlock.endpoints[cemOff])
-						{
-							SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);
-						}
+						SetEndpointClamp(pBlock.endpoints[cem], v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);
 						break;
 					case 6:
-						fixed (int* endpoint = &pBlock.endpoints[cemOff])
-						{
-							SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);
-						}
+						SetEndpoint(pBlock.endpoints[cem], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);
 						break;
 					case 8:
 						if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);
-							}
+							SetEndpoint(pBlock.endpoints[cem], v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);
 						}
 						else
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);
-							}
+							SetEndpointBlue(pBlock.endpoints[cem], v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);
 						}
 
 						break;
@@ -416,40 +395,25 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 						BitTransferSigned(ref v[5], ref v[4]);
 						if (v[1] + v[3] + v[5] >= 0)
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);
-							}
+							SetEndpointClamp(pBlock.endpoints[cem], v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);
 						}
 						else
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);
-							}
+							SetEndpointBlueClamp(pBlock.endpoints[cem], v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);
 						}
 
 						break;
 					case 10:
-						fixed (int* endpoint = &pBlock.endpoints[cemOff])
-						{
-							SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);
-						}
+						SetEndpoint(pBlock.endpoints[cem], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);
 						break;
 					case 12:
 						if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);
-							}
+							SetEndpoint(pBlock.endpoints[cem], v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);
 						}
 						else
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);
-							}
+							SetEndpointBlue(pBlock.endpoints[cem], v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);
 						}
 
 						break;
@@ -460,25 +424,19 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa
 						BitTransferSigned(ref v[7], ref v[6]);
 						if (v[1] + v[3] + v[5] >= 0)
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);
-							}
+							SetEndpointClamp(pBlock.endpoints[cem], v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);
 						}
 						else
 						{
-							fixed (int* endpoint = &pBlock.endpoints[cemOff])
-							{
-								SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);
-							}
+							SetEndpointBlueClamp(pBlock.endpoints[cem], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);
 						}
 
 						break;
 				}
 			}
 		}
 
-		private unsafe static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData block)
+		private static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData block)
 		{
 			Span<IntSeqData> wSeq = stackalloc IntSeqData[128];
 			DecodeIntseq(input, 128, WeightPrecTableA[block.weight_range], WeightPrecTableB[block.weight_range], block.weight_num, true, wSeq);
@@ -634,7 +592,7 @@ private unsafe static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData
 			}
 		}
 
-		private unsafe static void SelectPartition(ReadOnlySpan<byte> input, ref BlockData block)
+		private static void SelectPartition(ReadOnlySpan<byte> input, ref BlockData block)
 		{
 			bool small_block = block.bw * block.bh < 31;
 			int seed = (BinaryPrimitives.ReadInt32LittleEndian(input) >> 13 & 0x3ff) | (block.part_num - 1) << 10;
@@ -716,7 +674,7 @@ private unsafe static void SelectPartition(ReadOnlySpan<byte> input, ref BlockDa
 			}
 		}
 
-		private unsafe static void ApplicateColor(BlockData block, Span<uint> output)
+		private static void ApplicateColor(BlockData block, Span<uint> output)
 		{
 			if (block.dual_plane != 0)
 			{
@@ -727,21 +685,21 @@ private unsafe static void ApplicateColor(BlockData block, Span<uint> output)
 					for (int i = 0; i < block.bw * block.bh; i++)
 					{
 						int p = block.partition[i];
-						byte r = SelectColor(block.endpoints[p * 8 + 0], block.endpoints[p * 8 + 4], block.weights[i * 2 + ps[0]]);
-						byte g = SelectColor(block.endpoints[p * 8 + 1], block.endpoints[p * 8 + 5], block.weights[i * 2 + ps[1]]);
-						byte b = SelectColor(block.endpoints[p * 8 + 2], block.endpoints[p * 8 + 6], block.weights[i * 2 + ps[2]]);
-						byte a = SelectColor(block.endpoints[p * 8 + 3], block.endpoints[p * 8 + 7], block.weights[i * 2 + ps[3]]);
+						byte r = SelectColor(block.endpoints[p][0], block.endpoints[p][4], block.weights[i * 2 + ps[0]]);
+						byte g = SelectColor(block.endpoints[p][1], block.endpoints[p][5], block.weights[i * 2 + ps[1]]);
+						byte b = SelectColor(block.endpoints[p][2], block.endpoints[p][6], block.weights[i * 2 + ps[2]]);
+						byte a = SelectColor(block.endpoints[p][3], block.endpoints[p][7], block.weights[i * 2 + ps[3]]);
 						output[i] = Color(r, g, b, a);
 					}
 				}
 				else
 				{
 					for (int i = 0; i < block.bw * block.bh; i++)
 					{
-						byte r = SelectColor(block.endpoints[0], block.endpoints[4], block.weights[i * 2 + ps[0]]);
-						byte g = SelectColor(block.endpoints[1], block.endpoints[5], block.weights[i * 2 + ps[1]]);
-						byte b = SelectColor(block.endpoints[2], block.endpoints[6], block.weights[i * 2 + ps[2]]);
-						byte a = SelectColor(block.endpoints[3], block.endpoints[7], block.weights[i * 2 + ps[3]]);
+						byte r = SelectColor(block.endpoints[0][0], block.endpoints[0][4], block.weights[i * 2 + ps[0]]);
+						byte g = SelectColor(block.endpoints[0][1], block.endpoints[0][5], block.weights[i * 2 + ps[1]]);
+						byte b = SelectColor(block.endpoints[0][2], block.endpoints[0][6], block.weights[i * 2 + ps[2]]);
+						byte a = SelectColor(block.endpoints[0][3], block.endpoints[0][7], block.weights[i * 2 + ps[3]]);
 						output[i] = Color(r, g, b, a);
 					}
 				}
@@ -751,21 +709,21 @@ private unsafe static void ApplicateColor(BlockData block, Span<uint> output)
 				for (int i = 0; i < block.bw * block.bh; i++)
 				{
 					int p = block.partition[i];
-					byte r = SelectColor(block.endpoints[p * 8 + 0], block.endpoints[p * 8 + 4], block.weights[i * 2]);
-					byte g = SelectColor(block.endpoints[p * 8 + 1], block.endpoints[p * 8 + 5], block.weights[i * 2]);
-					byte b = SelectColor(block.endpoints[p * 8 + 2], block.endpoints[p * 8 + 6], block.weights[i * 2]);
-					byte a = SelectColor(block.endpoints[p * 8 + 3], block.endpoints[p * 8 + 7], block.weights[i * 2]);
+					byte r = SelectColor(block.endpoints[p][0], block.endpoints[p][4], block.weights[i * 2]);
+					byte g = SelectColor(block.endpoints[p][1], block.endpoints[p][5], block.weights[i * 2]);
+					byte b = SelectColor(block.endpoints[p][2], block.endpoints[p][6], block.weights[i * 2]);
+					byte a = SelectColor(block.endpoints[p][3], block.endpoints[p][7], block.weights[i * 2]);
 					output[i] = Color(r, g, b, a);
 				}
 			}
 			else
 			{
 				for (int i = 0; i < block.bw * block.bh; i++)
 				{
-					byte r = SelectColor(block.endpoints[0], block.endpoints[4], block.weights[i * 2]);
-					byte g = SelectColor(block.endpoints[1], block.endpoints[5], block.weights[i * 2]);
-					byte b = SelectColor(block.endpoints[2], block.endpoints[6], block.weights[i * 2]);
-					byte a = SelectColor(block.endpoints[3], block.endpoints[7], block.weights[i * 2]);
+					byte r = SelectColor(block.endpoints[0][0], block.endpoints[0][4], block.weights[i * 2]);
+					byte g = SelectColor(block.endpoints[0][1], block.endpoints[0][5], block.weights[i * 2]);
+					byte b = SelectColor(block.endpoints[0][2], block.endpoints[0][6], block.weights[i * 2]);
+					byte a = SelectColor(block.endpoints[0][3], block.endpoints[0][7], block.weights[i * 2]);
 					output[i] = Color(r, g, b, a);
 				}
 			}

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,10 @@`
`1`		`-namespace AssetRipper.TextureDecoder.Astc`
	`1`	`+namespace AssetRipper.TextureDecoder.Astc;`
	`2`	`+`
	`3`	`+public static partial class AstcDecoder`
`2`	`4`	`{`
`3`		`- public static partial class AstcDecoder`
	`5`	`+ private struct IntSeqData`
`4`	`6`	`{`
`5`		`- private struct IntSeqData`
`6`		`- {`
`7`		`- public int bits;`
`8`		`- public int nonbits;`
`9`		`- }`
	`7`	`+ public int bits;`
	`8`	`+ public int nonbits;`
`10`	`9`	`}`
`11`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ static void WriteUInt32(Span<byte> buffer, int offsetUInt32, uint value)`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- private unsafe static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth, int blockHeight, Span<uint> output)`
	`55`	`+ private static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth, int blockHeight, Span<uint> output)`
`56`	`56`	`{`
`57`	`57`	`if (input[0] == 0xfc && (input[1] & 1) == 1)`
`58`	`58`	`{`
`@@ -78,7 +78,7 @@ private unsafe static void DecodeBlock(ReadOnlySpan<byte> input, int blockWidth,`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`81`		`- private unsafe static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref BlockData pBlock)`
	`81`	`+ private static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref BlockData pBlock)`
`82`	`82`	`{`
`83`	`83`	`pBlock.dual_plane = (input[1] & 4) >> 2;`
`84`	`84`	`pBlock.weight_range = (input[0] >> 4 & 1) \| (input[1] << 2 & 8);`
`@@ -231,7 +231,7 @@ private unsafe static void DecodeBlockParameters(ReadOnlySpan<byte> input, ref B`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`234`		`- private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockData pBlock)`
	`234`	`+ private static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockData pBlock)`
`235`	`235`	`{`
`236`	`236`	`Span<IntSeqData> epSeq = stackalloc IntSeqData[32];`
`237`	`237`	`DecodeIntseq(input, pBlock.part_num == 1 ? 17 : 29, CemTableA[pBlock.cem_range], CemTableB[pBlock.cem_range], pBlock.endpoint_value_num, false, epSeq);`
`@@ -352,61 +352,40 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`Span<int> v = ev;`
`355`		`- for (int cem = 0, cemOff = 0; cem < pBlock.part_num; v = v.Slice((pBlock.cem[cem] / 4 + 1) * 2), cem++, cemOff += 8)`
	`355`	`+ for (int cem = 0; cem < pBlock.part_num; v = v.Slice((pBlock.cem[cem] / 4 + 1) * 2), cem++)`
`356`	`356`	`{`
`357`	`357`	`switch (pBlock.cem[cem])`
`358`	`358`	`{`
`359`	`359`	`case 0:`
`360`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`361`		`- {`
`362`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);`
`363`		`- }`
	`360`	`+ SetEndpoint(pBlock.endpoints[cem], v[0], v[0], v[0], 255, v[1], v[1], v[1], 255);`
`364`	`361`	`break;`
`365`	`362`	`case 1:`
`366`	`363`	`{`
`367`	`364`	`int l0 = (v[0] >> 2) \| (v[1] & 0xc0);`
`368`	`365`	`int l1 = Clamp(l0 + (v[1] & 0x3f));`
`369`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`370`		`- {`
`371`		`- SetEndpoint(new Span<int>(endpoint, 8), l0, l0, l0, 255, l1, l1, l1, 255);`
`372`		`- }`
	`366`	`+ SetEndpoint(pBlock.endpoints[cem], l0, l0, l0, 255, l1, l1, l1, 255);`
`373`	`367`	`}`
`374`	`368`	`break;`
`375`	`369`	`case 4:`
`376`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`377`		`- {`
`378`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);`
`379`		`- }`
	`370`	`+ SetEndpoint(pBlock.endpoints[cem], v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[3]);`
`380`	`371`	`break;`
`381`	`372`	`case 5:`
`382`	`373`	`BitTransferSigned(ref v[1], ref v[0]);`
`383`	`374`	`BitTransferSigned(ref v[3], ref v[2]);`
`384`	`375`	`v[1] += v[0];`
`385`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`386`		`- {`
`387`		`- SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);`
`388`		`- }`
	`376`	`+ SetEndpointClamp(pBlock.endpoints[cem], v[0], v[0], v[0], v[2], v[1], v[1], v[1], v[2] + v[3]);`
`389`	`377`	`break;`
`390`	`378`	`case 6:`
`391`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`392`		`- {`
`393`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);`
`394`		`- }`
	`379`	`+ SetEndpoint(pBlock.endpoints[cem], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, 255, v[0], v[1], v[2], 255);`
`395`	`380`	`break;`
`396`	`381`	`case 8:`
`397`	`382`	`if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])`
`398`	`383`	`{`
`399`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`400`		`- {`
`401`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);`
`402`		`- }`
	`384`	`+ SetEndpoint(pBlock.endpoints[cem], v[0], v[2], v[4], 255, v[1], v[3], v[5], 255);`
`403`	`385`	`}`
`404`	`386`	`else`
`405`	`387`	`{`
`406`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`407`		`- {`
`408`		`- SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);`
`409`		`- }`
	`388`	`+ SetEndpointBlue(pBlock.endpoints[cem], v[1], v[3], v[5], 255, v[0], v[2], v[4], 255);`
`410`	`389`	`}`
`411`	`390`
`412`	`391`	`break;`
`@@ -416,40 +395,25 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`416`	`395`	`BitTransferSigned(ref v[5], ref v[4]);`
`417`	`396`	`if (v[1] + v[3] + v[5] >= 0)`
`418`	`397`	`{`
`419`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`420`		`- {`
`421`		`- SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);`
`422`		`- }`
	`398`	`+ SetEndpointClamp(pBlock.endpoints[cem], v[0], v[2], v[4], 255, v[0] + v[1], v[2] + v[3], v[4] + v[5], 255);`
`423`	`399`	`}`
`424`	`400`	`else`
`425`	`401`	`{`
`426`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`427`		`- {`
`428`		`- SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);`
`429`		`- }`
	`402`	`+ SetEndpointBlueClamp(pBlock.endpoints[cem], v[0] + v[1], v[2] + v[3], v[4] + v[5], 255, v[0], v[2], v[4], 255);`
`430`	`403`	`}`
`431`	`404`
`432`	`405`	`break;`
`433`	`406`	`case 10:`
`434`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`435`		`- {`
`436`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);`
`437`		`- }`
	`407`	`+ SetEndpoint(pBlock.endpoints[cem], v[0] * v[3] >> 8, v[1] * v[3] >> 8, v[2] * v[3] >> 8, v[4], v[0], v[1], v[2], v[5]);`
`438`	`408`	`break;`
`439`	`409`	`case 12:`
`440`	`410`	`if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5])`
`441`	`411`	`{`
`442`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`443`		`- {`
`444`		`- SetEndpoint(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);`
`445`		`- }`
	`412`	`+ SetEndpoint(pBlock.endpoints[cem], v[0], v[2], v[4], v[6], v[1], v[3], v[5], v[7]);`
`446`	`413`	`}`
`447`	`414`	`else`
`448`	`415`	`{`
`449`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`450`		`- {`
`451`		`- SetEndpointBlue(new Span<int>(endpoint, 8), v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);`
`452`		`- }`
	`416`	`+ SetEndpointBlue(pBlock.endpoints[cem], v[1], v[3], v[5], v[7], v[0], v[2], v[4], v[6]);`
`453`	`417`	`}`
`454`	`418`
`455`	`419`	`break;`
`@@ -460,25 +424,19 @@ private unsafe static void DecodeEndpoints(ReadOnlySpan<byte> input, ref BlockDa`
`460`	`424`	`BitTransferSigned(ref v[7], ref v[6]);`
`461`	`425`	`if (v[1] + v[3] + v[5] >= 0)`
`462`	`426`	`{`
`463`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`464`		`- {`
`465`		`- SetEndpointClamp(new Span<int>(endpoint, 8), v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);`
`466`		`- }`
	`427`	`+ SetEndpointClamp(pBlock.endpoints[cem], v[0], v[2], v[4], v[6], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7]);`
`467`	`428`	`}`
`468`	`429`	`else`
`469`	`430`	`{`
`470`		`- fixed (int* endpoint = &pBlock.endpoints[cemOff])`
`471`		`- {`
`472`		`- SetEndpointBlueClamp(new Span<int>(endpoint, 8), v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);`
`473`		`- }`
	`431`	`+ SetEndpointBlueClamp(pBlock.endpoints[cem], v[0] + v[1], v[2] + v[3], v[4] + v[5], v[6] + v[7], v[0], v[2], v[4], v[6]);`
`474`	`432`	`}`
`475`	`433`
`476`	`434`	`break;`
`477`	`435`	`}`
`478`	`436`	`}`
`479`	`437`	`}`
`480`	`438`
`481`		`- private unsafe static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData block)`
	`439`	`+ private static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData block)`
`482`	`440`	`{`
`483`	`441`	`Span<IntSeqData> wSeq = stackalloc IntSeqData[128];`
`484`	`442`	`DecodeIntseq(input, 128, WeightPrecTableA[block.weight_range], WeightPrecTableB[block.weight_range], block.weight_num, true, wSeq);`
`@@ -634,7 +592,7 @@ private unsafe static void DecodeWeights(ReadOnlySpan<byte> input, ref BlockData`
`634`	`592`	`}`
`635`	`593`	`}`
`636`	`594`
`637`		`- private unsafe static void SelectPartition(ReadOnlySpan<byte> input, ref BlockData block)`
	`595`	`+ private static void SelectPartition(ReadOnlySpan<byte> input, ref BlockData block)`
`638`	`596`	`{`
`639`	`597`	`bool small_block = block.bw * block.bh < 31;`
`640`	`598`	`int seed = (BinaryPrimitives.ReadInt32LittleEndian(input) >> 13 & 0x3ff) \| (block.part_num - 1) << 10;`
`@@ -716,7 +674,7 @@ private unsafe static void SelectPartition(ReadOnlySpan<byte> input, ref BlockDa`
`716`	`674`	`}`
`717`	`675`	`}`
`718`	`676`
`719`		`- private unsafe static void ApplicateColor(BlockData block, Span<uint> output)`
	`677`	`+ private static void ApplicateColor(BlockData block, Span<uint> output)`
`720`	`678`	`{`
`721`	`679`	`if (block.dual_plane != 0)`
`722`	`680`	`{`
`@@ -727,21 +685,21 @@ private unsafe static void ApplicateColor(BlockData block, Span<uint> output)`
`727`	`685`	`for (int i = 0; i < block.bw * block.bh; i++)`
`728`	`686`	`{`
`729`	`687`	`int p = block.partition[i];`
`730`		`- byte r = SelectColor(block.endpoints[p * 8 + 0], block.endpoints[p * 8 + 4], block.weights[i * 2 + ps[0]]);`
`731`		`- byte g = SelectColor(block.endpoints[p * 8 + 1], block.endpoints[p * 8 + 5], block.weights[i * 2 + ps[1]]);`
`732`		`- byte b = SelectColor(block.endpoints[p * 8 + 2], block.endpoints[p * 8 + 6], block.weights[i * 2 + ps[2]]);`
`733`		`- byte a = SelectColor(block.endpoints[p * 8 + 3], block.endpoints[p * 8 + 7], block.weights[i * 2 + ps[3]]);`
	`688`	`+ byte r = SelectColor(block.endpoints[p][0], block.endpoints[p][4], block.weights[i * 2 + ps[0]]);`
	`689`	`+ byte g = SelectColor(block.endpoints[p][1], block.endpoints[p][5], block.weights[i * 2 + ps[1]]);`
	`690`	`+ byte b = SelectColor(block.endpoints[p][2], block.endpoints[p][6], block.weights[i * 2 + ps[2]]);`
	`691`	`+ byte a = SelectColor(block.endpoints[p][3], block.endpoints[p][7], block.weights[i * 2 + ps[3]]);`
`734`	`692`	`output[i] = Color(r, g, b, a);`
`735`	`693`	`}`
`736`	`694`	`}`
`737`	`695`	`else`
`738`	`696`	`{`
`739`	`697`	`for (int i = 0; i < block.bw * block.bh; i++)`
`740`	`698`	`{`
`741`		`- byte r = SelectColor(block.endpoints[0], block.endpoints[4], block.weights[i * 2 + ps[0]]);`
`742`		`- byte g = SelectColor(block.endpoints[1], block.endpoints[5], block.weights[i * 2 + ps[1]]);`
`743`		`- byte b = SelectColor(block.endpoints[2], block.endpoints[6], block.weights[i * 2 + ps[2]]);`
`744`		`- byte a = SelectColor(block.endpoints[3], block.endpoints[7], block.weights[i * 2 + ps[3]]);`
	`699`	`+ byte r = SelectColor(block.endpoints[0][0], block.endpoints[0][4], block.weights[i * 2 + ps[0]]);`
	`700`	`+ byte g = SelectColor(block.endpoints[0][1], block.endpoints[0][5], block.weights[i * 2 + ps[1]]);`
	`701`	`+ byte b = SelectColor(block.endpoints[0][2], block.endpoints[0][6], block.weights[i * 2 + ps[2]]);`
	`702`	`+ byte a = SelectColor(block.endpoints[0][3], block.endpoints[0][7], block.weights[i * 2 + ps[3]]);`
`745`	`703`	`output[i] = Color(r, g, b, a);`
`746`	`704`	`}`
`747`	`705`	`}`
`@@ -751,21 +709,21 @@ private unsafe static void ApplicateColor(BlockData block, Span<uint> output)`
`751`	`709`	`for (int i = 0; i < block.bw * block.bh; i++)`
`752`	`710`	`{`
`753`	`711`	`int p = block.partition[i];`
`754`		`- byte r = SelectColor(block.endpoints[p * 8 + 0], block.endpoints[p * 8 + 4], block.weights[i * 2]);`
`755`		`- byte g = SelectColor(block.endpoints[p * 8 + 1], block.endpoints[p * 8 + 5], block.weights[i * 2]);`
`756`		`- byte b = SelectColor(block.endpoints[p * 8 + 2], block.endpoints[p * 8 + 6], block.weights[i * 2]);`
`757`		`- byte a = SelectColor(block.endpoints[p * 8 + 3], block.endpoints[p * 8 + 7], block.weights[i * 2]);`
	`712`	`+ byte r = SelectColor(block.endpoints[p][0], block.endpoints[p][4], block.weights[i * 2]);`
	`713`	`+ byte g = SelectColor(block.endpoints[p][1], block.endpoints[p][5], block.weights[i * 2]);`
	`714`	`+ byte b = SelectColor(block.endpoints[p][2], block.endpoints[p][6], block.weights[i * 2]);`
	`715`	`+ byte a = SelectColor(block.endpoints[p][3], block.endpoints[p][7], block.weights[i * 2]);`
`758`	`716`	`output[i] = Color(r, g, b, a);`
`759`	`717`	`}`
`760`	`718`	`}`
`761`	`719`	`else`
`762`	`720`	`{`
`763`	`721`	`for (int i = 0; i < block.bw * block.bh; i++)`
`764`	`722`	`{`
`765`		`- byte r = SelectColor(block.endpoints[0], block.endpoints[4], block.weights[i * 2]);`
`766`		`- byte g = SelectColor(block.endpoints[1], block.endpoints[5], block.weights[i * 2]);`
`767`		`- byte b = SelectColor(block.endpoints[2], block.endpoints[6], block.weights[i * 2]);`
`768`		`- byte a = SelectColor(block.endpoints[3], block.endpoints[7], block.weights[i * 2]);`
	`723`	`+ byte r = SelectColor(block.endpoints[0][0], block.endpoints[0][4], block.weights[i * 2]);`
	`724`	`+ byte g = SelectColor(block.endpoints[0][1], block.endpoints[0][5], block.weights[i * 2]);`
	`725`	`+ byte b = SelectColor(block.endpoints[0][2], block.endpoints[0][6], block.weights[i * 2]);`
	`726`	`+ byte a = SelectColor(block.endpoints[0][3], block.endpoints[0][7], block.weights[i * 2]);`
`769`	`727`	`output[i] = Color(r, g, b, a);`
`770`	`728`	`}`
`771`	`729`	`}`