diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs b/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs
index bbdc95a13..ea1ffba05 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs
@@ -19,10 +19,10 @@ namespace SixLabors.ImageSharp
             private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 };
 
             /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                 ref ReadOnlySpan<float> source,
                 ref Span<byte> dest)
             {
@@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp
 
                     if (adjustedCount > 0)
                     {
-                        BulkConvertNormalizedFloatToByteClampOverflows(
+                        NormalizedFloatToByteSaturate(
                             source.Slice(0, adjustedCount),
                             dest.Slice(0, adjustedCount));
 
@@ -46,13 +46,13 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/>, which is faster on new .NET runtime.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/>, which is faster on new .NET runtime.
             /// </summary>
             /// <remarks>
             /// Implementation is based on MagicScaler code:
             /// https://github.com/saucecontrol/PhotoSauce/blob/a9bd6e5162d2160419f0cf743fd4f536c079170b/src/MagicScaler/Magic/Processors/ConvertersFloat.cs#L453-L477
             /// </remarks>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                 ReadOnlySpan<float> source,
                 Span<byte> dest)
             {
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs b/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
index ba3d9c4e8..1099678f7 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
@@ -21,10 +21,10 @@ namespace SixLabors.ImageSharp
 
 #if !SUPPORTS_EXTENDED_INTRINSICS
             /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                 ref ReadOnlySpan<byte> source,
                 ref Span<float> dest)
             {
@@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertByteToNormalizedFloat(
+                    ByteToNormalizedFloat(
                         source.Slice(0, adjustedCount),
                         dest.Slice(0, adjustedCount));
 
@@ -50,10 +50,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                 ref ReadOnlySpan<float> source,
                 ref Span<byte> dest)
             {
@@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertNormalizedFloatToByteClampOverflows(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
+                    NormalizedFloatToByteSaturate(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
 
                     source = source.Slice(adjustedCount);
                     dest = dest.Slice(adjustedCount);
@@ -78,15 +78,15 @@ namespace SixLabors.ImageSharp
 #endif
 
             /// <summary>
-            /// SIMD optimized implementation for <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/>.
+            /// SIMD optimized implementation for <see cref="SimdUtils.ByteToNormalizedFloat"/>.
             /// Works only with span Length divisible by 8.
             /// Implementation adapted from:
             /// http://lolengine.net/blog/2011/3/20/understanding-fast-float-integer-conversions
             /// http://stackoverflow.com/a/536278
             /// </summary>
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
             {
-                VerifyHasVector8(nameof(BulkConvertByteToNormalizedFloat));
+                VerifyHasVector8(nameof(ByteToNormalizedFloat));
                 VerifySpanInput(source, dest, 8);
 
                 var bVec = new Vector<float>(256.0f / 255.0f);
@@ -124,11 +124,11 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/> which is faster on older runtimes.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/> which is faster on older runtimes.
             /// </summary>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(ReadOnlySpan<float> source, Span<byte> dest)
+            internal static void NormalizedFloatToByteSaturate(ReadOnlySpan<float> source, Span<byte> dest)
             {
-                VerifyHasVector8(nameof(BulkConvertNormalizedFloatToByteClampOverflows));
+                VerifyHasVector8(nameof(NormalizedFloatToByteSaturate));
                 VerifySpanInput(source, dest, 8);
 
                 if (source.Length == 0)
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs b/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs
index 7baa788e4..69d5dfa73 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs
@@ -43,10 +43,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                 ref ReadOnlySpan<byte> source,
                 ref Span<float> dest)
             {
@@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertByteToNormalizedFloat(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
+                    ByteToNormalizedFloat(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
 
                     source = source.Slice(adjustedCount);
                     dest = dest.Slice(adjustedCount);
@@ -70,10 +70,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                 ref ReadOnlySpan<float> source,
                 ref Span<byte> dest)
             {
@@ -89,7 +89,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertNormalizedFloatToByteClampOverflows(
+                    NormalizedFloatToByteSaturate(
                         source.Slice(0, adjustedCount),
                         dest.Slice(0, adjustedCount));
 
@@ -99,9 +99,9 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/>, which is faster on new RyuJIT runtime.
+            /// Implementation <see cref="SimdUtils.ByteToNormalizedFloat"/>, which is faster on new RyuJIT runtime.
             /// </summary>
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
             {
                 VerifySpanInput(source, dest, Vector<byte>.Count);
 
@@ -132,9 +132,9 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/>, which is faster on new .NET runtime.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/>, which is faster on new .NET runtime.
             /// </summary>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                 ReadOnlySpan<float> source,
                 Span<byte> dest)
             {
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs b/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs
index 565ea08f5..aaacfdd85 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs
@@ -19,10 +19,10 @@ namespace SixLabors.ImageSharp
         public static class FallbackIntrinsics128
         {
             /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                 ref ReadOnlySpan<byte> source,
                 ref Span<float> dest)
             {
@@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertByteToNormalizedFloat(
+                    ByteToNormalizedFloat(
                         source.Slice(0, adjustedCount),
                         dest.Slice(0, adjustedCount));
 
@@ -43,10 +43,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
             /// </summary>
             [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                 ref ReadOnlySpan<float> source,
                 ref Span<byte> dest)
             {
@@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp
 
                 if (adjustedCount > 0)
                 {
-                    BulkConvertNormalizedFloatToByteClampOverflows(
+                    NormalizedFloatToByteSaturate(
                         source.Slice(0, adjustedCount),
                         dest.Slice(0, adjustedCount));
 
@@ -67,10 +67,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/> using <see cref="Vector4"/>.
+            /// Implementation of <see cref="SimdUtils.ByteToNormalizedFloat"/> using <see cref="Vector4"/>.
             /// </summary>
             [MethodImpl(InliningOptions.ColdPath)]
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
             {
                 VerifySpanInput(source, dest, 4);
 
@@ -99,10 +99,10 @@ namespace SixLabors.ImageSharp
             }
 
             /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/> using <see cref="Vector4"/>.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/> using <see cref="Vector4"/>.
             /// </summary>
             [MethodImpl(InliningOptions.ColdPath)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                 ReadOnlySpan<float> source,
                 Span<byte> dest)
             {
@@ -148,4 +148,4 @@ namespace SixLabors.ImageSharp
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/ImageSharp/Common/Helpers/SimdUtils.cs b/src/ImageSharp/Common/Helpers/SimdUtils.cs
index de313c8d5..b58ec900f 100644
--- a/src/ImageSharp/Common/Helpers/SimdUtils.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.cs
@@ -61,16 +61,18 @@ namespace SixLabors.ImageSharp
         /// <param name="source">The source span of bytes</param>
         /// <param name="dest">The destination span of floats</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+        internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
         {
             DebugGuard.IsTrue(source.Length == dest.Length, nameof(source), "Input spans must be of same length!");
 
 #if SUPPORTS_EXTENDED_INTRINSICS
-            ExtendedIntrinsics.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+            ExtendedIntrinsics.ByteToNormalizedFloatReduce(ref source, ref dest);
 #else
-            BasicIntrinsics256.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+            BasicIntrinsics256.ByteToNormalizedFloatReduce(ref source, ref dest);
 #endif
-            FallbackIntrinsics128.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+
+            // Also deals with the remainder from previous conversions:
+            FallbackIntrinsics128.ByteToNormalizedFloatReduce(ref source, ref dest);
 
             // Deal with the remainder:
             if (source.Length > 0)
@@ -88,20 +90,20 @@ namespace SixLabors.ImageSharp
         /// <param name="source">The source span of floats</param>
         /// <param name="dest">The destination span of bytes</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        internal static void BulkConvertNormalizedFloatToByteClampOverflows(ReadOnlySpan<float> source, Span<byte> dest)
+        internal static void NormalizedFloatToByteSaturate(ReadOnlySpan<float> source, Span<byte> dest)
         {
             DebugGuard.IsTrue(source.Length == dest.Length, nameof(source), "Input spans must be of same length!");
 
 #if SUPPORTS_RUNTIME_INTRINSICS
-            Avx2Intrinsics.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            Avx2Intrinsics.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #elif SUPPORTS_EXTENDED_INTRINSICS
-            ExtendedIntrinsics.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            ExtendedIntrinsics.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #else
-            BasicIntrinsics256.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            BasicIntrinsics256.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #endif
 
             // Also deals with the remainder from previous conversions:
-            FallbackIntrinsics128.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            FallbackIntrinsics128.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 
             // Deal with the remainder:
             if (source.Length > 0)
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs
index 7337c0c89..0b0e9b1c1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs
@@ -29,7 +29,7 @@ namespace SixLabors.ImageSharp.PixelFormats
                 Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationVectors, nameof(destinationVectors));
 
                 destinationVectors = destinationVectors.Slice(0, sourcePixels.Length);
-                SimdUtils.BulkConvertByteToNormalizedFloat(
+                SimdUtils.ByteToNormalizedFloat(
                     MemoryMarshal.Cast<Rgba32, byte>(sourcePixels),
                     MemoryMarshal.Cast<Vector4, float>(destinationVectors));
                 Vector4Converters.ApplyForwardConversionModifiers(destinationVectors, modifiers);
@@ -46,7 +46,7 @@ namespace SixLabors.ImageSharp.PixelFormats
 
                 destinationPixels = destinationPixels.Slice(0, sourceVectors.Length);
                 Vector4Converters.ApplyBackwardConversionModifiers(sourceVectors, modifiers);
-                SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(
+                SimdUtils.NormalizedFloatToByteSaturate(
                     MemoryMarshal.Cast<Vector4, float>(sourceVectors),
                     MemoryMarshal.Cast<Rgba32, byte>(destinationPixels));
             }
diff --git a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
index af04a06b7..4ee645c20 100644
--- a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
+++ b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
@@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.PixelFormats.Utils
 
                 // 'destVectors' and 'lastQuarterOfDestBuffer' are overlapping buffers,
                 // but we are always reading/writing at different positions:
-                SimdUtils.BulkConvertByteToNormalizedFloat(
+                SimdUtils.ByteToNormalizedFloat(
                     MemoryMarshal.Cast<Rgba32, byte>(lastQuarterOfDestBuffer),
                     MemoryMarshal.Cast<Vector4, float>(destVectors.Slice(0, countWithoutLastItem)));
 
@@ -107,7 +107,7 @@ namespace SixLabors.ImageSharp.PixelFormats.Utils
                 {
                     Span<Rgba32> tempSpan = tempBuffer.Memory.Span;
 
-                    SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(
+                    SimdUtils.NormalizedFloatToByteSaturate(
                         MemoryMarshal.Cast<Vector4, float>(sourceVectors),
                         MemoryMarshal.Cast<Rgba32, byte>(tempSpan));
 
diff --git a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
index ef554a011..b6bfca4b5 100644
--- a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
@@ -178,7 +178,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         {
             TestImpl_BulkConvertByteToNormalizedFloat(
                 count,
-                (s, d) => SimdUtils.FallbackIntrinsics128.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.FallbackIntrinsics128.ByteToNormalizedFloat(s.Span, d.Span));
         }
 
         [Theory]
@@ -192,7 +192,7 @@ namespace SixLabors.ImageSharp.Tests.Common
 
             TestImpl_BulkConvertByteToNormalizedFloat(
                 count,
-                (s, d) => SimdUtils.BasicIntrinsics256.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.BasicIntrinsics256.ByteToNormalizedFloat(s.Span, d.Span));
         }
 
         [Theory]
@@ -201,7 +201,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         {
             TestImpl_BulkConvertByteToNormalizedFloat(
                 count,
-                (s, d) => SimdUtils.ExtendedIntrinsics.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.ExtendedIntrinsics.ByteToNormalizedFloat(s.Span, d.Span));
         }
 
         [Theory]
@@ -210,7 +210,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         {
             TestImpl_BulkConvertByteToNormalizedFloat(
                 count,
-                (s, d) => SimdUtils.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.ByteToNormalizedFloat(s.Span, d.Span));
         }
 
         private static void TestImpl_BulkConvertByteToNormalizedFloat(
@@ -232,7 +232,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         {
             TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                 count,
-                (s, d) => SimdUtils.FallbackIntrinsics128.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.FallbackIntrinsics128.NormalizedFloatToByteSaturate(s.Span, d.Span));
         }
 
         [Theory]
@@ -244,7 +244,7 @@ namespace SixLabors.ImageSharp.Tests.Common
                 return;
             }
 
-            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BasicIntrinsics256.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BasicIntrinsics256.NormalizedFloatToByteSaturate(s.Span, d.Span));
         }
 
         [Theory]
@@ -253,7 +253,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         {
             TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                 count,
-                (s, d) => SimdUtils.ExtendedIntrinsics.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.ExtendedIntrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
         }
 
         [Theory]
@@ -290,7 +290,7 @@ namespace SixLabors.ImageSharp.Tests.Common
 
             TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                 count,
-                (s, d) => SimdUtils.Avx2Intrinsics.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.Avx2Intrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
         }
 
 #endif
@@ -299,7 +299,7 @@ namespace SixLabors.ImageSharp.Tests.Common
         [MemberData(nameof(ArbitraryArraySizes))]
         public void BulkConvertNormalizedFloatToByteClampOverflows(int count)
         {
-            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.NormalizedFloatToByteSaturate(s.Span, d.Span));
 
             // For small values, let's stress test the implementation a bit:
             if (count > 0 && count < 10)
@@ -308,7 +308,7 @@ namespace SixLabors.ImageSharp.Tests.Common
                 {
                     TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                         count,
-                        (s, d) => SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span),
+                        (s, d) => SimdUtils.NormalizedFloatToByteSaturate(s.Span, d.Span),
                         i + 42);
                 }
             }