Update to latest upstream Adler32 code.

Matched the existing code by inlining SeedValue instead of parameterising the adler seed.

Author: bgrainger

src/MySqlConnector/Protocol/Serialization/CompressedPayloadHandler.cs

@@ -168,7 +168,7 @@ private ValueTask<int> ReadBytesAsync(Memory<byte> buffer, ProtocolErrorBehavior
 								return ValueTaskExtensions.FromException<int>(new InvalidOperationException("Expected to read {0:n0} uncompressed bytes but only read {1:n0}".FormatInvariant(uncompressedLength, totalBytesRead)));
 							m_remainingData = new(uncompressedData, 0, totalBytesRead);
 
-							var checksum = Adler32.Calculate(uncompressedData, 0, (uint) totalBytesRead);
+							var checksum = Adler32.Calculate(uncompressedData.AsSpan(0, totalBytesRead));
 
 							var adlerStartOffset = payloadReadBytes.Offset + payloadReadBytes.Count - 4;
 							if (payloadReadBytes.Array[adlerStartOffset + 0] != ((checksum >> 24) & 0xFF) ||
@@ -218,7 +218,7 @@ private ValueTask<int> CompressAndWrite(ArraySegment<byte> remainingUncompressed
 			using (var deflateStream = new DeflateStream(compressedStream, CompressionLevel.Optimal, leaveOpen: true))
 				deflateStream.Write(remainingUncompressedData.Array!, remainingUncompressedData.Offset, remainingUncompressedBytes);
 
-			var checksum = Adler32.Calculate(remainingUncompressedData.Array!, (uint)remainingUncompressedData.Offset, (uint)remainingUncompressedBytes);
+			var checksum = Adler32.Calculate(remainingUncompressedData.AsSpan(0, remainingUncompressedBytes));
 			compressedStream.WriteByte((byte) ((checksum >> 24) & 0xFF));
 			compressedStream.WriteByte((byte) ((checksum >> 16) & 0xFF));
 			compressedStream.WriteByte((byte) ((checksum >> 8) & 0xFF));

src/MySqlConnector/Utilities/Adler32.cs

@@ -1,8 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
-// https://github.com/SixLabors/ImageSharp/blob/master/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+// https://github.com/SixLabors/ImageSharp/blob/master/src/ImageSharp/Compression/Zlib/Adler32.cs
 
 #if !NET6_0_OR_GREATER
+using System.Runtime.CompilerServices;
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
@@ -44,36 +45,37 @@ internal static class Adler32
 	/// Calculates the Adler32 checksum with the bytes taken from the span.
 	/// </summary>
 	/// <param name="buffer">The readonly span of bytes.</param>
-	/// <param name="offset">The offset.</param>
-	/// <param name="length">The length.</param>
 	/// <returns>The <see cref="uint"/>.</returns>
-	public static uint Calculate(ReadOnlySpan<byte> buffer, uint offset, uint length)
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static uint Calculate(ReadOnlySpan<byte> buffer)
 	{
-		if (buffer.Length == 0)
+		if (buffer.IsEmpty)
 		{
 			return SeedValue;
 		}
 
 #if NETCOREAPP3_0_OR_GREATER
 		if (Ssse3.IsSupported && buffer.Length >= MinBufferSize)
 		{
-			return CalculateSse(buffer, offset, length);
+			return CalculateSse(buffer);
 		}
 #endif
 
-		return CalculateScalar(buffer, offset, length);
+		return CalculateScalar(buffer);
 	}
 
 #if NETCOREAPP3_0_OR_GREATER
 	// Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
-	private static unsafe uint CalculateSse(ReadOnlySpan<byte> buffer, uint offset, uint length)
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static unsafe uint CalculateSse(ReadOnlySpan<byte> buffer)
 	{
 		uint s1 = SeedValue & 0xFFFF;
 		uint s2 = (SeedValue >> 16) & 0xFFFF;
 
 		// Process the data in blocks.
 		const int BLOCK_SIZE = 1 << 5;
 
+		uint length = (uint)buffer.Length;
 		uint blocks = length / BLOCK_SIZE;
 		length -= blocks * BLOCK_SIZE;
 
@@ -82,7 +84,7 @@ private static unsafe uint CalculateSse(ReadOnlySpan<byte> buffer, uint offset,
 		fixed (byte* tapPtr = Tap1Tap2)
 		{
 			index += (int)blocks * BLOCK_SIZE;
-			var localBufferPtr = bufferPtr + offset;
+			var localBufferPtr = bufferPtr;
 
 			// _mm_setr_epi8 on x86
 			Vector128<sbyte> tap1 = Sse2.LoadVector128((sbyte*)tapPtr);
@@ -192,15 +194,17 @@ private static unsafe uint CalculateSse(ReadOnlySpan<byte> buffer, uint offset,
 	}
 #endif
 
-	private static unsafe uint CalculateScalar(ReadOnlySpan<byte> buffer, uint offset, uint length)
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static unsafe uint CalculateScalar(ReadOnlySpan<byte> buffer)
 	{
 		uint s1 = SeedValue & 0xFFFF;
 		uint s2 = (SeedValue >> 16) & 0xFFFF;
 		uint k;
 
 		fixed (byte* bufferPtr = buffer)
 		{
-			var localBufferPtr = bufferPtr + offset;
+			var localBufferPtr = bufferPtr;
+			uint length = (uint) buffer.Length;
 
 			while (length > 0)
 			{