Update missed test and benchmarks project

tests/ImageSharp.Benchmarks/Codecs/Bmp/DecodeBmp.cs

@@ -1,49 +1,47 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 using SDSize = System.Drawing.Size;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeBmp
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] bmpBytes;
-    public class DecodeBmp
-    {
-        private byte[] bmpBytes;
 
-        private string TestImageFullPath
+    private string TestImageFullPath
-            => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+        => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.bmpBytes == null)
         {
-            if (this.bmpBytes == null)
+            this.bmpBytes = File.ReadAllBytes(this.TestImageFullPath);
-            {
-                this.bmpBytes = File.ReadAllBytes(this.TestImageFullPath);
-            }
         }
+    }
 
-        [Params(TestImages.Bmp.Car)]
+    [Params(TestImages.Bmp.Car)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Bmp")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Bmp")]
-        public SDSize BmpSystemDrawing()
+    public SDSize BmpSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.bmpBytes);
+        using var memoryStream = new MemoryStream(this.bmpBytes);
-            using var image = SDImage.FromStream(memoryStream);
+        using var image = SDImage.FromStream(memoryStream);
-            return image.Size;
+        return image.Size;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Bmp")]
+    [Benchmark(Description = "ImageSharp Bmp")]
-        public Size BmpImageSharp()
+    public Size BmpImageSharp()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.bmpBytes);
+        using var memoryStream = new MemoryStream(this.bmpBytes);
-            using var image = Image.Load<Rgba32>(memoryStream);
+        using var image = Image.Load<Rgba32>(memoryStream);
-            return new Size(image.Width, image.Height);
+        return new Size(image.Width, image.Height);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmp.cs

@@ -2,54 +2,52 @@
 // Licensed under the Six Labors Split License.
 
 using System.Drawing.Imaging;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeBmp
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private Stream bmpStream;
-    public class EncodeBmp
+    private SDImage bmpDrawing;
-    {
+    private Image<Rgba32> bmpCore;
-        private Stream bmpStream;
-        private SDImage bmpDrawing;
-        private Image<Rgba32> bmpCore;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.bmpStream == null)
         {
-            if (this.bmpStream == null)
+            this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Bmp.Car));
-            {
+            this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
-                this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Bmp.Car));
+            this.bmpStream.Position = 0;
-                this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
+            this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-                this.bmpStream.Position = 0;
-                this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bmpStream.Dispose();
+        this.bmpStream.Dispose();
-            this.bmpStream = null;
+        this.bmpStream = null;
-            this.bmpCore.Dispose();
+        this.bmpCore.Dispose();
-            this.bmpDrawing.Dispose();
+        this.bmpDrawing.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Bmp")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Bmp")]
-        public void BmpSystemDrawing()
+    public void BmpSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.bmpDrawing.Save(memoryStream, ImageFormat.Bmp);
+        this.bmpDrawing.Save(memoryStream, ImageFormat.Bmp);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Bmp")]
+    [Benchmark(Description = "ImageSharp Bmp")]
-        public void BmpImageSharp()
+    public void BmpImageSharp()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.bmpCore.SaveAsBmp(memoryStream);
+        this.bmpCore.SaveAsBmp(memoryStream);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Bmp/EncodeBmpMultiple.cs

@@ -1,32 +1,30 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Collections.Generic;
 using System.Drawing.Imaging;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Bmp;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeBmpMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Bmp/", "Jpg/baseline" };
-    public class EncodeBmpMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
-    {
-        protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Bmp/", "Jpg/baseline" };
 
-        [Benchmark(Description = "EncodeBmpMultiple - ImageSharp")]
+    [Benchmark(Description = "EncodeBmpMultiple - ImageSharp")]
-        public void EncodeBmpImageSharp()
+    public void EncodeBmpImageSharp()
-            => this.ForEachImageSharpImage((img, ms) =>
+        => this.ForEachImageSharpImage((img, ms) =>
-            {
+        {
-                img.Save(ms, new BmpEncoder());
+            img.Save(ms, new BmpEncoder());
-                return null;
+            return null;
-            });
+        });
 
-        [Benchmark(Baseline = true, Description = "EncodeBmpMultiple - System.Drawing")]
+    [Benchmark(Baseline = true, Description = "EncodeBmpMultiple - System.Drawing")]
-        public void EncodeBmpSystemDrawing()
+    public void EncodeBmpSystemDrawing()
-            => this.ForEachSystemDrawingImage((img, ms) =>
+        => this.ForEachSystemDrawingImage((img, ms) =>
-            {
+        {
-                img.Save(ms, ImageFormat.Bmp);
+            img.Save(ms, ImageFormat.Bmp);
-                return null;
+            return null;
-            });
+        });
-    }
 }

tests/ImageSharp.Benchmarks/Codecs/Gif/DecodeGif.cs

@@ -1,49 +1,47 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 using SDSize = System.Drawing.Size;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeGif
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] gifBytes;
-    public class DecodeGif
-    {
-        private byte[] gifBytes;
 
-        private string TestImageFullPath
+    private string TestImageFullPath
-            => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+        => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.gifBytes == null)
         {
-            if (this.gifBytes == null)
+            this.gifBytes = File.ReadAllBytes(this.TestImageFullPath);
-            {
-                this.gifBytes = File.ReadAllBytes(this.TestImageFullPath);
-            }
         }
+    }
 
-        [Params(TestImages.Gif.Rings)]
+    [Params(TestImages.Gif.Rings)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
-        public SDSize GifSystemDrawing()
+    public SDSize GifSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.gifBytes);
+        using var memoryStream = new MemoryStream(this.gifBytes);
-            using var image = SDImage.FromStream(memoryStream);
+        using var image = SDImage.FromStream(memoryStream);
-            return image.Size;
+        return image.Size;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Gif")]
+    [Benchmark(Description = "ImageSharp Gif")]
-        public Size GifImageSharp()
+    public Size GifImageSharp()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.gifBytes);
+        using var memoryStream = new MemoryStream(this.gifBytes);
-            using var image = Image.Load<Rgba32>(memoryStream);
+        using var image = Image.Load<Rgba32>(memoryStream);
-            return new Size(image.Width, image.Height);
+        return new Size(image.Width, image.Height);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGif.cs

@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Drawing.Imaging;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.PixelFormats;
@@ -11,58 +10,57 @@ using SixLabors.ImageSharp.Processing.Processors.Quantization;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeGif
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    // System.Drawing needs this.
-    public class EncodeGif
+    private Stream bmpStream;
-    {
+    private SDImage bmpDrawing;
-        // System.Drawing needs this.
+    private Image<Rgba32> bmpCore;
-        private Stream bmpStream;
-        private SDImage bmpDrawing;
-        private Image<Rgba32> bmpCore;
 
-        // Try to get as close to System.Drawing's output as possible
+    // Try to get as close to System.Drawing's output as possible
-        private readonly GifEncoder encoder = new GifEncoder
+    private readonly GifEncoder encoder = new GifEncoder
-        {
+    {
-            Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4 })
+        Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4 })
-        };
+    };
 
-        [Params(TestImages.Bmp.Car, TestImages.Png.Rgb48Bpp)]
+    [Params(TestImages.Bmp.Car, TestImages.Png.Rgb48Bpp)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.bmpStream == null)
         {
-            if (this.bmpStream == null)
+            this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage));
-            {
+            this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
-                this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage));
+            this.bmpStream.Position = 0;
-                this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
+            this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-                this.bmpStream.Position = 0;
-                this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bmpStream.Dispose();
+        this.bmpStream.Dispose();
-            this.bmpStream = null;
+        this.bmpStream = null;
-            this.bmpCore.Dispose();
+        this.bmpCore.Dispose();
-            this.bmpDrawing.Dispose();
+        this.bmpDrawing.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Gif")]
-        public void GifSystemDrawing()
+    public void GifSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.bmpDrawing.Save(memoryStream, ImageFormat.Gif);
+        this.bmpDrawing.Save(memoryStream, ImageFormat.Gif);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Gif")]
+    [Benchmark(Description = "ImageSharp Gif")]
-        public void GifImageSharp()
+    public void GifImageSharp()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.bmpCore.SaveAsGif(memoryStream, this.encoder);
+        this.bmpCore.SaveAsGif(memoryStream, this.encoder);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Gif/EncodeGifMultiple.cs

@@ -1,43 +1,41 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Collections.Generic;
 using System.Drawing.Imaging;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeGifMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    [Params(InputImageCategory.AllImages)]
-    public class EncodeGifMultiple : MultiImageBenchmarkBase.WithImagesPreloaded
+    public override InputImageCategory InputCategory { get; set; }
-    {
-        [Params(InputImageCategory.AllImages)]
-        public override InputImageCategory InputCategory { get; set; }
 
-        protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Gif/" };
+    protected override IEnumerable<string> InputImageSubfoldersOrFiles => new[] { "Gif/" };
 
-        [Benchmark(Description = "EncodeGifMultiple - ImageSharp")]
+    [Benchmark(Description = "EncodeGifMultiple - ImageSharp")]
-        public void EncodeGifImageSharp()
+    public void EncodeGifImageSharp()
-            => this.ForEachImageSharpImage((img, ms) =>
+        => this.ForEachImageSharpImage((img, ms) =>
+        {
+            // Try to get as close to System.Drawing's output as possible
+            var options = new GifEncoder
             {
-                // Try to get as close to System.Drawing's output as possible
+                Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4 })
-                var options = new GifEncoder
+            };
-                {
-                    Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = KnownDitherings.Bayer4x4 })
-                };
 
-                img.Save(ms, options);
+            img.Save(ms, options);
-                return null;
+            return null;
-            });
+        });
 
-        [Benchmark(Baseline = true, Description = "EncodeGifMultiple - System.Drawing")]
+    [Benchmark(Baseline = true, Description = "EncodeGifMultiple - System.Drawing")]
-        public void EncodeGifSystemDrawing()
+    public void EncodeGifSystemDrawing()
-            => this.ForEachSystemDrawingImage((img, ms) =>
+        => this.ForEachSystemDrawingImage((img, ms) =>
-            {
+        {
-                img.Save(ms, ImageFormat.Gif);
+            img.Save(ms, ImageFormat.Gif);
-                return null;
+            return null;
-            });
+        });
-    }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_AddInPlace.cs

@@ -4,18 +4,17 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Block8x8F_AddInPlace
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    [Benchmark]
-    public class Block8x8F_AddInPlace
+    public float AddInplace()
     {
-        [Benchmark]
+        float f = 42F;
-        public float AddInplace()
+        Block8x8F b = default;
-        {
+        b.AddInPlace(f);
-            float f = 42F;
+        return f;
-            Block8x8F b = default;
-            b.AddInPlace(f);
-            return f;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo1x1.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -11,375 +10,374 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+public unsafe class Block8x8F_CopyTo1x1
 {
-    public unsafe class Block8x8F_CopyTo1x1
+    private Block8x8F block;
-    {
+    private readonly Block8x8F[] blockArray = new Block8x8F[1];
-        private Block8x8F block;
-        private readonly Block8x8F[] blockArray = new Block8x8F[1];
 
-        private static readonly int Width = 100;
+    private static readonly int Width = 100;
 
-        private float[] buffer = new float[Width * 500];
+    private float[] buffer = new float[Width * 500];
-        private readonly float[] unpinnedBuffer = new float[Width * 500];
+    private readonly float[] unpinnedBuffer = new float[Width * 500];
-        private GCHandle bufferHandle;
+    private GCHandle bufferHandle;
-        private GCHandle blockHandle;
+    private GCHandle blockHandle;
-        private float* bufferPtr;
+    private float* bufferPtr;
-        private float* blockPtr;
+    private float* blockPtr;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        if (!SimdUtils.HasVector8)
         {
-            if (!SimdUtils.HasVector8)
+            throw new InvalidOperationException("Benchmark Block8x8F_CopyTo1x1 is invalid on platforms without AVX2 support.");
-            {
+        }
-                throw new InvalidOperationException("Benchmark Block8x8F_CopyTo1x1 is invalid on platforms without AVX2 support.");
-            }
 
-            this.bufferHandle = GCHandle.Alloc(this.buffer, GCHandleType.Pinned);
+        this.bufferHandle = GCHandle.Alloc(this.buffer, GCHandleType.Pinned);
-            this.bufferPtr = (float*)this.bufferHandle.AddrOfPinnedObject();
+        this.bufferPtr = (float*)this.bufferHandle.AddrOfPinnedObject();
 
-            // Pin self so we can take address of to the block:
+        // Pin self so we can take address of to the block:
-            this.blockHandle = GCHandle.Alloc(this.blockArray, GCHandleType.Pinned);
+        this.blockHandle = GCHandle.Alloc(this.blockArray, GCHandleType.Pinned);
-            this.blockPtr = (float*)Unsafe.AsPointer(ref this.block);
+        this.blockPtr = (float*)Unsafe.AsPointer(ref this.block);
-        }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bufferPtr = null;
+        this.bufferPtr = null;
-            this.blockPtr = null;
+        this.blockPtr = null;
-            this.bufferHandle.Free();
+        this.bufferHandle.Free();
-            this.blockHandle.Free();
+        this.blockHandle.Free();
-            this.buffer = null;
+        this.buffer = null;
-        }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Original()
+    public void Original()
-        {
+    {
-            ref byte selfBase = ref Unsafe.As<Block8x8F, byte>(ref this.block);
+        ref byte selfBase = ref Unsafe.As<Block8x8F, byte>(ref this.block);
-            ref byte destBase = ref Unsafe.AsRef<byte>(this.bufferPtr);
+        ref byte destBase = ref Unsafe.AsRef<byte>(this.bufferPtr);
-            int destStride = Width * sizeof(float);
+        int destStride = Width * sizeof(float);
-
+
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 0);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 0);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 1);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 1);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 2);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 2);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 3);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 3);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 4);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 4);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 5);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 5);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 6);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 6);
-            CopyRowImpl(ref selfBase, ref destBase, destStride, 7);
+        CopyRowImpl(ref selfBase, ref destBase, destStride, 7);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void CopyRowImpl(ref byte selfBase, ref byte destBase, int destStride, int row)
+    private static void CopyRowImpl(ref byte selfBase, ref byte destBase, int destStride, int row)
-        {
+    {
-            ref byte s = ref Unsafe.Add(ref selfBase, row * 8 * sizeof(float));
+        ref byte s = ref Unsafe.Add(ref selfBase, row * 8 * sizeof(float));
-            ref byte d = ref Unsafe.Add(ref destBase, row * destStride);
+        ref byte d = ref Unsafe.Add(ref destBase, row * destStride);
-            Unsafe.CopyBlock(ref d, ref s, 8 * sizeof(float));
+        Unsafe.CopyBlock(ref d, ref s, 8 * sizeof(float));
-        }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void UseVector8()
+    public void UseVector8()
-        {
+    {
-            ref Block8x8F s = ref this.block;
+        ref Block8x8F s = ref this.block;
-            ref float origin = ref Unsafe.AsRef<float>(this.bufferPtr);
+        ref float origin = ref Unsafe.AsRef<float>(this.bufferPtr);
-            int stride = Width;
+        int stride = Width;
-
+
-            ref Vector<float> d0 = ref Unsafe.As<float, Vector<float>>(ref origin);
+        ref Vector<float> d0 = ref Unsafe.As<float, Vector<float>>(ref origin);
-            ref Vector<float> d1 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride));
+        ref Vector<float> d1 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride));
-            ref Vector<float> d2 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 2));
+        ref Vector<float> d2 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 2));
-            ref Vector<float> d3 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 3));
+        ref Vector<float> d3 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 3));
-            ref Vector<float> d4 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 4));
+        ref Vector<float> d4 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 4));
-            ref Vector<float> d5 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 5));
+        ref Vector<float> d5 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 5));
-            ref Vector<float> d6 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 6));
+        ref Vector<float> d6 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 6));
-            ref Vector<float> d7 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 7));
+        ref Vector<float> d7 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 7));
-
+
-            Vector<float> row0 = Unsafe.As<Vector4, Vector<float>>(ref s.V0L);
+        Vector<float> row0 = Unsafe.As<Vector4, Vector<float>>(ref s.V0L);
-            Vector<float> row1 = Unsafe.As<Vector4, Vector<float>>(ref s.V1L);
+        Vector<float> row1 = Unsafe.As<Vector4, Vector<float>>(ref s.V1L);
-            Vector<float> row2 = Unsafe.As<Vector4, Vector<float>>(ref s.V2L);
+        Vector<float> row2 = Unsafe.As<Vector4, Vector<float>>(ref s.V2L);
-            Vector<float> row3 = Unsafe.As<Vector4, Vector<float>>(ref s.V3L);
+        Vector<float> row3 = Unsafe.As<Vector4, Vector<float>>(ref s.V3L);
-            Vector<float> row4 = Unsafe.As<Vector4, Vector<float>>(ref s.V4L);
+        Vector<float> row4 = Unsafe.As<Vector4, Vector<float>>(ref s.V4L);
-            Vector<float> row5 = Unsafe.As<Vector4, Vector<float>>(ref s.V5L);
+        Vector<float> row5 = Unsafe.As<Vector4, Vector<float>>(ref s.V5L);
-            Vector<float> row6 = Unsafe.As<Vector4, Vector<float>>(ref s.V6L);
+        Vector<float> row6 = Unsafe.As<Vector4, Vector<float>>(ref s.V6L);
-            Vector<float> row7 = Unsafe.As<Vector4, Vector<float>>(ref s.V7L);
+        Vector<float> row7 = Unsafe.As<Vector4, Vector<float>>(ref s.V7L);
-
+
-            d0 = row0;
+        d0 = row0;
-            d1 = row1;
+        d1 = row1;
-            d2 = row2;
+        d2 = row2;
-            d3 = row3;
+        d3 = row3;
-            d4 = row4;
+        d4 = row4;
-            d5 = row5;
+        d5 = row5;
-            d6 = row6;
+        d6 = row6;
-            d7 = row7;
+        d7 = row7;
-        }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void UseVector8_V2()
+    public void UseVector8_V2()
-        {
+    {
-            ref Block8x8F s = ref this.block;
+        ref Block8x8F s = ref this.block;
-            ref float origin = ref Unsafe.AsRef<float>(this.bufferPtr);
+        ref float origin = ref Unsafe.AsRef<float>(this.bufferPtr);
-            int stride = Width;
+        int stride = Width;
-
+
-            ref Vector<float> d0 = ref Unsafe.As<float, Vector<float>>(ref origin);
+        ref Vector<float> d0 = ref Unsafe.As<float, Vector<float>>(ref origin);
-            ref Vector<float> d1 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride));
+        ref Vector<float> d1 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride));
-            ref Vector<float> d2 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 2));
+        ref Vector<float> d2 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 2));
-            ref Vector<float> d3 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 3));
+        ref Vector<float> d3 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 3));
-            ref Vector<float> d4 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 4));
+        ref Vector<float> d4 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 4));
-            ref Vector<float> d5 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 5));
+        ref Vector<float> d5 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 5));
-            ref Vector<float> d6 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 6));
+        ref Vector<float> d6 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 6));
-            ref Vector<float> d7 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 7));
+        ref Vector<float> d7 = ref Unsafe.As<float, Vector<float>>(ref Unsafe.Add(ref origin, stride * 7));
-
+
-            d0 = Unsafe.As<Vector4, Vector<float>>(ref s.V0L);
+        d0 = Unsafe.As<Vector4, Vector<float>>(ref s.V0L);
-            d1 = Unsafe.As<Vector4, Vector<float>>(ref s.V1L);
+        d1 = Unsafe.As<Vector4, Vector<float>>(ref s.V1L);
-            d2 = Unsafe.As<Vector4, Vector<float>>(ref s.V2L);
+        d2 = Unsafe.As<Vector4, Vector<float>>(ref s.V2L);
-            d3 = Unsafe.As<Vector4, Vector<float>>(ref s.V3L);
+        d3 = Unsafe.As<Vector4, Vector<float>>(ref s.V3L);
-            d4 = Unsafe.As<Vector4, Vector<float>>(ref s.V4L);
+        d4 = Unsafe.As<Vector4, Vector<float>>(ref s.V4L);
-            d5 = Unsafe.As<Vector4, Vector<float>>(ref s.V5L);
+        d5 = Unsafe.As<Vector4, Vector<float>>(ref s.V5L);
-            d6 = Unsafe.As<Vector4, Vector<float>>(ref s.V6L);
+        d6 = Unsafe.As<Vector4, Vector<float>>(ref s.V6L);
-            d7 = Unsafe.As<Vector4, Vector<float>>(ref s.V7L);
+        d7 = Unsafe.As<Vector4, Vector<float>>(ref s.V7L);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector8_V3()
+    public void UseVector8_V3()
-        {
+    {
-            int stride = Width * sizeof(float);
+        int stride = Width * sizeof(float);
-            ref float d = ref this.unpinnedBuffer[0];
+        ref float d = ref this.unpinnedBuffer[0];
-            ref Vector<float> s = ref Unsafe.As<Block8x8F, Vector<float>>(ref this.block);
+        ref Vector<float> s = ref Unsafe.As<Block8x8F, Vector<float>>(ref this.block);
-
+
-            Vector<float> v0 = s;
+        Vector<float> v0 = s;
-            Vector<float> v1 = Unsafe.AddByteOffset(ref s, (IntPtr)1);
+        Vector<float> v1 = Unsafe.AddByteOffset(ref s, (IntPtr)1);
-            Vector<float> v2 = Unsafe.AddByteOffset(ref s, (IntPtr)2);
+        Vector<float> v2 = Unsafe.AddByteOffset(ref s, (IntPtr)2);
-            Vector<float> v3 = Unsafe.AddByteOffset(ref s, (IntPtr)3);
+        Vector<float> v3 = Unsafe.AddByteOffset(ref s, (IntPtr)3);
-
+
-            Unsafe.As<float, Vector<float>>(ref d) = v0;
+        Unsafe.As<float, Vector<float>>(ref d) = v0;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)stride)) = v1;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)stride)) = v1;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 2))) = v2;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 2))) = v2;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 3))) = v3;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 3))) = v3;
-
+
-            v0 = Unsafe.AddByteOffset(ref s, (IntPtr)4);
+        v0 = Unsafe.AddByteOffset(ref s, (IntPtr)4);
-            v1 = Unsafe.AddByteOffset(ref s, (IntPtr)5);
+        v1 = Unsafe.AddByteOffset(ref s, (IntPtr)5);
-            v2 = Unsafe.AddByteOffset(ref s, (IntPtr)6);
+        v2 = Unsafe.AddByteOffset(ref s, (IntPtr)6);
-            v3 = Unsafe.AddByteOffset(ref s, (IntPtr)7);
+        v3 = Unsafe.AddByteOffset(ref s, (IntPtr)7);
-
+
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 4))) = v0;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 4))) = v0;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 5))) = v1;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 5))) = v1;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 6))) = v2;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 6))) = v2;
-            Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 7))) = v3;
+        Unsafe.As<float, Vector<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 7))) = v3;
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector256_Avx2_Variant1()
+    public void UseVector256_Avx2_Variant1()
-        {
+    {
-            int stride = Width;
+        int stride = Width;
-            float* d = this.bufferPtr;
+        float* d = this.bufferPtr;
-            float* s = this.blockPtr;
+        float* s = this.blockPtr;
-            Vector256<float> v;
+        Vector256<float> v;
 
-            v = Avx.LoadVector256(s);
+        v = Avx.LoadVector256(s);
-            Avx.Store(d, v);
+        Avx.Store(d, v);
 
-            v = Avx.LoadVector256(s + 8);
+        v = Avx.LoadVector256(s + 8);
-            Avx.Store(d + stride, v);
+        Avx.Store(d + stride, v);
 
-            v = Avx.LoadVector256(s + (8 * 2));
+        v = Avx.LoadVector256(s + (8 * 2));
-            Avx.Store(d + (stride * 2), v);
+        Avx.Store(d + (stride * 2), v);
 
-            v = Avx.LoadVector256(s + (8 * 3));
+        v = Avx.LoadVector256(s + (8 * 3));
-            Avx.Store(d + (stride * 3), v);
+        Avx.Store(d + (stride * 3), v);
 
-            v = Avx.LoadVector256(s + (8 * 4));
+        v = Avx.LoadVector256(s + (8 * 4));
-            Avx.Store(d + (stride * 4), v);
+        Avx.Store(d + (stride * 4), v);
 
-            v = Avx.LoadVector256(s + (8 * 5));
+        v = Avx.LoadVector256(s + (8 * 5));
-            Avx.Store(d + (stride * 5), v);
+        Avx.Store(d + (stride * 5), v);
 
-            v = Avx.LoadVector256(s + (8 * 6));
+        v = Avx.LoadVector256(s + (8 * 6));
-            Avx.Store(d + (stride * 6), v);
+        Avx.Store(d + (stride * 6), v);
 
-            v = Avx.LoadVector256(s + (8 * 7));
+        v = Avx.LoadVector256(s + (8 * 7));
-            Avx.Store(d + (stride * 7), v);
+        Avx.Store(d + (stride * 7), v);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector256_Avx2_Variant2()
+    public void UseVector256_Avx2_Variant2()
-        {
+    {
-            int stride = Width;
+        int stride = Width;
-            float* d = this.bufferPtr;
+        float* d = this.bufferPtr;
-            float* s = this.blockPtr;
+        float* s = this.blockPtr;
-
+
-            Vector256<float> v0 = Avx.LoadVector256(s);
+        Vector256<float> v0 = Avx.LoadVector256(s);
-            Vector256<float> v1 = Avx.LoadVector256(s + 8);
+        Vector256<float> v1 = Avx.LoadVector256(s + 8);
-            Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
+        Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
-            Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
+        Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
-            Vector256<float> v4 = Avx.LoadVector256(s + (8 * 4));
+        Vector256<float> v4 = Avx.LoadVector256(s + (8 * 4));
-            Vector256<float> v5 = Avx.LoadVector256(s + (8 * 5));
+        Vector256<float> v5 = Avx.LoadVector256(s + (8 * 5));
-            Vector256<float> v6 = Avx.LoadVector256(s + (8 * 6));
+        Vector256<float> v6 = Avx.LoadVector256(s + (8 * 6));
-            Vector256<float> v7 = Avx.LoadVector256(s + (8 * 7));
+        Vector256<float> v7 = Avx.LoadVector256(s + (8 * 7));
-
+
-            Avx.Store(d, v0);
+        Avx.Store(d, v0);
-            Avx.Store(d + stride, v1);
+        Avx.Store(d + stride, v1);
-            Avx.Store(d + (stride * 2), v2);
+        Avx.Store(d + (stride * 2), v2);
-            Avx.Store(d + (stride * 3), v3);
+        Avx.Store(d + (stride * 3), v3);
-            Avx.Store(d + (stride * 4), v4);
+        Avx.Store(d + (stride * 4), v4);
-            Avx.Store(d + (stride * 5), v5);
+        Avx.Store(d + (stride * 5), v5);
-            Avx.Store(d + (stride * 6), v6);
+        Avx.Store(d + (stride * 6), v6);
-            Avx.Store(d + (stride * 7), v7);
+        Avx.Store(d + (stride * 7), v7);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector256_Avx2_Variant3()
+    public void UseVector256_Avx2_Variant3()
-        {
+    {
-            int stride = Width;
+        int stride = Width;
-            float* d = this.bufferPtr;
+        float* d = this.bufferPtr;
-            float* s = this.blockPtr;
+        float* s = this.blockPtr;
-
+
-            Vector256<float> v0 = Avx.LoadVector256(s);
+        Vector256<float> v0 = Avx.LoadVector256(s);
-            Vector256<float> v1 = Avx.LoadVector256(s + 8);
+        Vector256<float> v1 = Avx.LoadVector256(s + 8);
-            Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
+        Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
-            Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
+        Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
-            Avx.Store(d, v0);
+        Avx.Store(d, v0);
-            Avx.Store(d + stride, v1);
+        Avx.Store(d + stride, v1);
-            Avx.Store(d + (stride * 2), v2);
+        Avx.Store(d + (stride * 2), v2);
-            Avx.Store(d + (stride * 3), v3);
+        Avx.Store(d + (stride * 3), v3);
-
+
-            v0 = Avx.LoadVector256(s + (8 * 4));
+        v0 = Avx.LoadVector256(s + (8 * 4));
-            v1 = Avx.LoadVector256(s + (8 * 5));
+        v1 = Avx.LoadVector256(s + (8 * 5));
-            v2 = Avx.LoadVector256(s + (8 * 6));
+        v2 = Avx.LoadVector256(s + (8 * 6));
-            v3 = Avx.LoadVector256(s + (8 * 7));
+        v3 = Avx.LoadVector256(s + (8 * 7));
-            Avx.Store(d + (stride * 4), v0);
+        Avx.Store(d + (stride * 4), v0);
-            Avx.Store(d + (stride * 5), v1);
+        Avx.Store(d + (stride * 5), v1);
-            Avx.Store(d + (stride * 6), v2);
+        Avx.Store(d + (stride * 6), v2);
-            Avx.Store(d + (stride * 7), v3);
+        Avx.Store(d + (stride * 7), v3);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector256_Avx2_Variant3_RefCast()
+    public void UseVector256_Avx2_Variant3_RefCast()
-        {
+    {
-            int stride = Width;
+        int stride = Width;
-            ref float d = ref this.unpinnedBuffer[0];
+        ref float d = ref this.unpinnedBuffer[0];
-            ref Vector256<float> s = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this.block);
+        ref Vector256<float> s = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this.block);
-
+
-            Vector256<float> v0 = s;
+        Vector256<float> v0 = s;
-            Vector256<float> v1 = Unsafe.Add(ref s, 1);
+        Vector256<float> v1 = Unsafe.Add(ref s, 1);
-            Vector256<float> v2 = Unsafe.Add(ref s, 2);
+        Vector256<float> v2 = Unsafe.Add(ref s, 2);
-            Vector256<float> v3 = Unsafe.Add(ref s, 3);
+        Vector256<float> v3 = Unsafe.Add(ref s, 3);
-
+
-            Unsafe.As<float, Vector256<float>>(ref d) = v0;
+        Unsafe.As<float, Vector256<float>>(ref d) = v0;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride)) = v1;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride)) = v1;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 2)) = v2;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 2)) = v2;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 3)) = v3;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 3)) = v3;
-
+
-            v0 = Unsafe.Add(ref s, 4);
+        v0 = Unsafe.Add(ref s, 4);
-            v1 = Unsafe.Add(ref s, 5);
+        v1 = Unsafe.Add(ref s, 5);
-            v2 = Unsafe.Add(ref s, 6);
+        v2 = Unsafe.Add(ref s, 6);
-            v3 = Unsafe.Add(ref s, 7);
+        v3 = Unsafe.Add(ref s, 7);
-
+
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 4)) = v0;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 4)) = v0;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 5)) = v1;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 5)) = v1;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 6)) = v2;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 6)) = v2;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 7)) = v3;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.Add(ref d, stride * 7)) = v3;
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void UseVector256_Avx2_Variant3_RefCast_Mod()
+    public void UseVector256_Avx2_Variant3_RefCast_Mod()
-        {
+    {
-            int stride = Width * sizeof(float);
+        int stride = Width * sizeof(float);
-            ref float d = ref this.unpinnedBuffer[0];
+        ref float d = ref this.unpinnedBuffer[0];
-            ref Vector256<float> s = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this.block);
+        ref Vector256<float> s = ref Unsafe.As<Block8x8F, Vector256<float>>(ref this.block);
-
+
-            Vector256<float> v0 = s;
+        Vector256<float> v0 = s;
-            Vector256<float> v1 = Unsafe.AddByteOffset(ref s, (IntPtr)1);
+        Vector256<float> v1 = Unsafe.AddByteOffset(ref s, (IntPtr)1);
-            Vector256<float> v2 = Unsafe.AddByteOffset(ref s, (IntPtr)2);
+        Vector256<float> v2 = Unsafe.AddByteOffset(ref s, (IntPtr)2);
-            Vector256<float> v3 = Unsafe.AddByteOffset(ref s, (IntPtr)3);
+        Vector256<float> v3 = Unsafe.AddByteOffset(ref s, (IntPtr)3);
-
+
-            Unsafe.As<float, Vector256<float>>(ref d) = v0;
+        Unsafe.As<float, Vector256<float>>(ref d) = v0;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)stride)) = v1;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)stride)) = v1;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 2))) = v2;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 2))) = v2;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 3))) = v3;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 3))) = v3;
-
+
-            v0 = Unsafe.AddByteOffset(ref s, (IntPtr)4);
+        v0 = Unsafe.AddByteOffset(ref s, (IntPtr)4);
-            v1 = Unsafe.AddByteOffset(ref s, (IntPtr)5);
+        v1 = Unsafe.AddByteOffset(ref s, (IntPtr)5);
-            v2 = Unsafe.AddByteOffset(ref s, (IntPtr)6);
+        v2 = Unsafe.AddByteOffset(ref s, (IntPtr)6);
-            v3 = Unsafe.AddByteOffset(ref s, (IntPtr)7);
+        v3 = Unsafe.AddByteOffset(ref s, (IntPtr)7);
-
+
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 4))) = v0;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 4))) = v0;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 5))) = v1;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 5))) = v1;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 6))) = v2;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 6))) = v2;
-            Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 7))) = v3;
+        Unsafe.As<float, Vector256<float>>(ref Unsafe.AddByteOffset(ref d, (IntPtr)(stride * 7))) = v3;
-        }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void UseVector256_Avx2_Variant3_WithLocalPinning()
+    public void UseVector256_Avx2_Variant3_WithLocalPinning()
+    {
+        int stride = Width;
+        fixed (float* d = this.unpinnedBuffer)
         {
-            int stride = Width;
+            fixed (Block8x8F* ss = &this.block)
-            fixed (float* d = this.unpinnedBuffer)
             {
-                fixed (Block8x8F* ss = &this.block)
+                float* s = (float*)ss;
-                {
+                Vector256<float> v0 = Avx.LoadVector256(s);
-                    float* s = (float*)ss;
+                Vector256<float> v1 = Avx.LoadVector256(s + 8);
-                    Vector256<float> v0 = Avx.LoadVector256(s);
+                Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
-                    Vector256<float> v1 = Avx.LoadVector256(s + 8);
+                Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
-                    Vector256<float> v2 = Avx.LoadVector256(s + (8 * 2));
+                Avx.Store(d, v0);
-                    Vector256<float> v3 = Avx.LoadVector256(s + (8 * 3));
+                Avx.Store(d + stride, v1);
-                    Avx.Store(d, v0);
+                Avx.Store(d + (stride * 2), v2);
-                    Avx.Store(d + stride, v1);
+                Avx.Store(d + (stride * 3), v3);
-                    Avx.Store(d + (stride * 2), v2);
+
-                    Avx.Store(d + (stride * 3), v3);
+                v0 = Avx.LoadVector256(s + (8 * 4));
-
+                v1 = Avx.LoadVector256(s + (8 * 5));
-                    v0 = Avx.LoadVector256(s + (8 * 4));
+                v2 = Avx.LoadVector256(s + (8 * 6));
-                    v1 = Avx.LoadVector256(s + (8 * 5));
+                v3 = Avx.LoadVector256(s + (8 * 7));
-                    v2 = Avx.LoadVector256(s + (8 * 6));
+                Avx.Store(d + (stride * 4), v0);
-                    v3 = Avx.LoadVector256(s + (8 * 7));
+                Avx.Store(d + (stride * 5), v1);
-                    Avx.Store(d + (stride * 4), v0);
+                Avx.Store(d + (stride * 6), v2);
-                    Avx.Store(d + (stride * 5), v1);
+                Avx.Store(d + (stride * 7), v3);
-                    Avx.Store(d + (stride * 6), v2);
-                    Avx.Store(d + (stride * 7), v3);
-                }
             }
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void UseVector256_Avx2_Variant3_sbyte()
+    public void UseVector256_Avx2_Variant3_sbyte()
-        {
+    {
-            int stride = Width * 4;
+        int stride = Width * 4;
-            sbyte* d = (sbyte*)this.bufferPtr;
+        sbyte* d = (sbyte*)this.bufferPtr;
-            sbyte* s = (sbyte*)this.blockPtr;
+        sbyte* s = (sbyte*)this.blockPtr;
-
+
-            Vector256<sbyte> v0 = Avx.LoadVector256(s);
+        Vector256<sbyte> v0 = Avx.LoadVector256(s);
-            Vector256<sbyte> v1 = Avx.LoadVector256(s + 32);
+        Vector256<sbyte> v1 = Avx.LoadVector256(s + 32);
-            Vector256<sbyte> v2 = Avx.LoadVector256(s + (32 * 2));
+        Vector256<sbyte> v2 = Avx.LoadVector256(s + (32 * 2));
-            Vector256<sbyte> v3 = Avx.LoadVector256(s + (32 * 3));
+        Vector256<sbyte> v3 = Avx.LoadVector256(s + (32 * 3));
-            Avx.Store(d, v0);
+        Avx.Store(d, v0);
-            Avx.Store(d + stride, v1);
+        Avx.Store(d + stride, v1);
-            Avx.Store(d + (stride * 2), v2);
+        Avx.Store(d + (stride * 2), v2);
-            Avx.Store(d + (stride * 3), v3);
+        Avx.Store(d + (stride * 3), v3);
-
+
-            v0 = Avx.LoadVector256(s + (32 * 4));
+        v0 = Avx.LoadVector256(s + (32 * 4));
-            v1 = Avx.LoadVector256(s + (32 * 5));
+        v1 = Avx.LoadVector256(s + (32 * 5));
-            v2 = Avx.LoadVector256(s + (32 * 6));
+        v2 = Avx.LoadVector256(s + (32 * 6));
-            v3 = Avx.LoadVector256(s + (32 * 7));
+        v3 = Avx.LoadVector256(s + (32 * 7));
-            Avx.Store(d + (stride * 4), v0);
+        Avx.Store(d + (stride * 4), v0);
-            Avx.Store(d + (stride * 5), v1);
+        Avx.Store(d + (stride * 5), v1);
-            Avx.Store(d + (stride * 6), v2);
+        Avx.Store(d + (stride * 6), v2);
-            Avx.Store(d + (stride * 7), v3);
+        Avx.Store(d + (stride * 7), v3);
-        }
-
-        // *** RESULTS 02/2020 ***
-        // BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
-        // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-        // .NET Core SDK=3.1.200-preview-014971
-        //   [Host]     : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
-        //   DefaultJob : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
-        //
-        //
-        // |                                 Method |     Mean |     Error |    StdDev | Ratio | RatioSD |
-        // |--------------------------------------- |---------:|----------:|----------:|------:|--------:|
-        // |                               Original | 4.012 ns | 0.0567 ns | 0.0531 ns |  1.00 |    0.00 |
-        // |                          UseVector8_V3 | 4.013 ns | 0.0947 ns | 0.0840 ns |  1.00 |    0.03 |
-        // |             UseVector256_Avx2_Variant1 | 2.546 ns | 0.0376 ns | 0.0314 ns |  0.63 |    0.01 |
-        // |             UseVector256_Avx2_Variant2 | 2.643 ns | 0.0162 ns | 0.0151 ns |  0.66 |    0.01 |
-        // |             UseVector256_Avx2_Variant3 | 2.520 ns | 0.0760 ns | 0.0813 ns |  0.63 |    0.02 |
-        // |     UseVector256_Avx2_Variant3_RefCast | 2.300 ns | 0.0877 ns | 0.0938 ns |  0.58 |    0.03 |
-        // | UseVector256_Avx2_Variant3_RefCast_Mod | 2.139 ns | 0.0698 ns | 0.0686 ns |  0.53 |    0.02 |
     }
+
+    // *** RESULTS 02/2020 ***
+    // BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
+    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+    // .NET Core SDK=3.1.200-preview-014971
+    //   [Host]     : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
+    //   DefaultJob : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
+    //
+    //
+    // |                                 Method |     Mean |     Error |    StdDev | Ratio | RatioSD |
+    // |--------------------------------------- |---------:|----------:|----------:|------:|--------:|
+    // |                               Original | 4.012 ns | 0.0567 ns | 0.0531 ns |  1.00 |    0.00 |
+    // |                          UseVector8_V3 | 4.013 ns | 0.0947 ns | 0.0840 ns |  1.00 |    0.03 |
+    // |             UseVector256_Avx2_Variant1 | 2.546 ns | 0.0376 ns | 0.0314 ns |  0.63 |    0.01 |
+    // |             UseVector256_Avx2_Variant2 | 2.643 ns | 0.0162 ns | 0.0151 ns |  0.66 |    0.01 |
+    // |             UseVector256_Avx2_Variant3 | 2.520 ns | 0.0760 ns | 0.0813 ns |  0.63 |    0.02 |
+    // |     UseVector256_Avx2_Variant3_RefCast | 2.300 ns | 0.0877 ns | 0.0938 ns |  0.58 |    0.03 |
+    // | UseVector256_Avx2_Variant3_RefCast_Mod | 2.139 ns | 0.0698 ns | 0.0686 ns |  0.53 |    0.02 |
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_CopyTo2x2.cs

@@ -9,402 +9,401 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Memory;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+public class Block8x8F_CopyTo2x2
 {
-    public class Block8x8F_CopyTo2x2
+    private Block8x8F block;
+
+    private Buffer2D<float> buffer;
+
+    private Buffer2DRegion<float> destRegion;
+
+    [GlobalSetup]
+    public void Setup()
     {
-        private Block8x8F block;
+        this.buffer = Configuration.Default.MemoryAllocator.Allocate2D<float>(1000, 500);
+        this.destRegion = this.buffer.GetRegion(200, 100, 128, 128);
+    }
 
-        private Buffer2D<float> buffer;
+    [Benchmark(Baseline = true)]
+    public void Original()
+    {
+        ref float destBase = ref this.destRegion.GetReferenceToOrigin();
+        int destStride = this.destRegion.Stride;
+
+        ref Block8x8F src = ref this.block;
+
+        WidenCopyImpl2x2(ref src, ref destBase, 0, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 1, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 2, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 3, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 4, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 5, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 6, destStride);
+        WidenCopyImpl2x2(ref src, ref destBase, 7, destStride);
+    }
 
-        private Buffer2DRegion<float> destRegion;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void WidenCopyImpl2x2(ref Block8x8F src, ref float destBase, int row, int destStride)
+    {
+        ref Vector4 selfLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+        ref Vector4 selfRight = ref Unsafe.Add(ref selfLeft, 1);
+        ref float destLocalOrigo = ref Unsafe.Add(ref destBase, row * 2 * destStride);
+
+        Unsafe.Add(ref destLocalOrigo, 0) = selfLeft.X;
+        Unsafe.Add(ref destLocalOrigo, 1) = selfLeft.X;
+        Unsafe.Add(ref destLocalOrigo, 2) = selfLeft.Y;
+        Unsafe.Add(ref destLocalOrigo, 3) = selfLeft.Y;
+        Unsafe.Add(ref destLocalOrigo, 4) = selfLeft.Z;
+        Unsafe.Add(ref destLocalOrigo, 5) = selfLeft.Z;
+        Unsafe.Add(ref destLocalOrigo, 6) = selfLeft.W;
+        Unsafe.Add(ref destLocalOrigo, 7) = selfLeft.W;
+
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 0) = selfRight.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 1) = selfRight.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 2) = selfRight.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 3) = selfRight.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 4) = selfRight.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 5) = selfRight.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 6) = selfRight.W;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 7) = selfRight.W;
+
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 0) = selfLeft.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 1) = selfLeft.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 2) = selfLeft.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 3) = selfLeft.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 4) = selfLeft.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 5) = selfLeft.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 6) = selfLeft.W;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 7) = selfLeft.W;
+
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 0) = selfRight.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 1) = selfRight.X;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 2) = selfRight.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 3) = selfRight.Y;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 4) = selfRight.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 5) = selfRight.Z;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 6) = selfRight.W;
+        Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 7) = selfRight.W;
+    }
 
-        [GlobalSetup]
+    [Benchmark]
-        public void Setup()
+    public void Original_V2()
-        {
+    {
-            this.buffer = Configuration.Default.MemoryAllocator.Allocate2D<float>(1000, 500);
+        ref float destBase = ref this.destRegion.GetReferenceToOrigin();
-            this.destRegion = this.buffer.GetRegion(200, 100, 128, 128);
+        int destStride = this.destRegion.Stride;
-        }
+
+        ref Block8x8F src = ref this.block;
+
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 0, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 1, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 2, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 3, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 4, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 5, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 6, destStride);
+        WidenCopyImpl2x2_V2(ref src, ref destBase, 7, destStride);
+    }
 
-        [Benchmark(Baseline = true)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Original()
+    private static void WidenCopyImpl2x2_V2(ref Block8x8F src, ref float destBase, int row, int destStride)
-        {
+    {
-            ref float destBase = ref this.destRegion.GetReferenceToOrigin();
+        ref Vector4 selfLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
-            int destStride = this.destRegion.Stride;
+        ref Vector4 selfRight = ref Unsafe.Add(ref selfLeft, 1);
-
+        ref float dest0 = ref Unsafe.Add(ref destBase, row * 2 * destStride);
-            ref Block8x8F src = ref this.block;
+
-
+        Unsafe.Add(ref dest0, 0) = selfLeft.X;
-            WidenCopyImpl2x2(ref src, ref destBase, 0, destStride);
+        Unsafe.Add(ref dest0, 1) = selfLeft.X;
-            WidenCopyImpl2x2(ref src, ref destBase, 1, destStride);
+        Unsafe.Add(ref dest0, 2) = selfLeft.Y;
-            WidenCopyImpl2x2(ref src, ref destBase, 2, destStride);
+        Unsafe.Add(ref dest0, 3) = selfLeft.Y;
-            WidenCopyImpl2x2(ref src, ref destBase, 3, destStride);
+        Unsafe.Add(ref dest0, 4) = selfLeft.Z;
-            WidenCopyImpl2x2(ref src, ref destBase, 4, destStride);
+        Unsafe.Add(ref dest0, 5) = selfLeft.Z;
-            WidenCopyImpl2x2(ref src, ref destBase, 5, destStride);
+        Unsafe.Add(ref dest0, 6) = selfLeft.W;
-            WidenCopyImpl2x2(ref src, ref destBase, 6, destStride);
+        Unsafe.Add(ref dest0, 7) = selfLeft.W;
-            WidenCopyImpl2x2(ref src, ref destBase, 7, destStride);
+
-        }
+        ref float dest1 = ref Unsafe.Add(ref dest0, 8);
-
+
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        Unsafe.Add(ref dest1, 0) = selfRight.X;
-        private static void WidenCopyImpl2x2(ref Block8x8F src, ref float destBase, int row, int destStride)
+        Unsafe.Add(ref dest1, 1) = selfRight.X;
-        {
+        Unsafe.Add(ref dest1, 2) = selfRight.Y;
-            ref Vector4 selfLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+        Unsafe.Add(ref dest1, 3) = selfRight.Y;
-            ref Vector4 selfRight = ref Unsafe.Add(ref selfLeft, 1);
+        Unsafe.Add(ref dest1, 4) = selfRight.Z;
-            ref float destLocalOrigo = ref Unsafe.Add(ref destBase, row * 2 * destStride);
+        Unsafe.Add(ref dest1, 5) = selfRight.Z;
-
+        Unsafe.Add(ref dest1, 6) = selfRight.W;
-            Unsafe.Add(ref destLocalOrigo, 0) = selfLeft.X;
+        Unsafe.Add(ref dest1, 7) = selfRight.W;
-            Unsafe.Add(ref destLocalOrigo, 1) = selfLeft.X;
+
-            Unsafe.Add(ref destLocalOrigo, 2) = selfLeft.Y;
+        ref float dest2 = ref Unsafe.Add(ref dest0, destStride);
-            Unsafe.Add(ref destLocalOrigo, 3) = selfLeft.Y;
+
-            Unsafe.Add(ref destLocalOrigo, 4) = selfLeft.Z;
+        Unsafe.Add(ref dest2, 0) = selfLeft.X;
-            Unsafe.Add(ref destLocalOrigo, 5) = selfLeft.Z;
+        Unsafe.Add(ref dest2, 1) = selfLeft.X;
-            Unsafe.Add(ref destLocalOrigo, 6) = selfLeft.W;
+        Unsafe.Add(ref dest2, 2) = selfLeft.Y;
-            Unsafe.Add(ref destLocalOrigo, 7) = selfLeft.W;
+        Unsafe.Add(ref dest2, 3) = selfLeft.Y;
-
+        Unsafe.Add(ref dest2, 4) = selfLeft.Z;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 0) = selfRight.X;
+        Unsafe.Add(ref dest2, 5) = selfLeft.Z;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 1) = selfRight.X;
+        Unsafe.Add(ref dest2, 6) = selfLeft.W;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 2) = selfRight.Y;
+        Unsafe.Add(ref dest2, 7) = selfLeft.W;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 3) = selfRight.Y;
+
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 4) = selfRight.Z;
+        ref float dest3 = ref Unsafe.Add(ref dest2, 8);
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 5) = selfRight.Z;
+
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 6) = selfRight.W;
+        Unsafe.Add(ref dest3, 0) = selfRight.X;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, 8), 7) = selfRight.W;
+        Unsafe.Add(ref dest3, 1) = selfRight.X;
-
+        Unsafe.Add(ref dest3, 2) = selfRight.Y;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 0) = selfLeft.X;
+        Unsafe.Add(ref dest3, 3) = selfRight.Y;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 1) = selfLeft.X;
+        Unsafe.Add(ref dest3, 4) = selfRight.Z;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 2) = selfLeft.Y;
+        Unsafe.Add(ref dest3, 5) = selfRight.Z;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 3) = selfLeft.Y;
+        Unsafe.Add(ref dest3, 6) = selfRight.W;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 4) = selfLeft.Z;
+        Unsafe.Add(ref dest3, 7) = selfRight.W;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 5) = selfLeft.Z;
+    }
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 6) = selfLeft.W;
+
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride), 7) = selfLeft.W;
+    [Benchmark]
-
+    public void UseVector2()
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 0) = selfRight.X;
+    {
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 1) = selfRight.X;
+        ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 2) = selfRight.Y;
+        int destStride = this.destRegion.Stride / 2;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 3) = selfRight.Y;
+
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 4) = selfRight.Z;
+        ref Block8x8F src = ref this.block;
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 5) = selfRight.Z;
+
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 6) = selfRight.W;
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 0, destStride);
-            Unsafe.Add(ref Unsafe.Add(ref destLocalOrigo, destStride + 8), 7) = selfRight.W;
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 1, destStride);
-        }
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 2, destStride);
-
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 3, destStride);
-        [Benchmark]
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 4, destStride);
-        public void Original_V2()
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 5, destStride);
-        {
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 6, destStride);
-            ref float destBase = ref this.destRegion.GetReferenceToOrigin();
+        WidenCopyImpl2x2_Vector2(ref src, ref destBase, 7, destStride);
-            int destStride = this.destRegion.Stride;
+    }
-
+
-            ref Block8x8F src = ref this.block;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+    private static void WidenCopyImpl2x2_Vector2(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 0, destStride);
+    {
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 1, destStride);
+        ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 2, destStride);
+        ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 3, destStride);
+
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 4, destStride);
+        ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 5, destStride);
+        ref Vector2 dTopRight = ref Unsafe.Add(ref dTopLeft, 4);
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 6, destStride);
+        ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
-            WidenCopyImpl2x2_V2(ref src, ref destBase, 7, destStride);
+        ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
-        }
+
-
+        var xLeft = new Vector2(sLeft.X);
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        var yLeft = new Vector2(sLeft.Y);
-        private static void WidenCopyImpl2x2_V2(ref Block8x8F src, ref float destBase, int row, int destStride)
+        var zLeft = new Vector2(sLeft.Z);
-        {
+        var wLeft = new Vector2(sLeft.W);
-            ref Vector4 selfLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+
-            ref Vector4 selfRight = ref Unsafe.Add(ref selfLeft, 1);
+        var xRight = new Vector2(sRight.X);
-            ref float dest0 = ref Unsafe.Add(ref destBase, row * 2 * destStride);
+        var yRight = new Vector2(sRight.Y);
-
+        var zRight = new Vector2(sRight.Z);
-            Unsafe.Add(ref dest0, 0) = selfLeft.X;
+        var wRight = new Vector2(sRight.W);
-            Unsafe.Add(ref dest0, 1) = selfLeft.X;
+
-            Unsafe.Add(ref dest0, 2) = selfLeft.Y;
+        dTopLeft = xLeft;
-            Unsafe.Add(ref dest0, 3) = selfLeft.Y;
+        Unsafe.Add(ref dTopLeft, 1) = yLeft;
-            Unsafe.Add(ref dest0, 4) = selfLeft.Z;
+        Unsafe.Add(ref dTopLeft, 2) = zLeft;
-            Unsafe.Add(ref dest0, 5) = selfLeft.Z;
+        Unsafe.Add(ref dTopLeft, 3) = wLeft;
-            Unsafe.Add(ref dest0, 6) = selfLeft.W;
+
-            Unsafe.Add(ref dest0, 7) = selfLeft.W;
+        dTopRight = xRight;
-
+        Unsafe.Add(ref dTopRight, 1) = yRight;
-            ref float dest1 = ref Unsafe.Add(ref dest0, 8);
+        Unsafe.Add(ref dTopRight, 2) = zRight;
-
+        Unsafe.Add(ref dTopRight, 3) = wRight;
-            Unsafe.Add(ref dest1, 0) = selfRight.X;
+
-            Unsafe.Add(ref dest1, 1) = selfRight.X;
+        dBottomLeft = xLeft;
-            Unsafe.Add(ref dest1, 2) = selfRight.Y;
+        Unsafe.Add(ref dBottomLeft, 1) = yLeft;
-            Unsafe.Add(ref dest1, 3) = selfRight.Y;
+        Unsafe.Add(ref dBottomLeft, 2) = zLeft;
-            Unsafe.Add(ref dest1, 4) = selfRight.Z;
+        Unsafe.Add(ref dBottomLeft, 3) = wLeft;
-            Unsafe.Add(ref dest1, 5) = selfRight.Z;
+
-            Unsafe.Add(ref dest1, 6) = selfRight.W;
+        dBottomRight = xRight;
-            Unsafe.Add(ref dest1, 7) = selfRight.W;
+        Unsafe.Add(ref dBottomRight, 1) = yRight;
-
+        Unsafe.Add(ref dBottomRight, 2) = zRight;
-            ref float dest2 = ref Unsafe.Add(ref dest0, destStride);
+        Unsafe.Add(ref dBottomRight, 3) = wRight;
-
+    }
-            Unsafe.Add(ref dest2, 0) = selfLeft.X;
+
-            Unsafe.Add(ref dest2, 1) = selfLeft.X;
+    [Benchmark]
-            Unsafe.Add(ref dest2, 2) = selfLeft.Y;
+    public void UseVector4()
-            Unsafe.Add(ref dest2, 3) = selfLeft.Y;
+    {
-            Unsafe.Add(ref dest2, 4) = selfLeft.Z;
+        ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
-            Unsafe.Add(ref dest2, 5) = selfLeft.Z;
+        int destStride = this.destRegion.Stride / 2;
-            Unsafe.Add(ref dest2, 6) = selfLeft.W;
+
-            Unsafe.Add(ref dest2, 7) = selfLeft.W;
+        ref Block8x8F src = ref this.block;
-
+
-            ref float dest3 = ref Unsafe.Add(ref dest2, 8);
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 0, destStride);
-
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 1, destStride);
-            Unsafe.Add(ref dest3, 0) = selfRight.X;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 2, destStride);
-            Unsafe.Add(ref dest3, 1) = selfRight.X;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 3, destStride);
-            Unsafe.Add(ref dest3, 2) = selfRight.Y;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 4, destStride);
-            Unsafe.Add(ref dest3, 3) = selfRight.Y;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 5, destStride);
-            Unsafe.Add(ref dest3, 4) = selfRight.Z;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 6, destStride);
-            Unsafe.Add(ref dest3, 5) = selfRight.Z;
+        WidenCopyImpl2x2_Vector4(ref src, ref destBase, 7, destStride);
-            Unsafe.Add(ref dest3, 6) = selfRight.W;
+    }
-            Unsafe.Add(ref dest3, 7) = selfRight.W;
+
-        }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+    private static void WidenCopyImpl2x2_Vector4(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
-        [Benchmark]
+    {
-        public void UseVector2()
+        ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
-        {
+        ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
-            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
+
-            int destStride = this.destRegion.Stride / 2;
+        ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
-
+        ref Vector2 dTopRight = ref Unsafe.Add(ref dTopLeft, 4);
-            ref Block8x8F src = ref this.block;
+        ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
-
+        ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 0, destStride);
+
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 1, destStride);
+        var xLeft = new Vector4(sLeft.X);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 2, destStride);
+        var yLeft = new Vector4(sLeft.Y);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 3, destStride);
+        var zLeft = new Vector4(sLeft.Z);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 4, destStride);
+        var wLeft = new Vector4(sLeft.W);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 5, destStride);
+
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 6, destStride);
+        var xRight = new Vector4(sRight.X);
-            WidenCopyImpl2x2_Vector2(ref src, ref destBase, 7, destStride);
+        var yRight = new Vector4(sRight.Y);
-        }
+        var zRight = new Vector4(sRight.Z);
-
+        var wRight = new Vector4(sRight.W);
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
-        private static void WidenCopyImpl2x2_Vector2(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
+        Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
-        {
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
-            ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 2)) = zLeft;
-            ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 3)) = wLeft;
-
+
-            ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
+        Unsafe.As<Vector2, Vector4>(ref dTopRight) = xRight;
-            ref Vector2 dTopRight = ref Unsafe.Add(ref dTopLeft, 4);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 1)) = yRight;
-            ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 2)) = zRight;
-            ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 3)) = wRight;
-
+
-            var xLeft = new Vector2(sLeft.X);
+        Unsafe.As<Vector2, Vector4>(ref dBottomLeft) = xLeft;
-            var yLeft = new Vector2(sLeft.Y);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 1)) = yLeft;
-            var zLeft = new Vector2(sLeft.Z);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 2)) = zLeft;
-            var wLeft = new Vector2(sLeft.W);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 3)) = wLeft;
-
+
-            var xRight = new Vector2(sRight.X);
+        Unsafe.As<Vector2, Vector4>(ref dBottomRight) = xRight;
-            var yRight = new Vector2(sRight.Y);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 1)) = yRight;
-            var zRight = new Vector2(sRight.Z);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 2)) = zRight;
-            var wRight = new Vector2(sRight.W);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 3)) = wRight;
-
+    }
-            dTopLeft = xLeft;
+
-            Unsafe.Add(ref dTopLeft, 1) = yLeft;
+    [Benchmark]
-            Unsafe.Add(ref dTopLeft, 2) = zLeft;
+    public void UseVector4_SafeRightCorner()
-            Unsafe.Add(ref dTopLeft, 3) = wLeft;
+    {
-
+        ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
-            dTopRight = xRight;
+        int destStride = this.destRegion.Stride / 2;
-            Unsafe.Add(ref dTopRight, 1) = yRight;
+
-            Unsafe.Add(ref dTopRight, 2) = zRight;
+        ref Block8x8F src = ref this.block;
-            Unsafe.Add(ref dTopRight, 3) = wRight;
+
-
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 0, destStride);
-            dBottomLeft = xLeft;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 1, destStride);
-            Unsafe.Add(ref dBottomLeft, 1) = yLeft;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 2, destStride);
-            Unsafe.Add(ref dBottomLeft, 2) = zLeft;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 3, destStride);
-            Unsafe.Add(ref dBottomLeft, 3) = wLeft;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 4, destStride);
-
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 5, destStride);
-            dBottomRight = xRight;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 6, destStride);
-            Unsafe.Add(ref dBottomRight, 1) = yRight;
+        WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 7, destStride);
-            Unsafe.Add(ref dBottomRight, 2) = zRight;
+    }
-            Unsafe.Add(ref dBottomRight, 3) = wRight;
+
-        }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+    private static void WidenCopyImpl2x2_Vector4_SafeRightCorner(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
-        [Benchmark]
+    {
-        public void UseVector4()
+        ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
-        {
+        ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
-            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
+
-            int destStride = this.destRegion.Stride / 2;
+        ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
-
+        ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
-            ref Block8x8F src = ref this.block;
+
-
+        var xLeft = new Vector4(sLeft.X);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 0, destStride);
+        var yLeft = new Vector4(sLeft.Y);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 1, destStride);
+        var zLeft = new Vector4(sLeft.Z);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 2, destStride);
+        var wLeft = new Vector4(sLeft.W);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 3, destStride);
+
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 4, destStride);
+        var xRight = new Vector4(sRight.X);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 5, destStride);
+        var yRight = new Vector4(sRight.Y);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 6, destStride);
+        var zRight = new Vector4(sRight.Z);
-            WidenCopyImpl2x2_Vector4(ref src, ref destBase, 7, destStride);
+        var wRight = new Vector2(sRight.W);
-        }
+
-
+        Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
-        private static void WidenCopyImpl2x2_Vector4(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 2)) = zLeft;
-        {
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 3)) = wLeft;
-            ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+
-            ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 4)) = xRight;
-
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 5)) = yRight;
-            ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 6)) = zRight;
-            ref Vector2 dTopRight = ref Unsafe.Add(ref dTopLeft, 4);
+        Unsafe.Add(ref dTopLeft, 7) = wRight;
-            ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
+
-            ref Vector2 dBottomRight = ref Unsafe.Add(ref dBottomLeft, 4);
+        Unsafe.As<Vector2, Vector4>(ref dBottomLeft) = xLeft;
-
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 1)) = yLeft;
-            var xLeft = new Vector4(sLeft.X);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 2)) = zLeft;
-            var yLeft = new Vector4(sLeft.Y);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 3)) = wLeft;
-            var zLeft = new Vector4(sLeft.Z);
+
-            var wLeft = new Vector4(sLeft.W);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 4)) = xRight;
-
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 5)) = yRight;
-            var xRight = new Vector4(sRight.X);
+        Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 6)) = zRight;
-            var yRight = new Vector4(sRight.Y);
+        Unsafe.Add(ref dBottomLeft, 7) = wRight;
-            var zRight = new Vector4(sRight.Z);
+    }
-            var wRight = new Vector4(sRight.W);
+
-
+    [Benchmark]
-            Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
+    public void UseVector4_V2()
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
+    {
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 2)) = zLeft;
+        ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 3)) = wLeft;
+        int destStride = this.destRegion.Stride / 2;
-
+
-            Unsafe.As<Vector2, Vector4>(ref dTopRight) = xRight;
+        ref Block8x8F src = ref this.block;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 1)) = yRight;
+
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 2)) = zRight;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 0, destStride);
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopRight, 3)) = wRight;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 1, destStride);
-
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 2, destStride);
-            Unsafe.As<Vector2, Vector4>(ref dBottomLeft) = xLeft;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 3, destStride);
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 1)) = yLeft;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 4, destStride);
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 2)) = zLeft;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 5, destStride);
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 3)) = wLeft;
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 6, destStride);
-
+        WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 7, destStride);
-            Unsafe.As<Vector2, Vector4>(ref dBottomRight) = xRight;
+    }
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 1)) = yRight;
+
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 2)) = zRight;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomRight, 3)) = wRight;
+    private static void WidenCopyImpl2x2_Vector4_V2(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
-        }
+    {
-
+        ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
-        [Benchmark]
+        ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
-        public void UseVector4_SafeRightCorner()
+
+        int offset = 2 * row * destStride;
+        ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset));
+        ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset + destStride));
+
+        var xyLeft = new Vector4(sLeft.X)
         {
-            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
+            Z = sLeft.Y,
-            int destStride = this.destRegion.Stride / 2;
+            W = sLeft.Y
-
+        };
-            ref Block8x8F src = ref this.block;
+
-
+        var zwLeft = new Vector4(sLeft.Z)
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 0, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 1, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 2, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 3, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 4, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 5, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 6, destStride);
-            WidenCopyImpl2x2_Vector4_SafeRightCorner(ref src, ref destBase, 7, destStride);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void WidenCopyImpl2x2_Vector4_SafeRightCorner(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
         {
-            ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+            Z = sLeft.W,
-            ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
+            W = sLeft.W
-
+        };
-            ref Vector2 dTopLeft = ref Unsafe.Add(ref destBase, 2 * row * destStride);
+
-            ref Vector2 dBottomLeft = ref Unsafe.Add(ref dTopLeft, destStride);
+        var xyRight = new Vector4(sRight.X)
-
-            var xLeft = new Vector4(sLeft.X);
-            var yLeft = new Vector4(sLeft.Y);
-            var zLeft = new Vector4(sLeft.Z);
-            var wLeft = new Vector4(sLeft.W);
-
-            var xRight = new Vector4(sRight.X);
-            var yRight = new Vector4(sRight.Y);
-            var zRight = new Vector4(sRight.Z);
-            var wRight = new Vector2(sRight.W);
-
-            Unsafe.As<Vector2, Vector4>(ref dTopLeft) = xLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 1)) = yLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 2)) = zLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 3)) = wLeft;
-
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 4)) = xRight;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 5)) = yRight;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dTopLeft, 6)) = zRight;
-            Unsafe.Add(ref dTopLeft, 7) = wRight;
-
-            Unsafe.As<Vector2, Vector4>(ref dBottomLeft) = xLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 1)) = yLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 2)) = zLeft;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 3)) = wLeft;
-
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 4)) = xRight;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 5)) = yRight;
-            Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref dBottomLeft, 6)) = zRight;
-            Unsafe.Add(ref dBottomLeft, 7) = wRight;
-        }
-
-        [Benchmark]
-        public void UseVector4_V2()
         {
-            ref Vector2 destBase = ref Unsafe.As<float, Vector2>(ref this.destRegion.GetReferenceToOrigin());
+            Z = sRight.Y,
-            int destStride = this.destRegion.Stride / 2;
+            W = sRight.Y
-
+        };
-            ref Block8x8F src = ref this.block;
+
-
+        var zwRight = new Vector4(sRight.Z)
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 0, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 1, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 2, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 3, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 4, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 5, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 6, destStride);
-            WidenCopyImpl2x2_Vector4_V2(ref src, ref destBase, 7, destStride);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void WidenCopyImpl2x2_Vector4_V2(ref Block8x8F src, ref Vector2 destBase, int row, int destStride)
         {
-            ref Vector4 sLeft = ref Unsafe.Add(ref src.V0L, 2 * row);
+            Z = sRight.W,
-            ref Vector4 sRight = ref Unsafe.Add(ref sLeft, 1);
+            W = sRight.W
-
+        };
-            int offset = 2 * row * destStride;
+
-            ref Vector4 dTopLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset));
+        dTopLeft = xyLeft;
-            ref Vector4 dBottomLeft = ref Unsafe.As<Vector2, Vector4>(ref Unsafe.Add(ref destBase, offset + destStride));
+        Unsafe.Add(ref dTopLeft, 1) = zwLeft;
-
+        Unsafe.Add(ref dTopLeft, 2) = xyRight;
-            var xyLeft = new Vector4(sLeft.X)
+        Unsafe.Add(ref dTopLeft, 3) = zwRight;
-            {
+
-                Z = sLeft.Y,
+        dBottomLeft = xyLeft;
-                W = sLeft.Y
+        Unsafe.Add(ref dBottomLeft, 1) = zwLeft;
-            };
+        Unsafe.Add(ref dBottomLeft, 2) = xyRight;
-
+        Unsafe.Add(ref dBottomLeft, 3) = zwRight;
-            var zwLeft = new Vector4(sLeft.Z)
-            {
-                Z = sLeft.W,
-                W = sLeft.W
-            };
-
-            var xyRight = new Vector4(sRight.X)
-            {
-                Z = sRight.Y,
-                W = sRight.Y
-            };
-
-            var zwRight = new Vector4(sRight.Z)
-            {
-                Z = sRight.W,
-                W = sRight.W
-            };
-
-            dTopLeft = xyLeft;
-            Unsafe.Add(ref dTopLeft, 1) = zwLeft;
-            Unsafe.Add(ref dTopLeft, 2) = xyRight;
-            Unsafe.Add(ref dTopLeft, 3) = zwRight;
-
-            dBottomLeft = xyLeft;
-            Unsafe.Add(ref dBottomLeft, 1) = zwLeft;
-            Unsafe.Add(ref dBottomLeft, 2) = xyRight;
-            Unsafe.Add(ref dBottomLeft, 3) = zwRight;
-        }
-
-        // RESULTS:
-        //                      Method |     Mean |     Error |    StdDev | Scaled | ScaledSD |
-        // --------------------------- |---------:|----------:|----------:|-------:|---------:|
-        //                    Original | 92.69 ns | 2.4722 ns | 2.7479 ns |   1.00 |     0.00 |
-        //                 Original_V2 | 91.72 ns | 1.2089 ns | 1.0095 ns |   0.99 |     0.03 |
-        //                  UseVector2 | 86.70 ns | 0.5873 ns | 0.5206 ns |   0.94 |     0.03 |
-        //                  UseVector4 | 55.42 ns | 0.2482 ns | 0.2322 ns |   0.60 |     0.02 |
-        //  UseVector4_SafeRightCorner | 58.97 ns | 0.4152 ns | 0.3884 ns |   0.64 |     0.02 |
-        //               UseVector4_V2 | 41.88 ns | 0.3531 ns | 0.3303 ns |   0.45 |     0.01 |
     }
+
+    // RESULTS:
+    //                      Method |     Mean |     Error |    StdDev | Scaled | ScaledSD |
+    // --------------------------- |---------:|----------:|----------:|-------:|---------:|
+    //                    Original | 92.69 ns | 2.4722 ns | 2.7479 ns |   1.00 |     0.00 |
+    //                 Original_V2 | 91.72 ns | 1.2089 ns | 1.0095 ns |   0.99 |     0.03 |
+    //                  UseVector2 | 86.70 ns | 0.5873 ns | 0.5206 ns |   0.94 |     0.03 |
+    //                  UseVector4 | 55.42 ns | 0.2482 ns | 0.2322 ns |   0.60 |     0.02 |
+    //  UseVector4_SafeRightCorner | 58.97 ns | 0.4152 ns | 0.3884 ns |   0.64 |     0.02 |
+    //               UseVector4_V2 | 41.88 ns | 0.3531 ns | 0.3303 ns |   0.45 |     0.01 |
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_DivideRound.cs

@@ -8,153 +8,152 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+/// <summary>
+/// The goal of this benchmark is to measure the following Jpeg-related scenario:
+/// - Take 2 blocks of float-s
+/// - Divide each float pair, round the result
+/// - Iterate through all rounded values as int-s
+/// </summary>
+public unsafe class Block8x8F_DivideRound
 {
-    /// <summary>
+    private const int ExecutionCount = 5; // Added this to reduce the effect of copying the blocks
-    /// The goal of this benchmark is to measure the following Jpeg-related scenario:
+    private static readonly Vector4 MinusOne = new Vector4(-1);
-    /// - Take 2 blocks of float-s
+    private static readonly Vector4 Half = new Vector4(0.5f);
-    /// - Divide each float pair, round the result
-    /// - Iterate through all rounded values as int-s
-    /// </summary>
-    public unsafe class Block8x8F_DivideRound
-    {
-        private const int ExecutionCount = 5; // Added this to reduce the effect of copying the blocks
-        private static readonly Vector4 MinusOne = new Vector4(-1);
-        private static readonly Vector4 Half = new Vector4(0.5f);
 
-        private Block8x8F inputDividend;
+    private Block8x8F inputDividend;
-        private Block8x8F inputDivisor;
+    private Block8x8F inputDivisor;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        for (int i = 0; i < Block8x8F.Size; i++)
         {
-            for (int i = 0; i < Block8x8F.Size; i++)
+            this.inputDividend[i] = i * 44.8f;
-            {
+            this.inputDivisor[i] = 100 - i;
-                this.inputDividend[i] = i * 44.8f;
-                this.inputDivisor[i] = 100 - i;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public int ByRationalIntegers()
+    public int ByRationalIntegers()
-        {
+    {
-            int sum = 0;
+        int sum = 0;
 
-            Block8x8F b1 = this.inputDividend;
+        Block8x8F b1 = this.inputDividend;
-            Block8x8F b2 = this.inputDivisor;
+        Block8x8F b2 = this.inputDivisor;
-            float* pDividend = (float*)&b1;
+        float* pDividend = (float*)&b1;
-            float* pDivisor = (float*)&b2;
+        float* pDivisor = (float*)&b2;
 
-            int* result = stackalloc int[Block8x8F.Size];
+        int* result = stackalloc int[Block8x8F.Size];
 
-            for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        {
+            sum = 0;
+            for (int i = 0; i < Block8x8F.Size; i++)
             {
-                sum = 0;
+                int a = (int)pDividend[i];
-                for (int i = 0; i < Block8x8F.Size; i++)
+                int b = (int)pDivisor;
-                {
+                result[i] = RationalRound(a, b);
-                    int a = (int)pDividend[i];
-                    int b = (int)pDivisor;
-                    result[i] = RationalRound(a, b);
-                }
-
-                for (int i = 0; i < Block8x8F.Size; i++)
-                {
-                    sum += result[i];
-                }
             }
 
-            return sum;
+            for (int i = 0; i < Block8x8F.Size; i++)
+            {
+                sum += result[i];
+            }
         }
 
-        [Benchmark]
+        return sum;
-        public int BySystemMathRound()
+    }
-        {
+
-            int sum = 0;
+    [Benchmark]
+    public int BySystemMathRound()
+    {
+        int sum = 0;
 
-            Block8x8F b1 = this.inputDividend;
+        Block8x8F b1 = this.inputDividend;
-            Block8x8F b2 = this.inputDivisor;
+        Block8x8F b2 = this.inputDivisor;
-            float* pDividend = (float*)&b1;
+        float* pDividend = (float*)&b1;
-            float* pDivisor = (float*)&b2;
+        float* pDivisor = (float*)&b2;
 
-            for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        {
+            sum = 0;
+            for (int i = 0; i < Block8x8F.Size; i++)
             {
-                sum = 0;
+                double value = pDividend[i] / pDivisor[i];
-                for (int i = 0; i < Block8x8F.Size; i++)
+                pDividend[i] = (float)System.Math.Round(value);
-                {
-                    double value = pDividend[i] / pDivisor[i];
-                    pDividend[i] = (float)System.Math.Round(value);
-                }
-
-                for (int i = 0; i < Block8x8F.Size; i++)
-                {
-                    sum += (int)pDividend[i];
-                }
             }
 
-            return sum;
+            for (int i = 0; i < Block8x8F.Size; i++)
+            {
+                sum += (int)pDividend[i];
+            }
         }
 
-        [Benchmark]
+        return sum;
-        public int BySimdMagic()
+    }
-        {
+
-            int sum = 0;
+    [Benchmark]
+    public int BySimdMagic()
+    {
+        int sum = 0;
 
-            Block8x8F bDividend = this.inputDividend;
+        Block8x8F bDividend = this.inputDividend;
-            Block8x8F bDivisor = this.inputDivisor;
+        Block8x8F bDivisor = this.inputDivisor;
-            float* pDividend = (float*)&bDividend;
+        float* pDividend = (float*)&bDividend;
 
-            for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        for (int cnt = 0; cnt < ExecutionCount; cnt++)
+        {
+            sum = 0;
+            DivideRoundAll(ref bDividend, ref bDivisor);
+            for (int i = 0; i < Block8x8F.Size; i++)
             {
-                sum = 0;
+                sum += (int)pDividend[i];
-                DivideRoundAll(ref bDividend, ref bDivisor);
-                for (int i = 0; i < Block8x8F.Size; i++)
-                {
-                    sum += (int)pDividend[i];
-                }
             }
-
-            return sum;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return sum;
-        private static void DivideRoundAll(ref Block8x8F a, ref Block8x8F b)
+    }
-        {
-            a.V0L = DivideRound(a.V0L, b.V0L);
-            a.V0R = DivideRound(a.V0R, b.V0R);
-            a.V1L = DivideRound(a.V1L, b.V1L);
-            a.V1R = DivideRound(a.V1R, b.V1R);
-            a.V2L = DivideRound(a.V2L, b.V2L);
-            a.V2R = DivideRound(a.V2R, b.V2R);
-            a.V3L = DivideRound(a.V3L, b.V3L);
-            a.V3R = DivideRound(a.V3R, b.V3R);
-            a.V4L = DivideRound(a.V4L, b.V4L);
-            a.V4R = DivideRound(a.V4R, b.V4R);
-            a.V5L = DivideRound(a.V5L, b.V5L);
-            a.V5R = DivideRound(a.V5R, b.V5R);
-            a.V6L = DivideRound(a.V6L, b.V6L);
-            a.V6R = DivideRound(a.V6R, b.V6R);
-            a.V7L = DivideRound(a.V7L, b.V7L);
-            a.V7R = DivideRound(a.V7R, b.V7R);
-        }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector4 DivideRound(Vector4 dividend, Vector4 divisor)
+    private static void DivideRoundAll(ref Block8x8F a, ref Block8x8F b)
-        {
+    {
-            var sign = Vector4.Min(dividend, Vector4.One);
+        a.V0L = DivideRound(a.V0L, b.V0L);
-            sign = Vector4.Max(sign, MinusOne);
+        a.V0R = DivideRound(a.V0R, b.V0R);
+        a.V1L = DivideRound(a.V1L, b.V1L);
+        a.V1R = DivideRound(a.V1R, b.V1R);
+        a.V2L = DivideRound(a.V2L, b.V2L);
+        a.V2R = DivideRound(a.V2R, b.V2R);
+        a.V3L = DivideRound(a.V3L, b.V3L);
+        a.V3R = DivideRound(a.V3R, b.V3R);
+        a.V4L = DivideRound(a.V4L, b.V4L);
+        a.V4R = DivideRound(a.V4R, b.V4R);
+        a.V5L = DivideRound(a.V5L, b.V5L);
+        a.V5R = DivideRound(a.V5R, b.V5R);
+        a.V6L = DivideRound(a.V6L, b.V6L);
+        a.V6R = DivideRound(a.V6R, b.V6R);
+        a.V7L = DivideRound(a.V7L, b.V7L);
+        a.V7R = DivideRound(a.V7R, b.V7R);
+    }
 
-            return (dividend / divisor) + (sign * Half);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        }
+    private static Vector4 DivideRound(Vector4 dividend, Vector4 divisor)
+    {
+        var sign = Vector4.Min(dividend, Vector4.One);
+        sign = Vector4.Max(sign, MinusOne);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return (dividend / divisor) + (sign * Half);
-        private static int RationalRound(int dividend, int divisor)
+    }
-        {
-            if (dividend >= 0)
-            {
-                return (dividend + (divisor >> 1)) / divisor;
-            }
 
-            return -((-dividend + (divisor >> 1)) / divisor);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int RationalRound(int dividend, int divisor)
+    {
+        if (dividend >= 0)
+        {
+            return (dividend + (divisor >> 1)) / divisor;
         }
+
+        return -((-dividend + (divisor >> 1)) / divisor);
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_LoadFromInt16.cs

@@ -1,51 +1,49 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+public class Block8x8F_LoadFromInt16
 {
-    public class Block8x8F_LoadFromInt16
+    private Block8x8 source;
-    {
-        private Block8x8 source;
 
-        private Block8x8F dest = default;
+    private Block8x8F dest = default;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        if (Vector<float>.Count != 8)
         {
-            if (Vector<float>.Count != 8)
+            throw new NotSupportedException("Vector<float>.Count != 8");
-            {
-                throw new NotSupportedException("Vector<float>.Count != 8");
-            }
-
-            for (short i = 0; i < Block8x8F.Size; i++)
-            {
-                this.source[i] = i;
-            }
         }
 
-        [Benchmark(Baseline = true)]
+        for (short i = 0; i < Block8x8F.Size; i++)
-        public void Scalar()
         {
-            this.dest.LoadFromInt16Scalar(ref this.source);
+            this.source[i] = i;
         }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void ExtendedAvx2()
+    public void Scalar()
-        {
+    {
-            this.dest.LoadFromInt16ExtendedAvx2(ref this.source);
+        this.dest.LoadFromInt16Scalar(ref this.source);
-        }
+    }
 
-        // RESULT:
+    [Benchmark]
-        //        Method |     Mean |     Error |    StdDev | Scaled |
+    public void ExtendedAvx2()
-        // ------------- |---------:|----------:|----------:|-------:|
+    {
-        //        Scalar | 34.88 ns | 0.3296 ns | 0.3083 ns |   1.00 |
+        this.dest.LoadFromInt16ExtendedAvx2(ref this.source);
-        //  ExtendedAvx2 | 21.58 ns | 0.2125 ns | 0.1884 ns |   0.62 |
     }
+
+    // RESULT:
+    //        Method |     Mean |     Error |    StdDev | Scaled |
+    // ------------- |---------:|----------:|----------:|-------:|
+    //        Scalar | 34.88 ns | 0.3296 ns | 0.3083 ns |   1.00 |
+    //  ExtendedAvx2 | 21.58 ns | 0.2125 ns | 0.1884 ns |   0.62 |
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceBlock.cs

@@ -4,34 +4,33 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Block8x8F_MultiplyInPlaceBlock
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private static readonly Block8x8F Source = Create8x8FloatData();
-    public class Block8x8F_MultiplyInPlaceBlock
-    {
-        private static readonly Block8x8F Source = Create8x8FloatData();
 
-        [Benchmark]
+    [Benchmark]
-        public void MultiplyInPlaceBlock()
+    public void MultiplyInPlaceBlock()
-        {
+    {
-            Block8x8F dest = default;
+        Block8x8F dest = default;
-            Source.MultiplyInPlace(ref dest);
+        Source.MultiplyInPlace(ref dest);
-        }
+    }
 
-        private static Block8x8F Create8x8FloatData()
+    private static Block8x8F Create8x8FloatData()
+    {
+        var result = new float[64];
+        for (int i = 0; i < 8; i++)
         {
-            var result = new float[64];
+            for (int j = 0; j < 8; j++)
-            for (int i = 0; i < 8; i++)
             {
-                for (int j = 0; j < 8; j++)
+                result[(i * 8) + j] = (i * 10) + j;
-                {
-                    result[(i * 8) + j] = (i * 10) + j;
-                }
             }
-
-            var source = default(Block8x8F);
-            source.LoadFrom(result);
-            return source;
         }
+
+        var source = default(Block8x8F);
+        source.LoadFrom(result);
+        return source;
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_MultiplyInPlaceScalar.cs

@@ -4,18 +4,17 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Block8x8F_MultiplyInPlaceScalar
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    [Benchmark]
-    public class Block8x8F_MultiplyInPlaceScalar
+    public float MultiplyInPlaceScalar()
     {
-        [Benchmark]
+        float f = 42F;
-        public float MultiplyInPlaceScalar()
+        Block8x8F b = default;
-        {
+        b.MultiplyInPlace(f);
-            float f = 42F;
+        return f;
-            Block8x8F b = default;
-            b.MultiplyInPlace(f);
-            return f;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Quantize.cs

@@ -4,32 +4,31 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Block8x8F_Quantize
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private Block8x8F block = CreateFromScalar(1);
-    public class Block8x8F_Quantize
+    private Block8x8F quant = CreateFromScalar(1);
+    private Block8x8 result = default;
+
+    [Benchmark]
+    public short Quantize()
     {
-        private Block8x8F block = CreateFromScalar(1);
+        Block8x8F.Quantize(ref this.block, ref this.result, ref this.quant);
-        private Block8x8F quant = CreateFromScalar(1);
+        return this.result[0];
-        private Block8x8 result = default;
+    }
 
-        [Benchmark]
+    private static Block8x8F CreateFromScalar(float scalar)
-        public short Quantize()
+    {
+        Block8x8F block = default;
+        for (int i = 0; i < 64; i++)
         {
-            Block8x8F.Quantize(ref this.block, ref this.result, ref this.quant);
+            block[i] = scalar;
-            return this.result[0];
         }
 
-        private static Block8x8F CreateFromScalar(float scalar)
+        return block;
-        {
-            Block8x8F block = default;
-            for (int i = 0; i < 64; i++)
-            {
-                block[i] = scalar;
-            }
-
-            return block;
-        }
     }
 }
 
@@ -37,14 +36,14 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.1165 (20H2/October2020Update)
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+[Host]             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  1. No HwIntrinsics : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+1. No HwIntrinsics : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  2. SSE             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+2. SSE             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  3. AVX             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+3. AVX             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
 
 |   Method |             Job |     Mean |    Error |   StdDev | Ratio |
 |--------- |-----------------|---------:|---------:|---------:|------:|
 | Quantize | No HwIntrinsics | 73.34 ns | 1.081 ns | 1.011 ns |  1.00 |
 | Quantize |             SSE | 24.11 ns | 0.298 ns | 0.279 ns |  0.33 |
 | Quantize |             AVX | 15.90 ns | 0.074 ns | 0.065 ns |  0.22 |
- */
+*/

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Round.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -12,481 +11,480 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+public unsafe class Block8x8F_Round
 {
-    public unsafe class Block8x8F_Round
+    private Block8x8F block;
-    {
-        private Block8x8F block;
 
-        private readonly byte[] blockBuffer = new byte[512];
+    private readonly byte[] blockBuffer = new byte[512];
-        private GCHandle blockHandle;
+    private GCHandle blockHandle;
-        private float* alignedPtr;
+    private float* alignedPtr;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        if (Vector<float>.Count != 8)
         {
-            if (Vector<float>.Count != 8)
+            throw new NotSupportedException("Vector<float>.Count != 8");
-            {
-                throw new NotSupportedException("Vector<float>.Count != 8");
-            }
-
-            this.blockHandle = GCHandle.Alloc(this.blockBuffer, GCHandleType.Pinned);
-            ulong ptr = (ulong)this.blockHandle.AddrOfPinnedObject();
-            ptr += 16;
-            ptr -= ptr % 16;
-
-            if (ptr % 16 != 0)
-            {
-                throw new Exception("ptr is unaligned");
-            }
-
-            this.alignedPtr = (float*)ptr;
         }
 
-        [GlobalCleanup]
+        this.blockHandle = GCHandle.Alloc(this.blockBuffer, GCHandleType.Pinned);
-        public void Cleanup()
+        ulong ptr = (ulong)this.blockHandle.AddrOfPinnedObject();
+        ptr += 16;
+        ptr -= ptr % 16;
+
+        if (ptr % 16 != 0)
         {
-            this.blockHandle.Free();
+            throw new Exception("ptr is unaligned");
-            this.alignedPtr = null;
         }
 
-        [Benchmark]
+        this.alignedPtr = (float*)ptr;
-        public void ScalarRound()
+    }
-        {
-            ref float b = ref Unsafe.As<Block8x8F, float>(ref this.block);
 
-            for (int i = 0; i < Block8x8F.Size; i++)
+    [GlobalCleanup]
-            {
+    public void Cleanup()
-                ref float v = ref Unsafe.Add(ref b, i);
+    {
-                v = (float)Math.Round(v);
+        this.blockHandle.Free();
-            }
+        this.alignedPtr = null;
-        }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark]
-        public void SimdUtils_FastRound_Vector8()
+    public void ScalarRound()
-        {
+    {
-            ref Block8x8F b = ref this.block;
+        ref float b = ref Unsafe.As<Block8x8F, float>(ref this.block);
-
-            ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
-            row0 = SimdUtils.FastRound(row0);
-            ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
-            row1 = SimdUtils.FastRound(row1);
-            ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
-            row2 = SimdUtils.FastRound(row2);
-            ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
-            row3 = SimdUtils.FastRound(row3);
-            ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
-            row4 = SimdUtils.FastRound(row4);
-            ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
-            row5 = SimdUtils.FastRound(row5);
-            ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
-            row6 = SimdUtils.FastRound(row6);
-            ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
-            row7 = SimdUtils.FastRound(row7);
-        }
 
-        [Benchmark]
+        for (int i = 0; i < Block8x8F.Size; i++)
-        public void SimdUtils_FastRound_Vector8_ForceAligned()
         {
-            ref Block8x8F b = ref Unsafe.AsRef<Block8x8F>(this.alignedPtr);
+            ref float v = ref Unsafe.Add(ref b, i);
-
+            v = (float)Math.Round(v);
-            ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
-            row0 = SimdUtils.FastRound(row0);
-            ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
-            row1 = SimdUtils.FastRound(row1);
-            ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
-            row2 = SimdUtils.FastRound(row2);
-            ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
-            row3 = SimdUtils.FastRound(row3);
-            ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
-            row4 = SimdUtils.FastRound(row4);
-            ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
-            row5 = SimdUtils.FastRound(row5);
-            ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
-            row6 = SimdUtils.FastRound(row6);
-            ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
-            row7 = SimdUtils.FastRound(row7);
         }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void SimdUtils_FastRound_Vector8_Grouped()
+    public void SimdUtils_FastRound_Vector8()
-        {
+    {
-            ref Block8x8F b = ref this.block;
+        ref Block8x8F b = ref this.block;
-
+
-            ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
+        ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
-            ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
+        row0 = SimdUtils.FastRound(row0);
-            ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
+        ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
-            ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
+        row1 = SimdUtils.FastRound(row1);
-
+        ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
-            row0 = SimdUtils.FastRound(row0);
+        row2 = SimdUtils.FastRound(row2);
-            row1 = SimdUtils.FastRound(row1);
+        ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
-            row2 = SimdUtils.FastRound(row2);
+        row3 = SimdUtils.FastRound(row3);
-            row3 = SimdUtils.FastRound(row3);
+        ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
-
+        row4 = SimdUtils.FastRound(row4);
-            row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
+        ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
-            row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
+        row5 = SimdUtils.FastRound(row5);
-            row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
+        ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
-            row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
+        row6 = SimdUtils.FastRound(row6);
-
+        ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
-            row0 = SimdUtils.FastRound(row0);
+        row7 = SimdUtils.FastRound(row7);
-            row1 = SimdUtils.FastRound(row1);
+    }
-            row2 = SimdUtils.FastRound(row2);
-            row3 = SimdUtils.FastRound(row3);
-        }
 
-        [Benchmark]
+    [Benchmark]
-        public void Sse41_V1()
+    public void SimdUtils_FastRound_Vector8_ForceAligned()
-        {
+    {
-            ref Vector128<float> b0 = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
+        ref Block8x8F b = ref Unsafe.AsRef<Block8x8F>(this.alignedPtr);
+
+        ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
+        row0 = SimdUtils.FastRound(row0);
+        ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
+        row1 = SimdUtils.FastRound(row1);
+        ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
+        row2 = SimdUtils.FastRound(row2);
+        ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
+        row3 = SimdUtils.FastRound(row3);
+        ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
+        row4 = SimdUtils.FastRound(row4);
+        ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
+        row5 = SimdUtils.FastRound(row5);
+        ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
+        row6 = SimdUtils.FastRound(row6);
+        ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
+        row7 = SimdUtils.FastRound(row7);
+    }
 
-            ref Vector128<float> p = ref b0;
+    [Benchmark]
-            p = Sse41.RoundToNearestInteger(p);
+    public void SimdUtils_FastRound_Vector8_Grouped()
+    {
+        ref Block8x8F b = ref this.block;
+
+        ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V0L);
+        ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V1L);
+        ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V2L);
+        ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V3L);
+
+        row0 = SimdUtils.FastRound(row0);
+        row1 = SimdUtils.FastRound(row1);
+        row2 = SimdUtils.FastRound(row2);
+        row3 = SimdUtils.FastRound(row3);
+
+        row0 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V4L);
+        row1 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V5L);
+        row2 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V6L);
+        row3 = ref Unsafe.As<Vector4, Vector<float>>(ref b.V7L);
+
+        row0 = SimdUtils.FastRound(row0);
+        row1 = SimdUtils.FastRound(row1);
+        row2 = SimdUtils.FastRound(row2);
+        row3 = SimdUtils.FastRound(row3);
+    }
 
-            p = ref Unsafe.Add(ref b0, 1);
+    [Benchmark]
-            p = Sse41.RoundToNearestInteger(p);
+    public void Sse41_V1()
-            p = ref Unsafe.Add(ref b0, 2);
+    {
-            p = Sse41.RoundToNearestInteger(p);
+        ref Vector128<float> b0 = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
-            p = ref Unsafe.Add(ref b0, 3);
+
-            p = Sse41.RoundToNearestInteger(p);
+        ref Vector128<float> p = ref b0;
-            p = ref Unsafe.Add(ref b0, 4);
+        p = Sse41.RoundToNearestInteger(p);
-            p = Sse41.RoundToNearestInteger(p);
+
-            p = ref Unsafe.Add(ref b0, 5);
+        p = ref Unsafe.Add(ref b0, 1);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 6);
+        p = ref Unsafe.Add(ref b0, 2);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 7);
+        p = ref Unsafe.Add(ref b0, 3);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 8);
+        p = ref Unsafe.Add(ref b0, 4);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 9);
+        p = ref Unsafe.Add(ref b0, 5);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 10);
+        p = ref Unsafe.Add(ref b0, 6);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 11);
+        p = ref Unsafe.Add(ref b0, 7);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 12);
+        p = ref Unsafe.Add(ref b0, 8);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 13);
+        p = ref Unsafe.Add(ref b0, 9);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 14);
+        p = ref Unsafe.Add(ref b0, 10);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.Add(ref b0, 15);
+        p = ref Unsafe.Add(ref b0, 11);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-        }
+        p = ref Unsafe.Add(ref b0, 12);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.Add(ref b0, 13);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.Add(ref b0, 14);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.Add(ref b0, 15);
+        p = Sse41.RoundToNearestInteger(p);
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public unsafe void Sse41_V2()
+    public unsafe void Sse41_V2()
-        {
+    {
-            ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
+        ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
-            var offset = (IntPtr)sizeof(Vector128<float>);
+        var offset = (IntPtr)sizeof(Vector128<float>);
-            p = Sse41.RoundToNearestInteger(p);
+        p = Sse41.RoundToNearestInteger(p);
+
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+        p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
+    }
 
-            p = ref Unsafe.AddByteOffset(ref p, offset);
+    [Benchmark]
-            p = Sse41.RoundToNearestInteger(p);
+    public unsafe void Sse41_V3()
-            p = ref Unsafe.AddByteOffset(ref p, offset);
+    {
-            p = Sse41.RoundToNearestInteger(p);
+        ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
+        p = Sse41.RoundToNearestInteger(p);
-            p = Sse41.RoundToNearestInteger(p);
+        var offset = (IntPtr)sizeof(Vector128<float>);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-            p = ref Unsafe.AddByteOffset(ref p, offset);
-            p = Sse41.RoundToNearestInteger(p);
-        }
 
-        [Benchmark]
+        for (int i = 0; i < 15; i++)
-        public unsafe void Sse41_V3()
         {
-            ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
+            p = ref Unsafe.AddByteOffset(ref p, offset);
             p = Sse41.RoundToNearestInteger(p);
-            var offset = (IntPtr)sizeof(Vector128<float>);
-
-            for (int i = 0; i < 15; i++)
-            {
-                p = ref Unsafe.AddByteOffset(ref p, offset);
-                p = Sse41.RoundToNearestInteger(p);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public unsafe void Sse41_V4()
+    public unsafe void Sse41_V4()
-        {
+    {
-            ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
+        ref Vector128<float> p = ref Unsafe.As<Block8x8F, Vector128<float>>(ref this.block);
-            var offset = (IntPtr)sizeof(Vector128<float>);
+        var offset = (IntPtr)sizeof(Vector128<float>);
-
+
-            ref Vector128<float> a = ref p;
+        ref Vector128<float> a = ref p;
-            ref Vector128<float> b = ref Unsafe.AddByteOffset(ref a, offset);
+        ref Vector128<float> b = ref Unsafe.AddByteOffset(ref a, offset);
-            ref Vector128<float> c = ref Unsafe.AddByteOffset(ref b, offset);
+        ref Vector128<float> c = ref Unsafe.AddByteOffset(ref b, offset);
-            ref Vector128<float> d = ref Unsafe.AddByteOffset(ref c, offset);
+        ref Vector128<float> d = ref Unsafe.AddByteOffset(ref c, offset);
-            a = Sse41.RoundToNearestInteger(a);
+        a = Sse41.RoundToNearestInteger(a);
-            b = Sse41.RoundToNearestInteger(b);
+        b = Sse41.RoundToNearestInteger(b);
-            c = Sse41.RoundToNearestInteger(c);
+        c = Sse41.RoundToNearestInteger(c);
-            d = Sse41.RoundToNearestInteger(d);
+        d = Sse41.RoundToNearestInteger(d);
-
+
-            a = ref Unsafe.AddByteOffset(ref d, offset);
+        a = ref Unsafe.AddByteOffset(ref d, offset);
-            b = ref Unsafe.AddByteOffset(ref a, offset);
+        b = ref Unsafe.AddByteOffset(ref a, offset);
-            c = ref Unsafe.AddByteOffset(ref b, offset);
+        c = ref Unsafe.AddByteOffset(ref b, offset);
-            d = ref Unsafe.AddByteOffset(ref c, offset);
+        d = ref Unsafe.AddByteOffset(ref c, offset);
-            a = Sse41.RoundToNearestInteger(a);
+        a = Sse41.RoundToNearestInteger(a);
-            b = Sse41.RoundToNearestInteger(b);
+        b = Sse41.RoundToNearestInteger(b);
-            c = Sse41.RoundToNearestInteger(c);
+        c = Sse41.RoundToNearestInteger(c);
-            d = Sse41.RoundToNearestInteger(d);
+        d = Sse41.RoundToNearestInteger(d);
-
+
-            a = ref Unsafe.AddByteOffset(ref d, offset);
+        a = ref Unsafe.AddByteOffset(ref d, offset);
-            b = ref Unsafe.AddByteOffset(ref a, offset);
+        b = ref Unsafe.AddByteOffset(ref a, offset);
-            c = ref Unsafe.AddByteOffset(ref b, offset);
+        c = ref Unsafe.AddByteOffset(ref b, offset);
-            d = ref Unsafe.AddByteOffset(ref c, offset);
+        d = ref Unsafe.AddByteOffset(ref c, offset);
-            a = Sse41.RoundToNearestInteger(a);
+        a = Sse41.RoundToNearestInteger(a);
-            b = Sse41.RoundToNearestInteger(b);
+        b = Sse41.RoundToNearestInteger(b);
-            c = Sse41.RoundToNearestInteger(c);
+        c = Sse41.RoundToNearestInteger(c);
-            d = Sse41.RoundToNearestInteger(d);
+        d = Sse41.RoundToNearestInteger(d);
-
+
-            a = ref Unsafe.AddByteOffset(ref d, offset);
+        a = ref Unsafe.AddByteOffset(ref d, offset);
-            b = ref Unsafe.AddByteOffset(ref a, offset);
+        b = ref Unsafe.AddByteOffset(ref a, offset);
-            c = ref Unsafe.AddByteOffset(ref b, offset);
+        c = ref Unsafe.AddByteOffset(ref b, offset);
-            d = ref Unsafe.AddByteOffset(ref c, offset);
+        d = ref Unsafe.AddByteOffset(ref c, offset);
-            a = Sse41.RoundToNearestInteger(a);
+        a = Sse41.RoundToNearestInteger(a);
-            b = Sse41.RoundToNearestInteger(b);
+        b = Sse41.RoundToNearestInteger(b);
-            c = Sse41.RoundToNearestInteger(c);
+        c = Sse41.RoundToNearestInteger(c);
-            d = Sse41.RoundToNearestInteger(d);
+        d = Sse41.RoundToNearestInteger(d);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public unsafe void Sse41_V5_Unaligned()
+    public unsafe void Sse41_V5_Unaligned()
-        {
+    {
-            float* p = this.alignedPtr + 1;
+        float* p = this.alignedPtr + 1;
-
+
-            Vector128<float> v = Sse.LoadVector128(p);
+        Vector128<float> v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadVector128(p);
+        v = Sse.LoadVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.Store(p, v);
+        Sse.Store(p, v);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public unsafe void Sse41_V5_Aligned()
+    public unsafe void Sse41_V5_Aligned()
-        {
+    {
-            float* p = this.alignedPtr;
+        float* p = this.alignedPtr;
-
+
-            Vector128<float> v = Sse.LoadAlignedVector128(p);
+        Vector128<float> v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-
+
-            v = Sse.LoadAlignedVector128(p);
+        v = Sse.LoadAlignedVector128(p);
-            v = Sse41.RoundToNearestInteger(v);
+        v = Sse41.RoundToNearestInteger(v);
-            Sse.StoreAligned(p, v);
+        Sse.StoreAligned(p, v);
-            p += 8;
+        p += 8;
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Sse41_V6_Aligned()
+    public void Sse41_V6_Aligned()
-        {
+    {
-            float* p = this.alignedPtr;
+        float* p = this.alignedPtr;
 
-            Round8SseVectors(p);
+        Round8SseVectors(p);
-            Round8SseVectors(p + 32);
+        Round8SseVectors(p + 32);
-        }
+    }
 
-        private static void Round8SseVectors(float* p0)
+    private static void Round8SseVectors(float* p0)
-        {
+    {
-            float* p1 = p0 + 4;
+        float* p1 = p0 + 4;
-            float* p2 = p1 + 4;
+        float* p2 = p1 + 4;
-            float* p3 = p2 + 4;
+        float* p3 = p2 + 4;
-            float* p4 = p3 + 4;
+        float* p4 = p3 + 4;
-            float* p5 = p4 + 4;
+        float* p5 = p4 + 4;
-            float* p6 = p5 + 4;
+        float* p6 = p5 + 4;
-            float* p7 = p6 + 4;
+        float* p7 = p6 + 4;
-
+
-            Vector128<float> v0 = Sse.LoadAlignedVector128(p0);
+        Vector128<float> v0 = Sse.LoadAlignedVector128(p0);
-            Vector128<float> v1 = Sse.LoadAlignedVector128(p1);
+        Vector128<float> v1 = Sse.LoadAlignedVector128(p1);
-            Vector128<float> v2 = Sse.LoadAlignedVector128(p2);
+        Vector128<float> v2 = Sse.LoadAlignedVector128(p2);
-            Vector128<float> v3 = Sse.LoadAlignedVector128(p3);
+        Vector128<float> v3 = Sse.LoadAlignedVector128(p3);
-            Vector128<float> v4 = Sse.LoadAlignedVector128(p4);
+        Vector128<float> v4 = Sse.LoadAlignedVector128(p4);
-            Vector128<float> v5 = Sse.LoadAlignedVector128(p5);
+        Vector128<float> v5 = Sse.LoadAlignedVector128(p5);
-            Vector128<float> v6 = Sse.LoadAlignedVector128(p6);
+        Vector128<float> v6 = Sse.LoadAlignedVector128(p6);
-            Vector128<float> v7 = Sse.LoadAlignedVector128(p7);
+        Vector128<float> v7 = Sse.LoadAlignedVector128(p7);
-
+
-            v0 = Sse41.RoundToNearestInteger(v0);
+        v0 = Sse41.RoundToNearestInteger(v0);
-            v1 = Sse41.RoundToNearestInteger(v1);
+        v1 = Sse41.RoundToNearestInteger(v1);
-            v2 = Sse41.RoundToNearestInteger(v2);
+        v2 = Sse41.RoundToNearestInteger(v2);
-            v3 = Sse41.RoundToNearestInteger(v3);
+        v3 = Sse41.RoundToNearestInteger(v3);
-            v4 = Sse41.RoundToNearestInteger(v4);
+        v4 = Sse41.RoundToNearestInteger(v4);
-            v5 = Sse41.RoundToNearestInteger(v5);
+        v5 = Sse41.RoundToNearestInteger(v5);
-            v6 = Sse41.RoundToNearestInteger(v6);
+        v6 = Sse41.RoundToNearestInteger(v6);
-            v7 = Sse41.RoundToNearestInteger(v7);
+        v7 = Sse41.RoundToNearestInteger(v7);
-
+
-            Sse.StoreAligned(p0, v0);
+        Sse.StoreAligned(p0, v0);
-            Sse.StoreAligned(p1, v1);
+        Sse.StoreAligned(p1, v1);
-            Sse.StoreAligned(p2, v2);
+        Sse.StoreAligned(p2, v2);
-            Sse.StoreAligned(p3, v3);
+        Sse.StoreAligned(p3, v3);
-            Sse.StoreAligned(p4, v4);
+        Sse.StoreAligned(p4, v4);
-            Sse.StoreAligned(p5, v5);
+        Sse.StoreAligned(p5, v5);
-            Sse.StoreAligned(p6, v6);
+        Sse.StoreAligned(p6, v6);
-            Sse.StoreAligned(p7, v7);
+        Sse.StoreAligned(p7, v7);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Transpose.cs

@@ -4,33 +4,32 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Block8x8F_Transpose
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private Block8x8F source = Create8x8FloatData();
-    public class Block8x8F_Transpose
-    {
-        private Block8x8F source = Create8x8FloatData();
 
-        [Benchmark]
+    [Benchmark]
-        public float TransposeInplace()
+    public float TransposeInplace()
-        {
+    {
-            this.source.TransposeInplace();
+        this.source.TransposeInplace();
-            return this.source[0];
+        return this.source[0];
-        }
+    }
 
-        private static Block8x8F Create8x8FloatData()
+    private static Block8x8F Create8x8FloatData()
+    {
+        Block8x8F block = default;
+        for (int i = 0; i < 8; i++)
         {
-            Block8x8F block = default;
+            for (int j = 0; j < 8; j++)
-            for (int i = 0; i < 8; i++)
             {
-                for (int j = 0; j < 8; j++)
+                block[(i * 8) + j] = (i * 10) + j;
-                {
-                    block[(i * 8) + j] = (i * 10) + j;
-                }
             }
-
-            return block;
         }
+
+        return block;
     }
 }
 
@@ -38,10 +37,10 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg.BlockOperations
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.1237 (20H2/October2020Update)
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+[Host]             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  1. No HwIntrinsics : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+1. No HwIntrinsics : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  2. SSE             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+2. SSE             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  3. AVX             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+3. AVX             : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
 
 Runtime=.NET Core 3.1
 

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/CmykColorConversion.cs

@@ -4,38 +4,37 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class CmykColorConversion : ColorConversionBenchmark
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    public CmykColorConversion()
-    public class CmykColorConversion : ColorConversionBenchmark
+        : base(4)
+    {
+    }
+
+    [Benchmark(Baseline = true)]
+    public void Scalar()
     {
-        public CmykColorConversion()
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-            : base(4)
+
-        {
+        new JpegColorConverterBase.CmykScalar(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark(Baseline = true)]
+    [Benchmark]
-        public void Scalar()
+    public void SimdVector8()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.CmykScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykVector(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark]
+    [Benchmark]
-        public void SimdVector8()
+    public void SimdVectorAvx()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.CmykVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.CmykAvx(8).ConvertToRgbInplace(values);
-        }
-
-        [Benchmark]
-        public void SimdVectorAvx()
-        {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
-            new JpegColorConverterBase.CmykAvx(8).ConvertToRgbInplace(values);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/ColorConversionBenchmark.cs

@@ -1,61 +1,58 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
-using System.Numerics;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Memory;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+public abstract class ColorConversionBenchmark
 {
-    public abstract class ColorConversionBenchmark
+    private readonly int componentCount;
-    {
-        private readonly int componentCount;
 
-        public const int Count = 128;
+    public const int Count = 128;
 
-        protected ColorConversionBenchmark(int componentCount)
+    protected ColorConversionBenchmark(int componentCount)
-            => this.componentCount = componentCount;
+        => this.componentCount = componentCount;
 
-        protected Buffer2D<float>[] Input { get; private set; }
+    protected Buffer2D<float>[] Input { get; private set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.Input = CreateRandomValues(this.componentCount, Count);
+        this.Input = CreateRandomValues(this.componentCount, Count);
-        }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
+    {
+        foreach (Buffer2D<float> buffer in this.Input)
         {
-            foreach (Buffer2D<float> buffer in this.Input)
+            buffer.Dispose();
-            {
-                buffer.Dispose();
-            }
         }
+    }
 
-        private static Buffer2D<float>[] CreateRandomValues(
+    private static Buffer2D<float>[] CreateRandomValues(
-            int componentCount,
+        int componentCount,
-            int inputBufferLength,
+        int inputBufferLength,
-            float minVal = 0f,
+        float minVal = 0f,
-            float maxVal = 255f)
+        float maxVal = 255f)
+    {
+        var rnd = new Random(42);
+        var buffers = new Buffer2D<float>[componentCount];
+        for (int i = 0; i < componentCount; i++)
         {
-            var rnd = new Random(42);
+            var values = new float[inputBufferLength];
-            var buffers = new Buffer2D<float>[componentCount];
-            for (int i = 0; i < componentCount; i++)
-            {
-                var values = new float[inputBufferLength];
 
-                for (int j = 0; j < inputBufferLength; j++)
+            for (int j = 0; j < inputBufferLength; j++)
-                {
+            {
-                    values[j] = ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
+                values[j] = ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
-                }
-
-                // no need to dispose when buffer is not array owner
-                buffers[i] = Configuration.Default.MemoryAllocator.Allocate2D<float>(values.Length, 1);
             }
 
-            return buffers;
+            // no need to dispose when buffer is not array owner
+            buffers[i] = Configuration.Default.MemoryAllocator.Allocate2D<float>(values.Length, 1);
         }
+
+        return buffers;
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/GrayscaleColorConversion.cs

@@ -4,30 +4,29 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class GrayscaleColorConversion : ColorConversionBenchmark
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    public GrayscaleColorConversion()
-    public class GrayscaleColorConversion : ColorConversionBenchmark
+        : base(1)
     {
-        public GrayscaleColorConversion()
+    }
-            : base(1)
-        {
-        }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Scalar()
+    public void Scalar()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
 
-            new JpegColorConverterBase.GrayscaleScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.GrayscaleScalar(8).ConvertToRgbInplace(values);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void SimdVectorAvx()
+    public void SimdVectorAvx()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
 
-            new JpegColorConverterBase.GrayscaleAvx(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.GrayscaleAvx(8).ConvertToRgbInplace(values);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/RgbColorConversion.cs

@@ -4,38 +4,37 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class RgbColorConversion : ColorConversionBenchmark
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    public RgbColorConversion()
-    public class RgbColorConversion : ColorConversionBenchmark
+        : base(3)
+    {
+    }
+
+    [Benchmark(Baseline = true)]
+    public void Scalar()
     {
-        public RgbColorConversion()
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-            : base(3)
+
-        {
+        new JpegColorConverterBase.RgbScalar(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark(Baseline = true)]
+    [Benchmark]
-        public void Scalar()
+    public void SimdVector8()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.RgbScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbVector(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark]
+    [Benchmark]
-        public void SimdVector8()
+    public void SimdVectorAvx()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.RgbVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.RgbAvx(8).ConvertToRgbInplace(values);
-        }
-
-        [Benchmark]
-        public void SimdVectorAvx()
-        {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
-            new JpegColorConverterBase.RgbAvx(8).ConvertToRgbInplace(values);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YCbCrColorConversion.cs

@@ -4,38 +4,37 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class YCbCrColorConversion : ColorConversionBenchmark
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    public YCbCrColorConversion()
-    public class YCbCrColorConversion : ColorConversionBenchmark
+        : base(3)
+    {
+    }
+
+    [Benchmark]
+    public void Scalar()
     {
-        public YCbCrColorConversion()
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-            : base(3)
+
-        {
+        new JpegColorConverterBase.YCbCrScalar(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark]
+    [Benchmark]
-        public void Scalar()
+    public void SimdVector8()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.YCbCrScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrVector(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark]
+    [Benchmark]
-        public void SimdVector8()
+    public void SimdVectorAvx()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.YCbCrVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YCbCrAvx(8).ConvertToRgbInplace(values);
-        }
-
-        [Benchmark]
-        public void SimdVectorAvx()
-        {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
-            new JpegColorConverterBase.YCbCrAvx(8).ConvertToRgbInplace(values);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs

@@ -4,38 +4,37 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class YccKColorConverter : ColorConversionBenchmark
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    public YccKColorConverter()
-    public class YccKColorConverter : ColorConversionBenchmark
+        : base(4)
+    {
+    }
+
+    [Benchmark(Baseline = true)]
+    public void Scalar()
     {
-        public YccKColorConverter()
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-            : base(4)
+
-        {
+        new JpegColorConverterBase.YccKScalar(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark(Baseline = true)]
+    [Benchmark]
-        public void Scalar()
+    public void SimdVector8()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.YccKScalar(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKVector(8).ConvertToRgbInplace(values);
-        }
+    }
-
+
-        [Benchmark]
+    [Benchmark]
-        public void SimdVector8()
+    public void SimdVectorAvx2()
-        {
+    {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+        var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
+
-            new JpegColorConverterBase.YccKVector(8).ConvertToRgbInplace(values);
+        new JpegColorConverterBase.YccKAvx(8).ConvertToRgbInplace(values);
-        }
-
-        [Benchmark]
-        public void SimdVectorAvx2()
-        {
-            var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
-
-            new JpegColorConverterBase.YccKAvx(8).ConvertToRgbInplace(values);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg.cs

@@ -1,76 +1,74 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+public class DecodeJpeg
 {
-    public class DecodeJpeg
+    private JpegDecoder decoder;
-    {
-        private JpegDecoder decoder;
 
-        private MemoryStream preloadedImageStream;
+    private MemoryStream preloadedImageStream;
 
-        private void GenericSetup(string imageSubpath)
+    private void GenericSetup(string imageSubpath)
-        {
+    {
-            this.decoder = new JpegDecoder();
+        this.decoder = new JpegDecoder();
-            byte[] bytes = File.ReadAllBytes(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, imageSubpath));
+        byte[] bytes = File.ReadAllBytes(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, imageSubpath));
-            this.preloadedImageStream = new MemoryStream(bytes);
+        this.preloadedImageStream = new MemoryStream(bytes);
-        }
+    }
 
-        private void GenericBechmark()
+    private void GenericBechmark()
-        {
+    {
-            this.preloadedImageStream.Position = 0;
+        this.preloadedImageStream.Position = 0;
-            using Image img = this.decoder.Decode(DecoderOptions.Default, this.preloadedImageStream);
+        using Image img = this.decoder.Decode(DecoderOptions.Default, this.preloadedImageStream);
-        }
+    }
 
-        [GlobalSetup(Target = nameof(JpegBaselineInterleaved444))]
+    [GlobalSetup(Target = nameof(JpegBaselineInterleaved444))]
-        public void SetupBaselineInterleaved444() =>
+    public void SetupBaselineInterleaved444() =>
-            this.GenericSetup(TestImages.Jpeg.Baseline.Winter444_Interleaved);
+        this.GenericSetup(TestImages.Jpeg.Baseline.Winter444_Interleaved);
 
-        [GlobalSetup(Target = nameof(JpegBaselineInterleaved420))]
+    [GlobalSetup(Target = nameof(JpegBaselineInterleaved420))]
-        public void SetupBaselineInterleaved420() =>
+    public void SetupBaselineInterleaved420() =>
-            this.GenericSetup(TestImages.Jpeg.Baseline.Hiyamugi);
+        this.GenericSetup(TestImages.Jpeg.Baseline.Hiyamugi);
 
-        [GlobalSetup(Target = nameof(JpegBaseline400))]
+    [GlobalSetup(Target = nameof(JpegBaseline400))]
-        public void SetupBaselineSingleComponent() =>
+    public void SetupBaselineSingleComponent() =>
-            this.GenericSetup(TestImages.Jpeg.Baseline.Jpeg400);
+        this.GenericSetup(TestImages.Jpeg.Baseline.Jpeg400);
 
-        [GlobalSetup(Target = nameof(JpegProgressiveNonInterleaved420))]
+    [GlobalSetup(Target = nameof(JpegProgressiveNonInterleaved420))]
-        public void SetupProgressiveNoninterleaved420() =>
+    public void SetupProgressiveNoninterleaved420() =>
-            this.GenericSetup(TestImages.Jpeg.Progressive.Winter420_NonInterleaved);
+        this.GenericSetup(TestImages.Jpeg.Progressive.Winter420_NonInterleaved);
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.preloadedImageStream.Dispose();
+        this.preloadedImageStream.Dispose();
-            this.preloadedImageStream = null;
+        this.preloadedImageStream = null;
-        }
+    }
 
-        [Benchmark(Description = "Baseline 4:4:4 Interleaved")]
+    [Benchmark(Description = "Baseline 4:4:4 Interleaved")]
-        public void JpegBaselineInterleaved444() => this.GenericBechmark();
+    public void JpegBaselineInterleaved444() => this.GenericBechmark();
 
-        [Benchmark(Description = "Baseline 4:2:0 Interleaved")]
+    [Benchmark(Description = "Baseline 4:2:0 Interleaved")]
-        public void JpegBaselineInterleaved420() => this.GenericBechmark();
+    public void JpegBaselineInterleaved420() => this.GenericBechmark();
 
-        [Benchmark(Description = "Baseline 4:0:0 (grayscale)")]
+    [Benchmark(Description = "Baseline 4:0:0 (grayscale)")]
-        public void JpegBaseline400() => this.GenericBechmark();
+    public void JpegBaseline400() => this.GenericBechmark();
 
-        [Benchmark(Description = "Progressive 4:2:0 Non-Interleaved")]
+    [Benchmark(Description = "Progressive 4:2:0 Non-Interleaved")]
-        public void JpegProgressiveNonInterleaved420() => this.GenericBechmark();
+    public void JpegProgressiveNonInterleaved420() => this.GenericBechmark();
-    }
 }
 
 /*
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.1348 (20H2/October2020Update)
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]     : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+[Host]     : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
-  DefaultJob : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
+DefaultJob : .NET Core 3.1.18 (CoreCLR 4.700.21.35901, CoreFX 4.700.21.36305), X64 RyuJIT
 
 
 |                              Method |      Mean |     Error |    StdDev |
@@ -86,8 +84,8 @@ FRESH BENCHMARKS FOR NEW SPECTRAL CONVERSION SETUP
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19044
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]     : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
+[Host]     : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
-  DefaultJob : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
+DefaultJob : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
 
 
 |                              Method |      Mean |     Error |    StdDev |

tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
@@ -9,60 +8,59 @@ using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Tests;
 using SDSize = System.Drawing.Size;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeJpegParseStreamOnly
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    [Params(TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr)]
-    public class DecodeJpegParseStreamOnly
+    public string TestImage { get; set; }
-    {
-        [Params(TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr)]
-        public string TestImage { get; set; }
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        private byte[] jpegBytes;
+    private byte[] jpegBytes;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-            => this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
+        => this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
+
+    [Benchmark(Baseline = true, Description = "System.Drawing FULL")]
+    public SDSize JpegSystemDrawing()
+    {
+        using var memoryStream = new MemoryStream(this.jpegBytes);
+        using var image = System.Drawing.Image.FromStream(memoryStream);
+        return image.Size;
+    }
+
+    [Benchmark(Description = "JpegDecoderCore.ParseStream")]
+    public void ParseStream()
+    {
+        using var memoryStream = new MemoryStream(this.jpegBytes);
+        using var bufferedStream = new BufferedReadStream(Configuration.Default, memoryStream);
+        var options = new JpegDecoderOptions();
+        options.GeneralOptions.SkipMetadata = true;
 
-        [Benchmark(Baseline = true, Description = "System.Drawing FULL")]
+        using var decoder = new JpegDecoderCore(options);
-        public SDSize JpegSystemDrawing()
+        var spectralConverter = new NoopSpectralConverter();
+        decoder.ParseStream(bufferedStream, spectralConverter, cancellationToken: default);
+    }
+
+    // We want to test only stream parsing and scan decoding, we don't need to convert spectral data to actual pixels
+    // Nor we need to allocate final pixel buffer
+    // Note: this still introduces virtual method call overhead for baseline interleaved images
+    // There's no way to eliminate it as spectral conversion is built into the scan decoding loop for memory footprint reduction
+    private class NoopSpectralConverter : SpectralConverter
+    {
+        public override void ConvertStrideBaseline()
         {
-            using var memoryStream = new MemoryStream(this.jpegBytes);
-            using var image = System.Drawing.Image.FromStream(memoryStream);
-            return image.Size;
         }
 
-        [Benchmark(Description = "JpegDecoderCore.ParseStream")]
+        public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
-        public void ParseStream()
         {
-            using var memoryStream = new MemoryStream(this.jpegBytes);
-            using var bufferedStream = new BufferedReadStream(Configuration.Default, memoryStream);
-            var options = new JpegDecoderOptions();
-            options.GeneralOptions.SkipMetadata = true;
-
-            using var decoder = new JpegDecoderCore(options);
-            var spectralConverter = new NoopSpectralConverter();
-            decoder.ParseStream(bufferedStream, spectralConverter, cancellationToken: default);
         }
 
-        // We want to test only stream parsing and scan decoding, we don't need to convert spectral data to actual pixels
+        public override void PrepareForDecoding()
-        // Nor we need to allocate final pixel buffer
-        // Note: this still introduces virtual method call overhead for baseline interleaved images
-        // There's no way to eliminate it as spectral conversion is built into the scan decoding loop for memory footprint reduction
-        private class NoopSpectralConverter : SpectralConverter
         {
-            public override void ConvertStrideBaseline()
-            {
-            }
-
-            public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
-            {
-            }
-
-            public override void PrepareForDecoding()
-            {
-            }
         }
     }
 }
@@ -71,10 +69,10 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.1083 (20H2/October2020Update)
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]     : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
+[Host]     : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
-  Job-VAJCIU : .NET Core 2.1.26 (CoreCLR 4.6.29812.02, CoreFX 4.6.29812.01), X64 RyuJIT
+Job-VAJCIU : .NET Core 2.1.26 (CoreCLR 4.6.29812.02, CoreFX 4.6.29812.01), X64 RyuJIT
-  Job-INPXCR : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
+Job-INPXCR : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
-  Job-JRCLOJ : .NET Framework 4.8 (4.8.4390.0), X64 RyuJIT
+Job-JRCLOJ : .NET Framework 4.8 (4.8.4390.0), X64 RyuJIT
 
 IterationCount=3  LaunchCount=1  WarmupCount=3
 |                      Method |        Job |              Runtime |             TestImage |     Mean |     Error |    StdDev | Ratio |   Gen 0 | Gen 1 | Gen 2 | Allocated |

tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_Aggregate.cs

@@ -1,41 +1,39 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// An expensive Jpeg benchmark, running on a wide range of input images,
+/// showing aggregate results.
+/// </summary>
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeJpeg_Aggregate : MultiImageBenchmarkBase
 {
-    /// <summary>
+    protected override IEnumerable<string> InputImageSubfoldersOrFiles
-    /// An expensive Jpeg benchmark, running on a wide range of input images,
+        => new[]
-    /// showing aggregate results.
+        {
-    /// </summary>
+            TestImages.Jpeg.BenchmarkSuite.Jpeg400_SmallMonochrome,
-    [Config(typeof(Config.ShortMultiFramework))]
+            TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr,
-    public class DecodeJpeg_Aggregate : MultiImageBenchmarkBase
+            TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr,
-    {
+            TestImages.Jpeg.BenchmarkSuite.MissingFF00ProgressiveBedroom159_MidSize420YCbCr,
-        protected override IEnumerable<string> InputImageSubfoldersOrFiles
+            TestImages.Jpeg.BenchmarkSuite.ExifGetString750Transform_Huge420YCbCr,
-            => new[]
+        };
-            {
-                TestImages.Jpeg.BenchmarkSuite.Jpeg400_SmallMonochrome,
-                TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr,
-                TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr,
-                TestImages.Jpeg.BenchmarkSuite.MissingFF00ProgressiveBedroom159_MidSize420YCbCr,
-                TestImages.Jpeg.BenchmarkSuite.ExifGetString750Transform_Huge420YCbCr,
-            };
 
-        [Params(InputImageCategory.AllImages)]
+    [Params(InputImageCategory.AllImages)]
-        public override InputImageCategory InputCategory { get; set; }
+    public override InputImageCategory InputCategory { get; set; }
 
-        [Benchmark]
+    [Benchmark]
-        public void ImageSharp()
+    public void ImageSharp()
-            => this.ForEachStream(ms => Image.Load<Rgba32>(ms));
+        => this.ForEachStream(ms => Image.Load<Rgba32>(ms));
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void SystemDrawing()
+    public void SystemDrawing()
-            => this.ForEachStream(SDImage.FromStream);
+        => this.ForEachStream(SDImage.FromStream);
-    }
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpeg_ImageSpecific.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Tests;
@@ -9,67 +8,66 @@ using SDImage = System.Drawing.Image;
 using SDSize = System.Drawing.Size;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// Image-specific Jpeg benchmarks
+/// </summary>
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeJpeg_ImageSpecific
 {
-    /// <summary>
+    private byte[] jpegBytes;
-    /// Image-specific Jpeg benchmarks
-    /// </summary>
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class DecodeJpeg_ImageSpecific
-    {
-        private byte[] jpegBytes;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
 #pragma warning disable SA1115
-        [Params(
+    [Params(
-            TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr,
+        TestImages.Jpeg.BenchmarkSuite.Lake_Small444YCbCr,
-            TestImages.Jpeg.BenchmarkSuite.BadRstProgressive518_Large444YCbCr,
+        TestImages.Jpeg.BenchmarkSuite.BadRstProgressive518_Large444YCbCr,
 
-            // The scaled result for the large image "ExifGetString750Transform_Huge420YCbCr"
+        // The scaled result for the large image "ExifGetString750Transform_Huge420YCbCr"
-            // is almost the same as the result for Jpeg420Exif,
+        // is almost the same as the result for Jpeg420Exif,
-            // which proves that the execution time for the most common YCbCr 420 path scales linearly.
+        // which proves that the execution time for the most common YCbCr 420 path scales linearly.
-            // TestImages.Jpeg.BenchmarkSuite.ExifGetString750Transform_Huge420YCbCr,
+        // TestImages.Jpeg.BenchmarkSuite.ExifGetString750Transform_Huge420YCbCr,
-            TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr)]
+        TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr)]
 
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
-        {
+    {
-            if (this.jpegBytes == null)
+        if (this.jpegBytes == null)
-            {
-                this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
-            }
-        }
-
-        [Benchmark(Baseline = true)]
-        public SDSize SystemDrawing()
         {
-            using var memoryStream = new MemoryStream(this.jpegBytes);
+            this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
-            using var image = SDImage.FromStream(memoryStream);
-            return image.Size;
         }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public Size ImageSharp()
+    public SDSize SystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.jpegBytes);
+        using var memoryStream = new MemoryStream(this.jpegBytes);
-            using var image = Image.Load(new DecoderOptions() { SkipMetadata = true }, memoryStream);
+        using var image = SDImage.FromStream(memoryStream);
-            return new Size(image.Width, image.Height);
+        return image.Size;
-        }
+    }
 
-        /*
+    [Benchmark]
-        |                         Method |            TestImage |       Mean |       Error |     StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 |  Allocated |
+    public Size ImageSharp()
-        |------------------------------- |--------------------- |-----------:|------------:|-----------:|------:|--------:|------:|------:|------:|-----------:|
+    {
-        | 'Decode Jpeg - System.Drawing' | Jpg/b(...)e.jpg [21] |   5.122 ms |   1.3978 ms |  0.0766 ms |  1.00 |    0.00 |     - |     - |     - |      176 B |
+        using var memoryStream = new MemoryStream(this.jpegBytes);
-        |     'Decode Jpeg - ImageSharp' | Jpg/b(...)e.jpg [21] |  11.991 ms |   0.2514 ms |  0.0138 ms |  2.34 |    0.03 |     - |     - |     - |    15816 B |
+        using var image = Image.Load(new DecoderOptions() { SkipMetadata = true }, memoryStream);
-        |                                |                      |            |             |            |       |         |       |       |       |            |
+        return new Size(image.Width, image.Height);
-        | 'Decode Jpeg - System.Drawing' | Jpg/b(...)f.jpg [28] |  14.943 ms |   1.8410 ms |  0.1009 ms |  1.00 |    0.00 |     - |     - |     - |      176 B |
-        |     'Decode Jpeg - ImageSharp' | Jpg/b(...)f.jpg [28] |  29.759 ms |   1.5452 ms |  0.0847 ms |  1.99 |    0.01 |     - |     - |     - |    16824 B |
-        |                                |                      |            |             |            |       |         |       |       |       |            |
-        | 'Decode Jpeg - System.Drawing' | Jpg/i(...)e.jpg [43] | 388.229 ms | 382.8946 ms | 20.9877 ms |  1.00 |    0.00 |     - |     - |     - |      216 B |
-        |     'Decode Jpeg - ImageSharp' | Jpg/i(...)e.jpg [43] | 276.490 ms | 195.5104 ms | 10.7166 ms |  0.71 |    0.01 |     - |     - |     - | 36022368 B |
-         */
     }
+
+    /*
+    |                         Method |            TestImage |       Mean |       Error |     StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 |  Allocated |
+    |------------------------------- |--------------------- |-----------:|------------:|-----------:|------:|--------:|------:|------:|------:|-----------:|
+    | 'Decode Jpeg - System.Drawing' | Jpg/b(...)e.jpg [21] |   5.122 ms |   1.3978 ms |  0.0766 ms |  1.00 |    0.00 |     - |     - |     - |      176 B |
+    |     'Decode Jpeg - ImageSharp' | Jpg/b(...)e.jpg [21] |  11.991 ms |   0.2514 ms |  0.0138 ms |  2.34 |    0.03 |     - |     - |     - |    15816 B |
+    |                                |                      |            |             |            |       |         |       |       |       |            |
+    | 'Decode Jpeg - System.Drawing' | Jpg/b(...)f.jpg [28] |  14.943 ms |   1.8410 ms |  0.1009 ms |  1.00 |    0.00 |     - |     - |     - |      176 B |
+    |     'Decode Jpeg - ImageSharp' | Jpg/b(...)f.jpg [28] |  29.759 ms |   1.5452 ms |  0.0847 ms |  1.99 |    0.01 |     - |     - |     - |    16824 B |
+    |                                |                      |            |             |            |       |         |       |       |       |            |
+    | 'Decode Jpeg - System.Drawing' | Jpg/i(...)e.jpg [43] | 388.229 ms | 382.8946 ms | 20.9877 ms |  1.00 |    0.00 |     - |     - |     - |      216 B |
+    |     'Decode Jpeg - ImageSharp' | Jpg/i(...)e.jpg [43] | 276.490 ms | 195.5104 ms | 10.7166 ms |  0.71 |    0.01 |     - |     - |     - | 36022368 B |
+     */
 }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpegComparison.cs

@@ -1,95 +1,91 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Drawing.Imaging;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SkiaSharp;
-using SDImage = System.Drawing.Image;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// Benchmark for performance comparison between other codecs.
+/// </summary>
+/// <remarks>
+/// This benchmarks tests baseline 4:2:0 chroma sampling path.
+/// </remarks>
+public class EncodeJpegComparison
 {
-    /// <summary>
+    // Big enough, 4:4:4 chroma sampling
-    /// Benchmark for performance comparison between other codecs.
+    private const string TestImage = TestImages.Jpeg.Baseline.Calliphora;
-    /// </summary>
+
-    /// <remarks>
+    // Change/add parameters for extra benchmarks
-    /// This benchmarks tests baseline 4:2:0 chroma sampling path.
+    [Params(75, 90, 100)]
-    /// </remarks>
+    public int Quality;
-    public class EncodeJpegComparison
+
+    private MemoryStream destinationStream;
+
+    // ImageSharp
+    private Image<Rgba32> imageImageSharp;
+    private JpegEncoder encoderImageSharp;
+
+    // SkiaSharp
+    private SKBitmap imageSkiaSharp;
+
+    [GlobalSetup(Target = nameof(BenchmarkImageSharp))]
+    public void SetupImageSharp()
+    {
+        using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
+
+        this.imageImageSharp = Image.Load<Rgba32>(imageBinaryStream);
+        this.encoderImageSharp = new JpegEncoder { Quality = this.Quality, ColorType = JpegEncodingColor.YCbCrRatio420 };
+
+        this.destinationStream = new MemoryStream();
+    }
+
+    [GlobalCleanup(Target = nameof(BenchmarkImageSharp))]
+    public void CleanupImageSharp()
+    {
+        this.imageImageSharp.Dispose();
+        this.imageImageSharp = null;
+
+        this.destinationStream.Dispose();
+        this.destinationStream = null;
+    }
+
+    [Benchmark(Description = "ImageSharp")]
+    public void BenchmarkImageSharp()
+    {
+        this.imageImageSharp.SaveAsJpeg(this.destinationStream, this.encoderImageSharp);
+        this.destinationStream.Seek(0, SeekOrigin.Begin);
+    }
+
+    [GlobalSetup(Target = nameof(BenchmarkSkiaSharp))]
+    public void SetupSkiaSharp()
+    {
+        using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
+
+        this.imageSkiaSharp = SKBitmap.Decode(imageBinaryStream);
+
+        this.destinationStream = new MemoryStream();
+    }
+
+    [GlobalCleanup(Target = nameof(BenchmarkSkiaSharp))]
+    public void CleanupSkiaSharp()
+    {
+        this.imageSkiaSharp.Dispose();
+        this.imageSkiaSharp = null;
+
+        this.destinationStream.Dispose();
+        this.destinationStream = null;
+    }
+
+    [Benchmark(Description = "SkiaSharp")]
+    public void BenchmarkSkiaSharp()
     {
-        // Big enough, 4:4:4 chroma sampling
+        this.imageSkiaSharp.Encode(SKEncodedImageFormat.Jpeg, this.Quality).SaveTo(this.destinationStream);
-        private const string TestImage = TestImages.Jpeg.Baseline.Calliphora;
+        this.destinationStream.Seek(0, SeekOrigin.Begin);
-
-        // Change/add parameters for extra benchmarks
-        [Params(75, 90, 100)]
-        public int Quality;
-
-        private MemoryStream destinationStream;
-
-        // ImageSharp
-        private Image<Rgba32> imageImageSharp;
-        private JpegEncoder encoderImageSharp;
-
-        // SkiaSharp
-        private SKBitmap imageSkiaSharp;
-
-        [GlobalSetup(Target = nameof(BenchmarkImageSharp))]
-        public void SetupImageSharp()
-        {
-            using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
-
-            this.imageImageSharp = Image.Load<Rgba32>(imageBinaryStream);
-            this.encoderImageSharp = new JpegEncoder { Quality = this.Quality, ColorType = JpegEncodingColor.YCbCrRatio420 };
-
-            this.destinationStream = new MemoryStream();
-        }
-
-        [GlobalCleanup(Target = nameof(BenchmarkImageSharp))]
-        public void CleanupImageSharp()
-        {
-            this.imageImageSharp.Dispose();
-            this.imageImageSharp = null;
-
-            this.destinationStream.Dispose();
-            this.destinationStream = null;
-        }
-
-        [Benchmark(Description = "ImageSharp")]
-        public void BenchmarkImageSharp()
-        {
-            this.imageImageSharp.SaveAsJpeg(this.destinationStream, this.encoderImageSharp);
-            this.destinationStream.Seek(0, SeekOrigin.Begin);
-        }
-
-        [GlobalSetup(Target = nameof(BenchmarkSkiaSharp))]
-        public void SetupSkiaSharp()
-        {
-            using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
-
-            this.imageSkiaSharp = SKBitmap.Decode(imageBinaryStream);
-
-            this.destinationStream = new MemoryStream();
-        }
-
-        [GlobalCleanup(Target = nameof(BenchmarkSkiaSharp))]
-        public void CleanupSkiaSharp()
-        {
-            this.imageSkiaSharp.Dispose();
-            this.imageSkiaSharp = null;
-
-            this.destinationStream.Dispose();
-            this.destinationStream = null;
-        }
-
-        [Benchmark(Description = "SkiaSharp")]
-        public void BenchmarkSkiaSharp()
-        {
-            this.imageSkiaSharp.Encode(SKEncodedImageFormat.Jpeg, this.Quality).SaveTo(this.destinationStream);
-            this.destinationStream.Seek(0, SeekOrigin.Begin);
-        }
     }
 }
 
@@ -97,8 +93,8 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19044
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.100-preview.3.21202.5
-  [Host]     : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
+[Host]     : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
-  DefaultJob : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
+DefaultJob : .NET Core 3.1.21 (CoreCLR 4.700.21.51404, CoreFX 4.700.21.51508), X64 RyuJIT
 
 
 |     Method | Quality |      Mean |     Error |    StdDev |

tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpegFeatures.cs

@@ -1,76 +1,73 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Collections.Generic;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+/// <summary>
+/// Benchmark for all available encoding features of the Jpeg file type.
+/// </summary>
+/// <remarks>
+/// This benchmark does NOT compare ImageSharp to any other jpeg codecs.
+/// </remarks>
+public class EncodeJpegFeatures
 {
-    /// <summary>
+    // Big enough, 4:4:4 chroma sampling
-    /// Benchmark for all available encoding features of the Jpeg file type.
+    // No metadata
-    /// </summary>
+    private const string TestImage = TestImages.Jpeg.Baseline.Calliphora;
-    /// <remarks>
-    /// This benchmark does NOT compare ImageSharp to any other jpeg codecs.
-    /// </remarks>
-    public class EncodeJpegFeatures
-    {
-        // Big enough, 4:4:4 chroma sampling
-        // No metadata
-        private const string TestImage = TestImages.Jpeg.Baseline.Calliphora;
 
-        public static IEnumerable<JpegEncodingColor> ColorSpaceValues => new[]
+    public static IEnumerable<JpegEncodingColor> ColorSpaceValues => new[]
-        {
+    {
-            JpegEncodingColor.Luminance,
+        JpegEncodingColor.Luminance,
-            JpegEncodingColor.Rgb,
+        JpegEncodingColor.Rgb,
-            JpegEncodingColor.YCbCrRatio420,
+        JpegEncodingColor.YCbCrRatio420,
-            JpegEncodingColor.YCbCrRatio444,
+        JpegEncodingColor.YCbCrRatio444,
-        };
+    };
 
-        [Params(75, 90, 100)]
+    [Params(75, 90, 100)]
-        public int Quality;
+    public int Quality;
 
-        [ParamsSource(nameof(ColorSpaceValues), Priority = -100)]
+    [ParamsSource(nameof(ColorSpaceValues), Priority = -100)]
-        public JpegEncodingColor TargetColorSpace;
+    public JpegEncodingColor TargetColorSpace;
 
-        private Image<Rgb24> bmpCore;
+    private Image<Rgb24> bmpCore;
-        private JpegEncoder encoder;
+    private JpegEncoder encoder;
 
-        private MemoryStream destinationStream;
+    private MemoryStream destinationStream;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
+        this.bmpCore = Image.Load<Rgb24>(imageBinaryStream);
+        this.encoder = new JpegEncoder
         {
-            using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
+            Quality = this.Quality,
-            this.bmpCore = Image.Load<Rgb24>(imageBinaryStream);
+            ColorType = this.TargetColorSpace,
-            this.encoder = new JpegEncoder
+            Interleaved = true,
-            {
+        };
-                Quality = this.Quality,
+        this.destinationStream = new MemoryStream();
-                ColorType = this.TargetColorSpace,
+    }
-                Interleaved = true,
-            };
-            this.destinationStream = new MemoryStream();
-        }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bmpCore.Dispose();
+        this.bmpCore.Dispose();
-            this.bmpCore = null;
+        this.bmpCore = null;
 
-            this.destinationStream.Dispose();
+        this.destinationStream.Dispose();
-            this.destinationStream = null;
+        this.destinationStream = null;
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Benchmark()
+    public void Benchmark()
-        {
+    {
-            this.bmpCore.SaveAsJpeg(this.destinationStream, this.encoder);
+        this.bmpCore.SaveAsJpeg(this.destinationStream, this.encoder);
-            this.destinationStream.Seek(0, SeekOrigin.Begin);
+        this.destinationStream.Seek(0, SeekOrigin.Begin);
-        }
     }
 }
 
@@ -78,8 +75,8 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
 BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19044
 Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
 .NET SDK=6.0.202
-  [Host]     : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
+[Host]     : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
-  DefaultJob : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
+DefaultJob : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
 
 
 |    Method | TargetColorSpace | Quality |      Mean |     Error |    StdDev |

tests/ImageSharp.Benchmarks/Codecs/Jpeg/IdentifyJpeg.cs

@@ -1,39 +1,37 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class IdentifyJpeg
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] jpegBytes;
-    public class IdentifyJpeg
-    {
-        private byte[] jpegBytes;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(TestImages.Jpeg.Baseline.Jpeg420Exif, TestImages.Jpeg.Baseline.Calliphora)]
+    [Params(TestImages.Jpeg.Baseline.Jpeg420Exif, TestImages.Jpeg.Baseline.Calliphora)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.jpegBytes == null)
         {
-            if (this.jpegBytes == null)
+            this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
-            {
-                this.jpegBytes = File.ReadAllBytes(this.TestImageFullPath);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public IImageInfo Identify()
+    public IImageInfo Identify()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.jpegBytes);
+        using var memoryStream = new MemoryStream(this.jpegBytes);
-            IImageDecoder decoder = new JpegDecoder();
+        IImageDecoder decoder = new JpegDecoder();
-            return decoder.Identify(DecoderOptions.Default, memoryStream, default);
+        return decoder.Identify(DecoderOptions.Default, memoryStream, default);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/MultiImageBenchmarkBase.cs

@@ -1,139 +1,185 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
-using System.Collections.Generic;
 using System.Drawing;
-using System.IO;
-using System.Linq;
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+public abstract class MultiImageBenchmarkBase
 {
-    public abstract class MultiImageBenchmarkBase
+    protected Dictionary<string, byte[]> FileNamesToBytes { get; set; } = new Dictionary<string, byte[]>();
-    {
-        protected Dictionary<string, byte[]> FileNamesToBytes { get; set; } = new Dictionary<string, byte[]>();
 
-        protected Dictionary<string, Image<Rgba32>> FileNamesToImageSharpImages { get; set; } = new Dictionary<string, Image<Rgba32>>();
+    protected Dictionary<string, Image<Rgba32>> FileNamesToImageSharpImages { get; set; } = new Dictionary<string, Image<Rgba32>>();
 
-        protected Dictionary<string, Bitmap> FileNamesToSystemDrawingImages { get; set; } = new Dictionary<string, Bitmap>();
+    protected Dictionary<string, Bitmap> FileNamesToSystemDrawingImages { get; set; } = new Dictionary<string, Bitmap>();
 
+    /// <summary>
+    /// The values of this enum separate input files into categories.
+    /// </summary>
+    public enum InputImageCategory
+    {
         /// <summary>
-        /// The values of this enum separate input files into categories.
+        /// Use all images.
         /// </summary>
-        public enum InputImageCategory
+        AllImages,
-        {
-            /// <summary>
-            /// Use all images.
-            /// </summary>
-            AllImages,
-
-            /// <summary>
-            /// Use small images only.
-            /// </summary>
-            SmallImagesOnly,
-
-            /// <summary>
-            /// Use large images only.
-            /// </summary>
-            LargeImagesOnly
-        }
-
-        [Params(InputImageCategory.AllImages, InputImageCategory.SmallImagesOnly, InputImageCategory.LargeImagesOnly)]
-        public virtual InputImageCategory InputCategory { get; set; }
-
-        protected virtual string BaseFolder => TestEnvironment.InputImagesDirectoryFullPath;
-
-        protected virtual IEnumerable<string> SearchPatterns => new[] { "*.*" };
 
         /// <summary>
-        /// Gets the file names containing these strings are substrings are not processed by the benchmark.
+        /// Use small images only.
         /// </summary>
-        protected virtual IEnumerable<string> ExcludeSubstringsInFileNames => new[] { "badeof", "BadEof", "CriticalEOF" };
+        SmallImagesOnly,
 
         /// <summary>
-        /// Gets folders containing files OR files to be processed by the benchmark.
+        /// Use large images only.
         /// </summary>
-        protected IEnumerable<string> AllFoldersOrFiles
+        LargeImagesOnly
-            => this.InputImageSubfoldersOrFiles.Select(f => Path.Combine(this.BaseFolder, f));
+    }
 
-        /// <summary>
+    [Params(InputImageCategory.AllImages, InputImageCategory.SmallImagesOnly, InputImageCategory.LargeImagesOnly)]
-        /// Gets the large image threshold.
+    public virtual InputImageCategory InputCategory { get; set; }
-        /// The images sized above this threshold will be included in.
-        /// </summary>
-        protected virtual int LargeImageThresholdInBytes => 100000;
 
-        protected IEnumerable<KeyValuePair<string, T>> EnumeratePairsByBenchmarkSettings<T>(
+    protected virtual string BaseFolder => TestEnvironment.InputImagesDirectoryFullPath;
-            Dictionary<string, T> input,
-            Predicate<T> checkIfSmall)
-            => this.InputCategory switch
-            {
-                InputImageCategory.AllImages => input,
-                InputImageCategory.SmallImagesOnly => input.Where(kv => checkIfSmall(kv.Value)),
-                InputImageCategory.LargeImagesOnly => input.Where(kv => !checkIfSmall(kv.Value)),
-                _ => throw new ArgumentOutOfRangeException(),
-            };
 
-        protected IEnumerable<KeyValuePair<string, byte[]>> FileNames2Bytes
+    protected virtual IEnumerable<string> SearchPatterns => new[] { "*.*" };
-            =>
+
-            this.EnumeratePairsByBenchmarkSettings(
+    /// <summary>
-                this.FileNamesToBytes,
+    /// Gets the file names containing these strings are substrings are not processed by the benchmark.
-                arr => arr.Length < this.LargeImageThresholdInBytes);
+    /// </summary>
+    protected virtual IEnumerable<string> ExcludeSubstringsInFileNames => new[] { "badeof", "BadEof", "CriticalEOF" };
+
+    /// <summary>
+    /// Gets folders containing files OR files to be processed by the benchmark.
+    /// </summary>
+    protected IEnumerable<string> AllFoldersOrFiles
+        => this.InputImageSubfoldersOrFiles.Select(f => Path.Combine(this.BaseFolder, f));
+
+    /// <summary>
+    /// Gets the large image threshold.
+    /// The images sized above this threshold will be included in.
+    /// </summary>
+    protected virtual int LargeImageThresholdInBytes => 100000;
+
+    protected IEnumerable<KeyValuePair<string, T>> EnumeratePairsByBenchmarkSettings<T>(
+        Dictionary<string, T> input,
+        Predicate<T> checkIfSmall)
+        => this.InputCategory switch
+        {
+            InputImageCategory.AllImages => input,
+            InputImageCategory.SmallImagesOnly => input.Where(kv => checkIfSmall(kv.Value)),
+            InputImageCategory.LargeImagesOnly => input.Where(kv => !checkIfSmall(kv.Value)),
+            _ => throw new ArgumentOutOfRangeException(),
+        };
+
+    protected IEnumerable<KeyValuePair<string, byte[]>> FileNames2Bytes
+        =>
+        this.EnumeratePairsByBenchmarkSettings(
+            this.FileNamesToBytes,
+            arr => arr.Length < this.LargeImageThresholdInBytes);
+
+    protected abstract IEnumerable<string> InputImageSubfoldersOrFiles { get; }
+
+    [GlobalSetup]
+    public virtual void Setup()
+    {
+        if (!Vector.IsHardwareAccelerated)
+        {
+            throw new Exception("Vector.IsHardwareAccelerated == false! Check your build settings!");
+        }
 
-        protected abstract IEnumerable<string> InputImageSubfoldersOrFiles { get; }
+        // Console.WriteLine("Vector.IsHardwareAccelerated: " + Vector.IsHardwareAccelerated);
+        this.ReadFilesImpl();
+    }
 
-        [GlobalSetup]
+    protected virtual void ReadFilesImpl()
-        public virtual void Setup()
+    {
+        foreach (string path in this.AllFoldersOrFiles)
         {
-            if (!Vector.IsHardwareAccelerated)
+            if (File.Exists(path))
             {
-                throw new Exception("Vector.IsHardwareAccelerated == false! Check your build settings!");
+                this.FileNamesToBytes[path] = File.ReadAllBytes(path);
+                continue;
             }
 
-            // Console.WriteLine("Vector.IsHardwareAccelerated: " + Vector.IsHardwareAccelerated);
+            string[] excludeStrings = this.ExcludeSubstringsInFileNames.Select(s => s.ToLower()).ToArray();
-            this.ReadFilesImpl();
+
+            string[] allFiles =
+                this.SearchPatterns.SelectMany(
+                    f =>
+                        Directory.EnumerateFiles(path, f, SearchOption.AllDirectories)
+                            .Where(fn => !excludeStrings.Any(excludeStr => fn.ToLower().Contains(excludeStr)))).ToArray();
+
+            foreach (string fn in allFiles)
+            {
+                this.FileNamesToBytes[fn] = File.ReadAllBytes(fn);
+            }
         }
+    }
 
-        protected virtual void ReadFilesImpl()
+    /// <summary>
+    /// Execute code for each image stream. If the returned object of the operation <see cref="Func{T, TResult}"/> is <see cref="IDisposable"/> it will be disposed.
+    /// </summary>
+    /// <param name="operation">The operation to execute. If the returned object is &lt;see cref="IDisposable"/&gt; it will be disposed </param>
+    protected void ForEachStream(Func<MemoryStream, object> operation)
+    {
+        foreach (KeyValuePair<string, byte[]> kv in this.FileNames2Bytes)
         {
-            foreach (string path in this.AllFoldersOrFiles)
+            using var memoryStream = new MemoryStream(kv.Value);
+            try
             {
-                if (File.Exists(path))
+                object obj = operation(memoryStream);
-                {
+                (obj as IDisposable)?.Dispose();
-                    this.FileNamesToBytes[path] = File.ReadAllBytes(path);
+            }
-                    continue;
+            catch (Exception ex)
-                }
+            {
+                Console.WriteLine($"Operation on {kv.Key} failed with {ex.Message}");
+            }
+        }
+    }
 
-                string[] excludeStrings = this.ExcludeSubstringsInFileNames.Select(s => s.ToLower()).ToArray();
+    public abstract class WithImagesPreloaded : MultiImageBenchmarkBase
+    {
+        protected override void ReadFilesImpl()
+        {
+            base.ReadFilesImpl();
 
-                string[] allFiles =
+            foreach (KeyValuePair<string, byte[]> kv in this.FileNamesToBytes)
-                    this.SearchPatterns.SelectMany(
+            {
-                        f =>
+                byte[] bytes = kv.Value;
-                            Directory.EnumerateFiles(path, f, SearchOption.AllDirectories)
+                string fn = kv.Key;
-                                .Where(fn => !excludeStrings.Any(excludeStr => fn.ToLower().Contains(excludeStr)))).ToArray();
 
-                foreach (string fn in allFiles)
+                using (var ms1 = new MemoryStream(bytes))
                 {
-                    this.FileNamesToBytes[fn] = File.ReadAllBytes(fn);
+                    this.FileNamesToImageSharpImages[fn] = Image.Load<Rgba32>(ms1);
                 }
+
+                this.FileNamesToSystemDrawingImages[fn] = new Bitmap(new MemoryStream(bytes));
             }
         }
 
-        /// <summary>
+        protected IEnumerable<KeyValuePair<string, Image<Rgba32>>> FileNames2ImageSharpImages
-        /// Execute code for each image stream. If the returned object of the operation <see cref="Func{T, TResult}"/> is <see cref="IDisposable"/> it will be disposed.
+            =>
-        /// </summary>
+            this.EnumeratePairsByBenchmarkSettings(
-        /// <param name="operation">The operation to execute. If the returned object is &lt;see cref="IDisposable"/&gt; it will be disposed </param>
+                this.FileNamesToImageSharpImages,
-        protected void ForEachStream(Func<MemoryStream, object> operation)
+                img => img.Width * img.Height < this.LargeImageThresholdInPixels);
+
+        protected IEnumerable<KeyValuePair<string, Bitmap>> FileNames2SystemDrawingImages
+            =>
+            this.EnumeratePairsByBenchmarkSettings(
+                this.FileNamesToSystemDrawingImages,
+                img => img.Width * img.Height < this.LargeImageThresholdInPixels);
+
+        protected virtual int LargeImageThresholdInPixels => 700000;
+
+        protected void ForEachImageSharpImage(Func<Image<Rgba32>, object> operation)
         {
-            foreach (KeyValuePair<string, byte[]> kv in this.FileNames2Bytes)
+            foreach (KeyValuePair<string, Image<Rgba32>> kv in this.FileNames2ImageSharpImages)
             {
-                using var memoryStream = new MemoryStream(kv.Value);
                 try
                 {
-                    object obj = operation(memoryStream);
+                    object obj = operation(kv.Value);
                     (obj as IDisposable)?.Dispose();
                 }
                 catch (Exception ex)
@@ -143,101 +189,50 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs
             }
         }
 
-        public abstract class WithImagesPreloaded : MultiImageBenchmarkBase
+        protected void ForEachImageSharpImage(Func<Image<Rgba32>, MemoryStream, object> operation)
         {
-            protected override void ReadFilesImpl()
+            using var workStream = new MemoryStream();
-            {
+            this.ForEachImageSharpImage(
-                base.ReadFilesImpl();
+                img =>
-
-                foreach (KeyValuePair<string, byte[]> kv in this.FileNamesToBytes)
                 {
-                    byte[] bytes = kv.Value;
+                    // ReSharper disable AccessToDisposedClosure
-                    string fn = kv.Key;
+                    object result = operation(img, workStream);
-
+                    workStream.Seek(0, SeekOrigin.Begin);
-                    using (var ms1 = new MemoryStream(bytes))
-                    {
-                        this.FileNamesToImageSharpImages[fn] = Image.Load<Rgba32>(ms1);
-                    }
-
-                    this.FileNamesToSystemDrawingImages[fn] = new Bitmap(new MemoryStream(bytes));
-                }
-            }
-
-            protected IEnumerable<KeyValuePair<string, Image<Rgba32>>> FileNames2ImageSharpImages
-                =>
-                this.EnumeratePairsByBenchmarkSettings(
-                    this.FileNamesToImageSharpImages,
-                    img => img.Width * img.Height < this.LargeImageThresholdInPixels);
 
-            protected IEnumerable<KeyValuePair<string, Bitmap>> FileNames2SystemDrawingImages
+                    // ReSharper restore AccessToDisposedClosure
-                =>
+                    return result;
-                this.EnumeratePairsByBenchmarkSettings(
+                });
-                    this.FileNamesToSystemDrawingImages,
+        }
-                    img => img.Width * img.Height < this.LargeImageThresholdInPixels);
-
-            protected virtual int LargeImageThresholdInPixels => 700000;
 
-            protected void ForEachImageSharpImage(Func<Image<Rgba32>, object> operation)
+        protected void ForEachSystemDrawingImage(Func<Bitmap, object> operation)
+        {
+            foreach (KeyValuePair<string, Bitmap> kv in this.FileNames2SystemDrawingImages)
             {
-                foreach (KeyValuePair<string, Image<Rgba32>> kv in this.FileNames2ImageSharpImages)
+                try
                 {
-                    try
+                    object obj = operation(kv.Value);
-                    {
+                    (obj as IDisposable)?.Dispose();
-                        object obj = operation(kv.Value);
-                        (obj as IDisposable)?.Dispose();
-                    }
-                    catch (Exception ex)
-                    {
-                        Console.WriteLine($"Operation on {kv.Key} failed with {ex.Message}");
-                    }
                 }
-            }
+                catch (Exception ex)
-
-            protected void ForEachImageSharpImage(Func<Image<Rgba32>, MemoryStream, object> operation)
-            {
-                using var workStream = new MemoryStream();
-                this.ForEachImageSharpImage(
-                    img =>
-                    {
-                        // ReSharper disable AccessToDisposedClosure
-                        object result = operation(img, workStream);
-                        workStream.Seek(0, SeekOrigin.Begin);
-
-                        // ReSharper restore AccessToDisposedClosure
-                        return result;
-                    });
-            }
-
-            protected void ForEachSystemDrawingImage(Func<Bitmap, object> operation)
-            {
-                foreach (KeyValuePair<string, Bitmap> kv in this.FileNames2SystemDrawingImages)
                 {
-                    try
+                    Console.WriteLine($"Operation on {kv.Key} failed with {ex.Message}");
-                    {
-                        object obj = operation(kv.Value);
-                        (obj as IDisposable)?.Dispose();
-                    }
-                    catch (Exception ex)
-                    {
-                        Console.WriteLine($"Operation on {kv.Key} failed with {ex.Message}");
-                    }
                 }
             }
+        }
 
-            protected void ForEachSystemDrawingImage(Func<Bitmap, MemoryStream, object> operation)
+        protected void ForEachSystemDrawingImage(Func<Bitmap, MemoryStream, object> operation)
-            {
+        {
-                using var workStream = new MemoryStream();
+            using var workStream = new MemoryStream();
-                this.ForEachSystemDrawingImage(
+            this.ForEachSystemDrawingImage(
-                    img =>
+                img =>
-                    {
+                {
-                        // ReSharper disable AccessToDisposedClosure
+                    // ReSharper disable AccessToDisposedClosure
-                        object result = operation(img, workStream);
+                    object result = operation(img, workStream);
-                        workStream.Seek(0, SeekOrigin.Begin);
+                    workStream.Seek(0, SeekOrigin.Begin);
-
+
-                        // ReSharper restore AccessToDisposedClosure
+                    // ReSharper restore AccessToDisposedClosure
-                        return result;
+                    return result;
-                    });
+                });
-            }
         }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Png/DecodeFilteredPng.cs

@@ -1,67 +1,65 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
-{
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class DecodeFilteredPng
-    {
-        private byte[] filter0;
-        private byte[] filter1;
-        private byte[] filter2;
-        private byte[] filter3;
-        private byte[] averageFilter3bpp;
-        private byte[] averageFilter4bpp;
 
-        [GlobalSetup]
+[Config(typeof(Config.ShortMultiFramework))]
-        public void ReadImages()
+public class DecodeFilteredPng
-        {
+{
-            this.filter0 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.Filter0));
+    private byte[] filter0;
-            this.filter1 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.SubFilter3BytesPerPixel));
+    private byte[] filter1;
-            this.filter2 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.UpFilter));
+    private byte[] filter2;
-            this.filter3 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.PaethFilter3BytesPerPixel));
+    private byte[] filter3;
-            this.averageFilter3bpp = File.ReadAllBytes(TestImageFullPath(TestImages.Png.AverageFilter3BytesPerPixel));
+    private byte[] averageFilter3bpp;
-            this.averageFilter4bpp = File.ReadAllBytes(TestImageFullPath(TestImages.Png.AverageFilter4BytesPerPixel));
+    private byte[] averageFilter4bpp;
-        }
 
-        [Benchmark(Baseline = true, Description = "None-filtered PNG file")]
+    [GlobalSetup]
-        public Size PngFilter0()
+    public void ReadImages()
-            => LoadPng(this.filter0);
+    {
+        this.filter0 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.Filter0));
+        this.filter1 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.SubFilter3BytesPerPixel));
+        this.filter2 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.UpFilter));
+        this.filter3 = File.ReadAllBytes(TestImageFullPath(TestImages.Png.PaethFilter3BytesPerPixel));
+        this.averageFilter3bpp = File.ReadAllBytes(TestImageFullPath(TestImages.Png.AverageFilter3BytesPerPixel));
+        this.averageFilter4bpp = File.ReadAllBytes(TestImageFullPath(TestImages.Png.AverageFilter4BytesPerPixel));
+    }
 
-        [Benchmark(Description = "Sub-filtered PNG file")]
+    [Benchmark(Baseline = true, Description = "None-filtered PNG file")]
-        public Size PngFilter1()
+    public Size PngFilter0()
-            => LoadPng(this.filter1);
+        => LoadPng(this.filter0);
 
-        [Benchmark(Description = "Up-filtered PNG file")]
+    [Benchmark(Description = "Sub-filtered PNG file")]
-        public Size PngFilter2()
+    public Size PngFilter1()
-            => LoadPng(this.filter2);
+        => LoadPng(this.filter1);
 
-        [Benchmark(Description = "Average-filtered PNG file (3bpp)")]
+    [Benchmark(Description = "Up-filtered PNG file")]
-        public Size PngAvgFilter1()
+    public Size PngFilter2()
-            => LoadPng(this.averageFilter3bpp);
+        => LoadPng(this.filter2);
 
-        [Benchmark(Description = "Average-filtered PNG file (4bpp)")]
+    [Benchmark(Description = "Average-filtered PNG file (3bpp)")]
-        public Size PngAvgFilter2()
+    public Size PngAvgFilter1()
-            => LoadPng(this.averageFilter4bpp);
+        => LoadPng(this.averageFilter3bpp);
 
-        [Benchmark(Description = "Paeth-filtered PNG file")]
+    [Benchmark(Description = "Average-filtered PNG file (4bpp)")]
-        public Size PngFilter4()
+    public Size PngAvgFilter2()
-            => LoadPng(this.filter3);
+        => LoadPng(this.averageFilter4bpp);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [Benchmark(Description = "Paeth-filtered PNG file")]
-        private static Size LoadPng(byte[] bytes)
+    public Size PngFilter4()
-        {
+        => LoadPng(this.filter3);
-            using var image = Image.Load<Rgba32>(bytes);
-            return image.Size();
-        }
 
-        private static string TestImageFullPath(string path)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, path);
+    private static Size LoadPng(byte[] bytes)
+    {
+        using var image = Image.Load<Rgba32>(bytes);
+        return image.Size();
     }
+
+    private static string TestImageFullPath(string path)
+        => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, path);
 }

tests/ImageSharp.Benchmarks/Codecs/Png/DecodePng.cs

@@ -1,49 +1,47 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 using SDSize = System.Drawing.Size;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodePng
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] pngBytes;
-    public class DecodePng
-    {
-        private byte[] pngBytes;
 
-        private string TestImageFullPath
+    private string TestImageFullPath
-            => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+        => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(TestImages.Png.Splash)]
+    [Params(TestImages.Png.Splash)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.pngBytes == null)
         {
-            if (this.pngBytes == null)
+            this.pngBytes = File.ReadAllBytes(this.TestImageFullPath);
-            {
-                this.pngBytes = File.ReadAllBytes(this.TestImageFullPath);
-            }
         }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Png")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Png")]
-        public SDSize PngSystemDrawing()
+    public SDSize PngSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.pngBytes);
+        using var memoryStream = new MemoryStream(this.pngBytes);
-            using var image = SDImage.FromStream(memoryStream);
+        using var image = SDImage.FromStream(memoryStream);
-            return image.Size;
+        return image.Size;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Png")]
+    [Benchmark(Description = "ImageSharp Png")]
-        public Size PngImageSharp()
+    public Size PngImageSharp()
-        {
+    {
-            using var memoryStream = new MemoryStream(this.pngBytes);
+        using var memoryStream = new MemoryStream(this.pngBytes);
-            using var image = Image.Load<Rgba32>(memoryStream);
+        using var image = Image.Load<Rgba32>(memoryStream);
-            return image.Size();
+        return image.Size();
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Png/EncodeIndexedPng.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
@@ -9,84 +8,83 @@ using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+/// <summary>
+/// Benchmarks saving png files using different quantizers.
+/// System.Drawing cannot save indexed png files so we cannot compare.
+/// </summary>
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeIndexedPng
 {
-    /// <summary>
+    // System.Drawing needs this.
-    /// Benchmarks saving png files using different quantizers.
+    private Stream bmpStream;
-    /// System.Drawing cannot save indexed png files so we cannot compare.
+    private Image<Rgba32> bmpCore;
-    /// </summary>
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class EncodeIndexedPng
-    {
-        // System.Drawing needs this.
-        private Stream bmpStream;
-        private Image<Rgba32> bmpCore;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.bmpStream == null)
         {
-            if (this.bmpStream == null)
+            this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Bmp.Car));
-            {
+            this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
-                this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Bmp.Car));
+            this.bmpStream.Position = 0;
-                this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
-                this.bmpStream.Position = 0;
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bmpStream.Dispose();
+        this.bmpStream.Dispose();
-            this.bmpStream = null;
+        this.bmpStream = null;
-            this.bmpCore.Dispose();
+        this.bmpCore.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "ImageSharp Octree Png")]
+    [Benchmark(Baseline = true, Description = "ImageSharp Octree Png")]
-        public void PngCoreOctree()
+    public void PngCoreOctree()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = KnownQuantizers.Octree };
+        var options = new PngEncoder { Quantizer = KnownQuantizers.Octree };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Octree NoDither Png")]
+    [Benchmark(Description = "ImageSharp Octree NoDither Png")]
-        public void PngCoreOctreeNoDither()
+    public void PngCoreOctreeNoDither()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = new OctreeQuantizer(new QuantizerOptions { Dither = null }) };
+        var options = new PngEncoder { Quantizer = new OctreeQuantizer(new QuantizerOptions { Dither = null }) };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Palette Png")]
+    [Benchmark(Description = "ImageSharp Palette Png")]
-        public void PngCorePalette()
+    public void PngCorePalette()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = KnownQuantizers.WebSafe };
+        var options = new PngEncoder { Quantizer = KnownQuantizers.WebSafe };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Palette NoDither Png")]
+    [Benchmark(Description = "ImageSharp Palette NoDither Png")]
-        public void PngCorePaletteNoDither()
+    public void PngCorePaletteNoDither()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = null }) };
+        var options = new PngEncoder { Quantizer = new WebSafePaletteQuantizer(new QuantizerOptions { Dither = null }) };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Wu Png")]
+    [Benchmark(Description = "ImageSharp Wu Png")]
-        public void PngCoreWu()
+    public void PngCoreWu()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = KnownQuantizers.Wu };
+        var options = new PngEncoder { Quantizer = KnownQuantizers.Wu };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Wu NoDither Png")]
+    [Benchmark(Description = "ImageSharp Wu NoDither Png")]
-        public void PngCoreWuNoDither()
+    public void PngCoreWuNoDither()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var options = new PngEncoder { Quantizer = new WuQuantizer(new QuantizerOptions { Dither = null }), ColorType = PngColorType.Palette };
+        var options = new PngEncoder { Quantizer = new WuQuantizer(new QuantizerOptions { Dither = null }), ColorType = PngColorType.Palette };
-            this.bmpCore.SaveAsPng(memoryStream, options);
+        this.bmpCore.SaveAsPng(memoryStream, options);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Png/EncodePng.cs

@@ -2,61 +2,59 @@
 // Licensed under the Six Labors Split License.
 
 using System.Drawing.Imaging;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodePng
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    // System.Drawing needs this.
-    public class EncodePng
+    private Stream bmpStream;
-    {
+    private SDImage bmpDrawing;
-        // System.Drawing needs this.
+    private Image<Rgba32> bmpCore;
-        private Stream bmpStream;
-        private SDImage bmpDrawing;
-        private Image<Rgba32> bmpCore;
 
-        [Params(false)]
+    [Params(false)]
-        public bool LargeImage { get; set; }
+    public bool LargeImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.bmpStream == null)
         {
-            if (this.bmpStream == null)
+            string path = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.LargeImage ? TestImages.Jpeg.Baseline.Jpeg420Exif : TestImages.Bmp.Car);
-            {
+            this.bmpStream = File.OpenRead(path);
-                string path = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.LargeImage ? TestImages.Jpeg.Baseline.Jpeg420Exif : TestImages.Bmp.Car);
+            this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
-                this.bmpStream = File.OpenRead(path);
+            this.bmpStream.Position = 0;
-                this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
+            this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-                this.bmpStream.Position = 0;
-                this.bmpDrawing = SDImage.FromStream(this.bmpStream);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.bmpStream.Dispose();
+        this.bmpStream.Dispose();
-            this.bmpStream = null;
+        this.bmpStream = null;
-            this.bmpCore.Dispose();
+        this.bmpCore.Dispose();
-            this.bmpDrawing.Dispose();
+        this.bmpDrawing.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Png")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Png")]
-        public void PngSystemDrawing()
+    public void PngSystemDrawing()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.bmpDrawing.Save(memoryStream, ImageFormat.Png);
+        this.bmpDrawing.Save(memoryStream, ImageFormat.Png);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Png")]
+    [Benchmark(Description = "ImageSharp Png")]
-        public void PngCore()
+    public void PngCore()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            var encoder = new PngEncoder { FilterMethod = PngFilterMethod.None };
+        var encoder = new PngEncoder { FilterMethod = PngFilterMethod.None };
-            this.bmpCore.SaveAsPng(memoryStream, encoder);
+        this.bmpCore.SaveAsPng(memoryStream, encoder);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Tga/DecodeTga.cs

@@ -2,80 +2,77 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
-using System.IO;
-using System.Threading;
 using BenchmarkDotNet.Attributes;
 using ImageMagick;
 using Pfim;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
-{
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class DecodeTga
-    {
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        private readonly PfimConfig pfimConfig = new(allocator: new PfimAllocator());
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeTga
+{
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        private byte[] data;
+    private readonly PfimConfig pfimConfig = new(allocator: new PfimAllocator());
 
-        [Params(TestImages.Tga.Bit24BottomLeft)]
+    private byte[] data;
-        public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [Params(TestImages.Tga.Bit24BottomLeft)]
-        public void SetupData()
+    public string TestImage { get; set; }
-            => this.data = File.ReadAllBytes(this.TestImageFullPath);
 
-        [Benchmark(Baseline = true, Description = "ImageMagick Tga")]
+    [GlobalSetup]
-        public int TgaImageMagick()
+    public void SetupData()
-        {
+        => this.data = File.ReadAllBytes(this.TestImageFullPath);
-            var settings = new MagickReadSettings { Format = MagickFormat.Tga };
-            using var image = new MagickImage(new MemoryStream(this.data), settings);
-            return image.Width;
-        }
 
-        [Benchmark(Description = "ImageSharp Tga")]
+    [Benchmark(Baseline = true, Description = "ImageMagick Tga")]
-        public int TgaImageSharp()
+    public int TgaImageMagick()
-        {
+    {
-            using var image = Image.Load<Bgr24>(this.data);
+        var settings = new MagickReadSettings { Format = MagickFormat.Tga };
-            return image.Width;
+        using var image = new MagickImage(new MemoryStream(this.data), settings);
-        }
+        return image.Width;
+    }
 
-        [Benchmark(Description = "Pfim Tga")]
+    [Benchmark(Description = "ImageSharp Tga")]
-        public int TgaPfim()
+    public int TgaImageSharp()
-        {
+    {
-            using var image = Targa.Create(this.data, this.pfimConfig);
+        using var image = Image.Load<Bgr24>(this.data);
-            return image.Width;
+        return image.Width;
-        }
+    }
 
-        private class PfimAllocator : IImageAllocator
+    [Benchmark(Description = "Pfim Tga")]
-        {
+    public int TgaPfim()
-            private int rented;
+    {
-            private readonly ArrayPool<byte> shared = ArrayPool<byte>.Shared;
+        using var image = Targa.Create(this.data, this.pfimConfig);
+        return image.Width;
+    }
 
-            public byte[] Rent(int size) => this.shared.Rent(size);
+    private class PfimAllocator : IImageAllocator
+    {
+        private int rented;
+        private readonly ArrayPool<byte> shared = ArrayPool<byte>.Shared;
 
-            public void Return(byte[] data)
+        public byte[] Rent(int size) => this.shared.Rent(size);
-            {
-                Interlocked.Decrement(ref this.rented);
-                this.shared.Return(data);
-            }
 
-            public int Rented => this.rented;
+        public void Return(byte[] data)
+        {
+            Interlocked.Decrement(ref this.rented);
+            this.shared.Return(data);
         }
 
-        /* RESULTS (07/01/2020)
+        public int Rented => this.rented;
-        |            Method |       Runtime |           TestImage |         Mean |        Error |     StdDev | Ratio |  Gen 0 | Gen 1 | Gen 2 | Allocated |
-        |------------------ |-------------- |-------------------- |-------------:|-------------:|-----------:|------:|-------:|------:|------:|----------:|
-        | 'ImageMagick Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga | 1,778.965 us | 1,711.088 us | 93.7905 us | 1.000 | 1.9531 |     - |     - |   13668 B |
-        |  'ImageSharp Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga |    38.659 us |     6.886 us |  0.3774 us | 0.022 | 0.3052 |     - |     - |    1316 B |
-        |        'Pfim Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga |     6.752 us |    10.268 us |  0.5628 us | 0.004 | 0.0687 |     - |     - |     313 B |
-        |                   |               |                     |              |              |            |       |        |       |       |           |
-        | 'ImageMagick Tga' | .NET Core 2.1 | Tga/targa_24bit.tga | 1,407.585 us |   124.215 us |  6.8087 us | 1.000 | 1.9531 |     - |     - |   13307 B |
-        |  'ImageSharp Tga' | .NET Core 2.1 | Tga/targa_24bit.tga |    17.958 us |     9.352 us |  0.5126 us | 0.013 | 0.2747 |     - |     - |    1256 B |
-        |        'Pfim Tga' | .NET Core 2.1 | Tga/targa_24bit.tga |     5.645 us |     2.279 us |  0.1249 us | 0.004 | 0.0610 |     - |     - |     280 B |
-        */
     }
+
+    /* RESULTS (07/01/2020)
+    |            Method |       Runtime |           TestImage |         Mean |        Error |     StdDev | Ratio |  Gen 0 | Gen 1 | Gen 2 | Allocated |
+    |------------------ |-------------- |-------------------- |-------------:|-------------:|-----------:|------:|-------:|------:|------:|----------:|
+    | 'ImageMagick Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga | 1,778.965 us | 1,711.088 us | 93.7905 us | 1.000 | 1.9531 |     - |     - |   13668 B |
+    |  'ImageSharp Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga |    38.659 us |     6.886 us |  0.3774 us | 0.022 | 0.3052 |     - |     - |    1316 B |
+    |        'Pfim Tga' |    .NET 4.7.2 | Tga/targa_24bit.tga |     6.752 us |    10.268 us |  0.5628 us | 0.004 | 0.0687 |     - |     - |     313 B |
+    |                   |               |                     |              |              |            |       |        |       |       |           |
+    | 'ImageMagick Tga' | .NET Core 2.1 | Tga/targa_24bit.tga | 1,407.585 us |   124.215 us |  6.8087 us | 1.000 | 1.9531 |     - |     - |   13307 B |
+    |  'ImageSharp Tga' | .NET Core 2.1 | Tga/targa_24bit.tga |    17.958 us |     9.352 us |  0.5126 us | 0.013 | 0.2747 |     - |     - |    1256 B |
+    |        'Pfim Tga' | .NET Core 2.1 | Tga/targa_24bit.tga |     5.645 us |     2.279 us |  0.1249 us | 0.004 | 0.0610 |     - |     - |     280 B |
+    */
 }

tests/ImageSharp.Benchmarks/Codecs/Tga/EncodeTga.cs

@@ -1,56 +1,54 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using ImageMagick;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeTga
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private MagickImage tgaMagick;
-    public class EncodeTga
+    private Image<Rgba32> tga;
-    {
-        private MagickImage tgaMagick;
-        private Image<Rgba32> tga;
 
-        private string TestImageFullPath
+    private string TestImageFullPath
-            => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+        => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(TestImages.Tga.Bit24BottomLeft)]
+    [Params(TestImages.Tga.Bit24BottomLeft)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.tga == null)
         {
-            if (this.tga == null)
+            this.tga = Image.Load<Rgba32>(this.TestImageFullPath);
-            {
+            this.tgaMagick = new MagickImage(this.TestImageFullPath);
-                this.tga = Image.Load<Rgba32>(this.TestImageFullPath);
-                this.tgaMagick = new MagickImage(this.TestImageFullPath);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.tga.Dispose();
+        this.tga.Dispose();
-            this.tga = null;
+        this.tga = null;
-            this.tgaMagick.Dispose();
+        this.tgaMagick.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "Magick Tga")]
+    [Benchmark(Baseline = true, Description = "Magick Tga")]
-        public void MagickTga()
+    public void MagickTga()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.tgaMagick.Write(memoryStream, MagickFormat.Tga);
+        this.tgaMagick.Write(memoryStream, MagickFormat.Tga);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Tga")]
+    [Benchmark(Description = "ImageSharp Tga")]
-        public void ImageSharpTga()
+    public void ImageSharpTga()
-        {
+    {
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.tga.SaveAsTga(memoryStream);
+        this.tga.SaveAsTga(memoryStream);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Tiff/DecodeTiff.cs

@@ -5,86 +5,84 @@
 // Use the scripts gen_big.ps1 and gen_medium.ps1 in tests\Images\Input\Tiff\Benchmarks to generate those images.
 //// #define BIG_TESTS
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 using SDSize = System.Drawing.Size;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[MarkdownExporter]
+[HtmlExporter]
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeTiff
 {
-    [MarkdownExporter]
+    private string prevImage;
-    [HtmlExporter]
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class DecodeTiff
-    {
-        private string prevImage;
 
-        private byte[] data;
+    private byte[] data;
 
 #if BIG_TESTS
-        private static readonly int BufferSize = 1024 * 68;
+    private static readonly int BufferSize = 1024 * 68;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, Path.Combine(TestImages.Tiff.Benchmark_Path, this.TestImage));
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, Path.Combine(TestImages.Tiff.Benchmark_Path, this.TestImage));
 
-        [Params(
+    [Params(
-            TestImages.Tiff.Benchmark_BwFax3,
+        TestImages.Tiff.Benchmark_BwFax3,
-            //// TestImages.Tiff.Benchmark_RgbFax4, // fax4 is not supported yet.
+        //// TestImages.Tiff.Benchmark_RgbFax4, // fax4 is not supported yet.
-            TestImages.Tiff.Benchmark_GrayscaleUncompressed,
+        TestImages.Tiff.Benchmark_GrayscaleUncompressed,
-            TestImages.Tiff.Benchmark_PaletteUncompressed,
+        TestImages.Tiff.Benchmark_PaletteUncompressed,
-            TestImages.Tiff.Benchmark_RgbDeflate,
+        TestImages.Tiff.Benchmark_RgbDeflate,
-            TestImages.Tiff.Benchmark_RgbLzw,
+        TestImages.Tiff.Benchmark_RgbLzw,
-            TestImages.Tiff.Benchmark_RgbPackbits,
+        TestImages.Tiff.Benchmark_RgbPackbits,
-            TestImages.Tiff.Benchmark_RgbUncompressed)]
+        TestImages.Tiff.Benchmark_RgbUncompressed)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
 #else
-        private static readonly int BufferSize = Configuration.Default.StreamProcessingBufferSize;
+    private static readonly int BufferSize = Configuration.Default.StreamProcessingBufferSize;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(
+    [Params(
-            TestImages.Tiff.CcittFax3AllTermCodes,
+        TestImages.Tiff.CcittFax3AllTermCodes,
-            TestImages.Tiff.Fax4Compressed2,
+        TestImages.Tiff.Fax4Compressed2,
-            TestImages.Tiff.HuffmanRleAllMakeupCodes,
+        TestImages.Tiff.HuffmanRleAllMakeupCodes,
-            TestImages.Tiff.Calliphora_GrayscaleUncompressed,
+        TestImages.Tiff.Calliphora_GrayscaleUncompressed,
-            TestImages.Tiff.Calliphora_RgbPaletteLzw_Predictor,
+        TestImages.Tiff.Calliphora_RgbPaletteLzw_Predictor,
-            TestImages.Tiff.Calliphora_RgbDeflate_Predictor,
+        TestImages.Tiff.Calliphora_RgbDeflate_Predictor,
-            TestImages.Tiff.Calliphora_RgbLzwPredictor,
+        TestImages.Tiff.Calliphora_RgbLzwPredictor,
-            TestImages.Tiff.Calliphora_RgbPackbits,
+        TestImages.Tiff.Calliphora_RgbPackbits,
-            TestImages.Tiff.Calliphora_RgbUncompressed)]
+        TestImages.Tiff.Calliphora_RgbUncompressed)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 #endif
 
-        [IterationSetup]
+    [IterationSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.prevImage != this.TestImage)
         {
-            if (this.prevImage != this.TestImage)
+            this.data = File.ReadAllBytes(this.TestImageFullPath);
-            {
+            this.prevImage = this.TestImage;
-                this.data = File.ReadAllBytes(this.TestImageFullPath);
-                this.prevImage = this.TestImage;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Tiff")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Tiff")]
-        public SDSize TiffSystemDrawing()
+    public SDSize TiffSystemDrawing()
+    {
+        using (var memoryStream = new MemoryStream(this.data))
+        using (var image = SDImage.FromStream(memoryStream))
         {
-            using (var memoryStream = new MemoryStream(this.data))
+            return image.Size;
-            using (var image = SDImage.FromStream(memoryStream))
-            {
-                return image.Size;
-            }
         }
+    }
 
-        [Benchmark(Description = "ImageSharp Tiff")]
+    [Benchmark(Description = "ImageSharp Tiff")]
-        public Size TiffCore()
+    public Size TiffCore()
+    {
+        using (var ms = new MemoryStream(this.data))
+        using (var image = Image.Load<Rgba32>(ms))
         {
-            using (var ms = new MemoryStream(this.data))
+            return image.Size();
-            using (var image = Image.Load<Rgba32>(ms))
-            {
-                return image.Size();
-            }
         }
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Tiff/EncodeTiff.cs

@@ -1,9 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Drawing.Imaging;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.Formats.Tiff;
@@ -12,122 +10,121 @@ using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 using SDImage = System.Drawing.Image;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[MarkdownExporter]
+[HtmlExporter]
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeTiff
 {
-    [MarkdownExporter]
+    private Stream stream;
-    [HtmlExporter]
+    private SDImage drawing;
-    [Config(typeof(Config.ShortMultiFramework))]
+    private Image<Rgba32> core;
-    public class EncodeTiff
-    {
-        private Stream stream;
-        private SDImage drawing;
-        private Image<Rgba32> core;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(TestImages.Tiff.Calliphora_RgbUncompressed)]
+    [Params(TestImages.Tiff.Calliphora_RgbUncompressed)]
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [Params(
+    [Params(
-            TiffCompression.None,
+        TiffCompression.None,
 
-            // System.Drawing does not support Deflate or PackBits
+        // System.Drawing does not support Deflate or PackBits
-            // TiffCompression.Deflate,
+        // TiffCompression.Deflate,
-            // TiffCompression.PackBits,
+        // TiffCompression.PackBits,
-            TiffCompression.Lzw,
+        TiffCompression.Lzw,
-            TiffCompression.CcittGroup3Fax,
+        TiffCompression.CcittGroup3Fax,
-            TiffCompression.Ccitt1D)]
+        TiffCompression.Ccitt1D)]
-        public TiffCompression Compression { get; set; }
+    public TiffCompression Compression { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.stream == null)
         {
-            if (this.stream == null)
+            this.stream = File.OpenRead(this.TestImageFullPath);
-            {
+            this.core = Image.Load<Rgba32>(this.stream);
-                this.stream = File.OpenRead(this.TestImageFullPath);
+            this.stream.Position = 0;
-                this.core = Image.Load<Rgba32>(this.stream);
+            this.drawing = SDImage.FromStream(this.stream);
-                this.stream.Position = 0;
-                this.drawing = SDImage.FromStream(this.stream);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.core.Dispose();
+        this.core.Dispose();
-            this.drawing.Dispose();
+        this.drawing.Dispose();
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "System.Drawing Tiff")]
+    [Benchmark(Baseline = true, Description = "System.Drawing Tiff")]
-        public void SystemDrawing()
+    public void SystemDrawing()
+    {
+        ImageCodecInfo codec = FindCodecForType("image/tiff");
+        using var parameters = new EncoderParameters(1)
         {
-            ImageCodecInfo codec = FindCodecForType("image/tiff");
+            Param = { [0] = new EncoderParameter(Encoder.Compression, (long)Cast(this.Compression)) }
-            using var parameters = new EncoderParameters(1)
+        };
-            {
-                Param = { [0] = new EncoderParameter(Encoder.Compression, (long)Cast(this.Compression)) }
-            };
 
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.drawing.Save(memoryStream, codec, parameters);
+        this.drawing.Save(memoryStream, codec, parameters);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Tiff")]
+    [Benchmark(Description = "ImageSharp Tiff")]
-        public void TiffCore()
+    public void TiffCore()
-        {
+    {
-            TiffPhotometricInterpretation photometricInterpretation =
+        TiffPhotometricInterpretation photometricInterpretation =
-                IsOneBitCompression(this.Compression) ?
+            IsOneBitCompression(this.Compression) ?
-                    TiffPhotometricInterpretation.WhiteIsZero :
+                TiffPhotometricInterpretation.WhiteIsZero :
-                    TiffPhotometricInterpretation.Rgb;
+                TiffPhotometricInterpretation.Rgb;
-
+
-            var encoder = new TiffEncoder() { Compression = this.Compression, PhotometricInterpretation = photometricInterpretation };
+        var encoder = new TiffEncoder() { Compression = this.Compression, PhotometricInterpretation = photometricInterpretation };
-            using var memoryStream = new MemoryStream();
+        using var memoryStream = new MemoryStream();
-            this.core.SaveAsTiff(memoryStream, encoder);
+        this.core.SaveAsTiff(memoryStream, encoder);
-        }
+    }
 
-        private static ImageCodecInfo FindCodecForType(string mimeType)
+    private static ImageCodecInfo FindCodecForType(string mimeType)
-        {
+    {
-            ImageCodecInfo[] imgEncoders = ImageCodecInfo.GetImageEncoders();
+        ImageCodecInfo[] imgEncoders = ImageCodecInfo.GetImageEncoders();
 
-            for (int i = 0; i < imgEncoders.GetLength(0); i++)
+        for (int i = 0; i < imgEncoders.GetLength(0); i++)
+        {
+            if (imgEncoders[i].MimeType == mimeType)
             {
-                if (imgEncoders[i].MimeType == mimeType)
+                return imgEncoders[i];
-                {
-                    return imgEncoders[i];
-                }
             }
-
-            return null;
         }
 
-        private static EncoderValue Cast(TiffCompression compression)
+        return null;
+    }
+
+    private static EncoderValue Cast(TiffCompression compression)
+    {
+        switch (compression)
         {
-            switch (compression)
+            case TiffCompression.None:
-            {
+                return EncoderValue.CompressionNone;
-                case TiffCompression.None:
-                    return EncoderValue.CompressionNone;
 
-                case TiffCompression.CcittGroup3Fax:
+            case TiffCompression.CcittGroup3Fax:
-                    return EncoderValue.CompressionCCITT3;
+                return EncoderValue.CompressionCCITT3;
 
-                case TiffCompression.Ccitt1D:
+            case TiffCompression.Ccitt1D:
-                    return EncoderValue.CompressionRle;
+                return EncoderValue.CompressionRle;
 
-                case TiffCompression.Lzw:
+            case TiffCompression.Lzw:
-                    return EncoderValue.CompressionLZW;
+                return EncoderValue.CompressionLZW;
 
-                default:
+            default:
-                    throw new NotSupportedException(compression.ToString());
+                throw new NotSupportedException(compression.ToString());
-            }
         }
+    }
 
-        public static bool IsOneBitCompression(TiffCompression compression)
+    public static bool IsOneBitCompression(TiffCompression compression)
+    {
+        if (compression is TiffCompression.Ccitt1D or TiffCompression.CcittGroup3Fax or TiffCompression.CcittGroup4Fax)
         {
-            if (compression is TiffCompression.Ccitt1D or TiffCompression.CcittGroup3Fax or TiffCompression.CcittGroup4Fax)
+            return true;
-            {
-                return true;
-            }
-
-            return false;
         }
+
+        return false;
     }
 }

tests/ImageSharp.Benchmarks/Codecs/Webp/DecodeWebp.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 
 using ImageMagick;
@@ -9,96 +8,95 @@ using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[MarkdownExporter]
+[HtmlExporter]
+[Config(typeof(Config.ShortMultiFramework))]
+public class DecodeWebp
 {
-    [MarkdownExporter]
+    private Configuration configuration;
-    [HtmlExporter]
+
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] webpLossyBytes;
-    public class DecodeWebp
+
+    private byte[] webpLosslessBytes;
+
+    private string TestImageLossyFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImageLossy);
+
+    private string TestImageLosslessFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImageLossless);
+
+    [Params(TestImages.Webp.Lossy.Earth)]
+    public string TestImageLossy { get; set; }
+
+    [Params(TestImages.Webp.Lossless.Earth)]
+    public string TestImageLossless { get; set; }
+
+    [GlobalSetup]
+    public void ReadImages()
+    {
+        this.configuration = Configuration.CreateDefaultInstance();
+        new WebpConfigurationModule().Configure(this.configuration);
+
+        this.webpLossyBytes ??= File.ReadAllBytes(this.TestImageLossyFullPath);
+        this.webpLosslessBytes ??= File.ReadAllBytes(this.TestImageLosslessFullPath);
+    }
+
+    [Benchmark(Description = "Magick Lossy Webp")]
+    public int WebpLossyMagick()
+    {
+        var settings = new MagickReadSettings { Format = MagickFormat.WebP };
+        using var memoryStream = new MemoryStream(this.webpLossyBytes);
+        using var image = new MagickImage(memoryStream, settings);
+        return image.Width;
+    }
+
+    [Benchmark(Description = "ImageSharp Lossy Webp")]
+    public int WebpLossy()
     {
-        private Configuration configuration;
+        using var memoryStream = new MemoryStream(this.webpLossyBytes);
-
+        using var image = Image.Load<Rgba32>(memoryStream);
-        private byte[] webpLossyBytes;
+        return image.Height;
-
-        private byte[] webpLosslessBytes;
-
-        private string TestImageLossyFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImageLossy);
-
-        private string TestImageLosslessFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImageLossless);
-
-        [Params(TestImages.Webp.Lossy.Earth)]
-        public string TestImageLossy { get; set; }
-
-        [Params(TestImages.Webp.Lossless.Earth)]
-        public string TestImageLossless { get; set; }
-
-        [GlobalSetup]
-        public void ReadImages()
-        {
-            this.configuration = Configuration.CreateDefaultInstance();
-            new WebpConfigurationModule().Configure(this.configuration);
-
-            this.webpLossyBytes ??= File.ReadAllBytes(this.TestImageLossyFullPath);
-            this.webpLosslessBytes ??= File.ReadAllBytes(this.TestImageLosslessFullPath);
-        }
-
-        [Benchmark(Description = "Magick Lossy Webp")]
-        public int WebpLossyMagick()
-        {
-            var settings = new MagickReadSettings { Format = MagickFormat.WebP };
-            using var memoryStream = new MemoryStream(this.webpLossyBytes);
-            using var image = new MagickImage(memoryStream, settings);
-            return image.Width;
-        }
-
-        [Benchmark(Description = "ImageSharp Lossy Webp")]
-        public int WebpLossy()
-        {
-            using var memoryStream = new MemoryStream(this.webpLossyBytes);
-            using var image = Image.Load<Rgba32>(memoryStream);
-            return image.Height;
-        }
-
-        [Benchmark(Description = "Magick Lossless Webp")]
-        public int WebpLosslessMagick()
-        {
-            var settings = new MagickReadSettings { Format = MagickFormat.WebP };
-            using var memoryStream = new MemoryStream(this.webpLossyBytes);
-            using var image = new MagickImage(memoryStream, settings);
-            return image.Width;
-        }
-
-        [Benchmark(Description = "ImageSharp Lossless Webp")]
-        public int WebpLossless()
-        {
-            using var memoryStream = new MemoryStream(this.webpLosslessBytes);
-            using var image = Image.Load<Rgba32>(memoryStream);
-            return image.Height;
-        }
-
-        /* Results 04.11.2021
-         *  BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1320 (21H1/May2021Update)
-            Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
-            .NET SDK=6.0.100-rc.2.21505.57
-              [Host]     : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
-              Job-WQLXJO : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
-              Job-OJJAMD : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
-              Job-OMFOAS : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT
-
-            |                     Method |        Job |              Runtime |             Arguments |        TestImageLossy |        TestImageLossless |       Mean |     Error |  StdDev |    Gen 0 | Gen 1 | Gen 2 | Allocated |
-            |--------------------------- |----------- |--------------------- |---------------------- |---------------------- |------------------------- |-----------:|----------:|--------:|---------:|------:|------:|----------:|
-            |        'Magick Lossy Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   107.9 ms |  28.91 ms | 1.58 ms |        - |     - |     - |     25 KB |
-            |    'ImageSharp Lossy Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   282.3 ms |  25.40 ms | 1.39 ms | 500.0000 |     - |     - |  2,428 KB |
-            |     'Magick Lossless Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.3 ms |  11.99 ms | 0.66 ms |        - |     - |     - |     16 KB |
-            | 'ImageSharp Lossless Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   280.2 ms |   6.21 ms | 0.34 ms |        - |     - |     - |  2,092 KB |
-            |        'Magick Lossy Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.2 ms |   9.32 ms | 0.51 ms |        - |     - |     - |     15 KB |
-            |    'ImageSharp Lossy Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   295.8 ms |  21.25 ms | 1.16 ms | 500.0000 |     - |     - |  2,427 KB |
-            |     'Magick Lossless Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.5 ms |   4.07 ms | 0.22 ms |        - |     - |     - |     15 KB |
-            | 'ImageSharp Lossless Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   464.0 ms |  55.70 ms | 3.05 ms |        - |     - |     - |  2,090 KB |
-            |        'Magick Lossy Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   108.0 ms |  29.60 ms | 1.62 ms |        - |     - |     - |     32 KB |
-            |    'ImageSharp Lossy Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   564.9 ms |  29.69 ms | 1.63 ms |        - |     - |     - |  2,436 KB |
-            |     'Magick Lossless Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.2 ms |   4.74 ms | 0.26 ms |        - |     - |     - |     18 KB |
-            | 'ImageSharp Lossless Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp | 1,767.5 ms | 106.33 ms | 5.83 ms |        - |     - |     - |  9,729 KB |
-         */
     }
+
+    [Benchmark(Description = "Magick Lossless Webp")]
+    public int WebpLosslessMagick()
+    {
+        var settings = new MagickReadSettings { Format = MagickFormat.WebP };
+        using var memoryStream = new MemoryStream(this.webpLossyBytes);
+        using var image = new MagickImage(memoryStream, settings);
+        return image.Width;
+    }
+
+    [Benchmark(Description = "ImageSharp Lossless Webp")]
+    public int WebpLossless()
+    {
+        using var memoryStream = new MemoryStream(this.webpLosslessBytes);
+        using var image = Image.Load<Rgba32>(memoryStream);
+        return image.Height;
+    }
+
+    /* Results 04.11.2021
+     *  BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1320 (21H1/May2021Update)
+        Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
+        .NET SDK=6.0.100-rc.2.21505.57
+          [Host]     : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
+          Job-WQLXJO : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
+          Job-OJJAMD : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
+          Job-OMFOAS : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT
+
+        |                     Method |        Job |              Runtime |             Arguments |        TestImageLossy |        TestImageLossless |       Mean |     Error |  StdDev |    Gen 0 | Gen 1 | Gen 2 | Allocated |
+        |--------------------------- |----------- |--------------------- |---------------------- |---------------------- |------------------------- |-----------:|----------:|--------:|---------:|------:|------:|----------:|
+        |        'Magick Lossy Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   107.9 ms |  28.91 ms | 1.58 ms |        - |     - |     - |     25 KB |
+        |    'ImageSharp Lossy Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   282.3 ms |  25.40 ms | 1.39 ms | 500.0000 |     - |     - |  2,428 KB |
+        |     'Magick Lossless Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.3 ms |  11.99 ms | 0.66 ms |        - |     - |     - |     16 KB |
+        | 'ImageSharp Lossless Webp' | Job-HLWZLL |             .NET 5.0 | /p:DebugType=portable | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   280.2 ms |   6.21 ms | 0.34 ms |        - |     - |     - |  2,092 KB |
+        |        'Magick Lossy Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.2 ms |   9.32 ms | 0.51 ms |        - |     - |     - |     15 KB |
+        |    'ImageSharp Lossy Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   295.8 ms |  21.25 ms | 1.16 ms | 500.0000 |     - |     - |  2,427 KB |
+        |     'Magick Lossless Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.5 ms |   4.07 ms | 0.22 ms |        - |     - |     - |     15 KB |
+        | 'ImageSharp Lossless Webp' | Job-ALQPDS |        .NET Core 3.1 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   464.0 ms |  55.70 ms | 3.05 ms |        - |     - |     - |  2,090 KB |
+        |        'Magick Lossy Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   108.0 ms |  29.60 ms | 1.62 ms |        - |     - |     - |     32 KB |
+        |    'ImageSharp Lossy Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   564.9 ms |  29.69 ms | 1.63 ms |        - |     - |     - |  2,436 KB |
+        |     'Magick Lossless Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp |   106.2 ms |   4.74 ms | 0.26 ms |        - |     - |     - |     18 KB |
+        | 'ImageSharp Lossless Webp' | Job-RYVVNN | .NET Framework 4.7.2 |               Default | Webp/earth_lossy.webp | Webp/earth_lossless.webp | 1,767.5 ms | 106.33 ms | 5.83 ms |        - |     - |     - |  9,729 KB |
+     */
 }

tests/ImageSharp.Benchmarks/Codecs/Webp/EncodeWebp.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using ImageMagick;
 using ImageMagick.Formats;
@@ -9,135 +8,134 @@ using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.Codecs
+namespace SixLabors.ImageSharp.Benchmarks.Codecs;
+
+[MarkdownExporter]
+[HtmlExporter]
+[Config(typeof(Config.ShortMultiFramework))]
+public class EncodeWebp
 {
-    [MarkdownExporter]
+    private MagickImage webpMagick;
-    [HtmlExporter]
+    private Image<Rgba32> webp;
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class EncodeWebp
-    {
-        private MagickImage webpMagick;
-        private Image<Rgba32> webp;
 
-        private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
+    private string TestImageFullPath => Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.TestImage);
 
-        [Params(TestImages.Png.Bike)] // The bike image will have all 3 transforms as lossless webp.
+    [Params(TestImages.Png.Bike)] // The bike image will have all 3 transforms as lossless webp.
-        public string TestImage { get; set; }
+    public string TestImage { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void ReadImages()
+    public void ReadImages()
+    {
+        if (this.webp == null)
         {
-            if (this.webp == null)
+            this.webp = Image.Load<Rgba32>(this.TestImageFullPath);
-            {
+            this.webpMagick = new MagickImage(this.TestImageFullPath);
-                this.webp = Image.Load<Rgba32>(this.TestImageFullPath);
-                this.webpMagick = new MagickImage(this.TestImageFullPath);
-            }
         }
+    }
 
-        [GlobalCleanup]
+    [GlobalCleanup]
-        public void Cleanup()
+    public void Cleanup()
-        {
+    {
-            this.webp.Dispose();
+        this.webp.Dispose();
-            this.webpMagick.Dispose();
+        this.webpMagick.Dispose();
-        }
+    }
+
+    [Benchmark(Description = "Magick Webp Lossy")]
+    public void MagickWebpLossy()
+    {
+        using var memoryStream = new MemoryStream();
 
-        [Benchmark(Description = "Magick Webp Lossy")]
+        var defines = new WebPWriteDefines
-        public void MagickWebpLossy()
         {
-            using var memoryStream = new MemoryStream();
+            Lossless = false,
-
+            Method = 4,
-            var defines = new WebPWriteDefines
+            AlphaCompression = WebPAlphaCompression.None,
-            {
+            FilterStrength = 60,
-                Lossless = false,
+            SnsStrength = 50,
-                Method = 4,
+            Pass = 1,
-                AlphaCompression = WebPAlphaCompression.None,
+
-                FilterStrength = 60,
+            // 100 means off.
-                SnsStrength = 50,
+            NearLossless = 100
-                Pass = 1,
+        };
-
+
-                // 100 means off.
+        this.webpMagick.Quality = 75;
-                NearLossless = 100
+        this.webpMagick.Write(memoryStream, defines);
-            };
+    }
-
-            this.webpMagick.Quality = 75;
-            this.webpMagick.Write(memoryStream, defines);
-        }
 
-        [Benchmark(Description = "ImageSharp Webp Lossy")]
+    [Benchmark(Description = "ImageSharp Webp Lossy")]
-        public void ImageSharpWebpLossy()
+    public void ImageSharpWebpLossy()
+    {
+        using var memoryStream = new MemoryStream();
+        this.webp.Save(memoryStream, new WebpEncoder()
         {
-            using var memoryStream = new MemoryStream();
+            FileFormat = WebpFileFormatType.Lossy,
-            this.webp.Save(memoryStream, new WebpEncoder()
+            Method = WebpEncodingMethod.Level4,
-            {
+            UseAlphaCompression = false,
-                FileFormat = WebpFileFormatType.Lossy,
+            FilterStrength = 60,
-                Method = WebpEncodingMethod.Level4,
+            SpatialNoiseShaping = 50,
-                UseAlphaCompression = false,
+            EntropyPasses = 1
-                FilterStrength = 60,
+        });
-                SpatialNoiseShaping = 50,
+    }
-                EntropyPasses = 1
-            });
-        }
 
-        [Benchmark(Baseline = true, Description = "Magick Webp Lossless")]
+    [Benchmark(Baseline = true, Description = "Magick Webp Lossless")]
-        public void MagickWebpLossless()
+    public void MagickWebpLossless()
+    {
+        using var memoryStream = new MemoryStream();
+        var defines = new WebPWriteDefines
         {
-            using var memoryStream = new MemoryStream();
+            Lossless = true,
-            var defines = new WebPWriteDefines
+            Method = 4,
-            {
+
-                Lossless = true,
+            // 100 means off.
-                Method = 4,
+            NearLossless = 100
-
+        };
-                // 100 means off.
-                NearLossless = 100
-            };
-
-            this.webpMagick.Quality = 75;
-            this.webpMagick.Write(memoryStream, defines);
-        }
 
-        [Benchmark(Description = "ImageSharp Webp Lossless")]
+        this.webpMagick.Quality = 75;
-        public void ImageSharpWebpLossless()
+        this.webpMagick.Write(memoryStream, defines);
+    }
+
+    [Benchmark(Description = "ImageSharp Webp Lossless")]
+    public void ImageSharpWebpLossless()
+    {
+        using var memoryStream = new MemoryStream();
+        this.webp.Save(memoryStream, new WebpEncoder()
         {
-            using var memoryStream = new MemoryStream();
+            FileFormat = WebpFileFormatType.Lossless,
-            this.webp.Save(memoryStream, new WebpEncoder()
+            Method = WebpEncodingMethod.Level4,
-            {
+            NearLossless = false,
-                FileFormat = WebpFileFormatType.Lossless,
-                Method = WebpEncodingMethod.Level4,
-                NearLossless = false,
-
-                // This is equal to exact = false in libwebp, which is the default.
-                TransparentColorMode = WebpTransparentColorMode.Clear
-            });
-        }
 
-        /* Results 04.11.2021
+            // This is equal to exact = false in libwebp, which is the default.
-         * Summary *
+            TransparentColorMode = WebpTransparentColorMode.Clear
-        BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1320 (21H1/May2021Update)
+        });
-        Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
-        .NET SDK=6.0.100-rc.2.21505.57
-          [Host]     : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
-          Job-WQLXJO : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
-          Job-OJJAMD : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
-          Job-OMFOAS : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT
-
-        IterationCount=3  LaunchCount=1  WarmupCount=3
-
-        |                     Method |        Job |              Runtime |             Arguments |    TestImage |      Mean |     Error |   StdDev | Ratio | RatioSD |       Gen 0 |     Gen 1 |     Gen 2 |  Allocated |
-        |--------------------------- |----------- |--------------------- |---------------------- |------------- |----------:|----------:|---------:|------:|--------:|------------:|----------:|----------:|-----------:|
-        |        'Magick Webp Lossy' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png |  23.33 ms |  1.491 ms | 0.082 ms |  0.15 |    0.00 |           - |         - |         - |      67 KB |
-        |    'ImageSharp Webp Lossy' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 245.80 ms | 24.288 ms | 1.331 ms |  1.53 |    0.01 | 135000.0000 |         - |         - | 552,713 KB |
-        |     'Magick Webp Lossless' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 160.36 ms | 11.131 ms | 0.610 ms |  1.00 |    0.00 |           - |         - |         - |     518 KB |
-        | 'ImageSharp Webp Lossless' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 313.93 ms | 45.605 ms | 2.500 ms |  1.96 |    0.01 |  34000.0000 | 5000.0000 | 2000.0000 | 161,670 KB |
-        |                            |            |                      |                       |              |           |           |          |       |         |             |           |           |            |
-        |        'Magick Webp Lossy' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png |  23.36 ms |  2.289 ms | 0.125 ms |  0.15 |    0.00 |           - |         - |         - |      67 KB |
-        |    'ImageSharp Webp Lossy' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 254.64 ms | 19.620 ms | 1.075 ms |  1.59 |    0.00 | 135000.0000 |         - |         - | 552,713 KB |
-        |     'Magick Webp Lossless' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 160.30 ms |  9.549 ms | 0.523 ms |  1.00 |    0.00 |           - |         - |         - |     518 KB |
-        | 'ImageSharp Webp Lossless' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 320.35 ms | 22.924 ms | 1.257 ms |  2.00 |    0.01 |  34000.0000 | 5000.0000 | 2000.0000 | 161,669 KB |
-        |                            |            |                      |                       |              |           |           |          |       |         |             |           |           |            |
-        |        'Magick Webp Lossy' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png |  23.37 ms |  0.908 ms | 0.050 ms |  0.15 |    0.00 |           - |         - |         - |      68 KB |
-        |    'ImageSharp Webp Lossy' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 378.67 ms | 25.540 ms | 1.400 ms |  2.36 |    0.01 | 135000.0000 |         - |         - | 554,351 KB |
-        |     'Magick Webp Lossless' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 160.13 ms |  5.115 ms | 0.280 ms |  1.00 |    0.00 |           - |         - |         - |     520 KB |
-        | 'ImageSharp Webp Lossless' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 379.01 ms | 71.192 ms | 3.902 ms |  2.37 |    0.02 |  34000.0000 | 5000.0000 | 2000.0000 | 162,119 KB |
-        */
     }
+
+    /* Results 04.11.2021
+     * Summary *
+    BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1320 (21H1/May2021Update)
+    Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
+    .NET SDK=6.0.100-rc.2.21505.57
+      [Host]     : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
+      Job-WQLXJO : .NET 5.0.11 (5.0.1121.47308), X64 RyuJIT
+      Job-OJJAMD : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
+      Job-OMFOAS : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT
+
+    IterationCount=3  LaunchCount=1  WarmupCount=3
+
+    |                     Method |        Job |              Runtime |             Arguments |    TestImage |      Mean |     Error |   StdDev | Ratio | RatioSD |       Gen 0 |     Gen 1 |     Gen 2 |  Allocated |
+    |--------------------------- |----------- |--------------------- |---------------------- |------------- |----------:|----------:|---------:|------:|--------:|------------:|----------:|----------:|-----------:|
+    |        'Magick Webp Lossy' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png |  23.33 ms |  1.491 ms | 0.082 ms |  0.15 |    0.00 |           - |         - |         - |      67 KB |
+    |    'ImageSharp Webp Lossy' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 245.80 ms | 24.288 ms | 1.331 ms |  1.53 |    0.01 | 135000.0000 |         - |         - | 552,713 KB |
+    |     'Magick Webp Lossless' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 160.36 ms | 11.131 ms | 0.610 ms |  1.00 |    0.00 |           - |         - |         - |     518 KB |
+    | 'ImageSharp Webp Lossless' | Job-WQLXJO |             .NET 5.0 | /p:DebugType=portable | Png/Bike.png | 313.93 ms | 45.605 ms | 2.500 ms |  1.96 |    0.01 |  34000.0000 | 5000.0000 | 2000.0000 | 161,670 KB |
+    |                            |            |                      |                       |              |           |           |          |       |         |             |           |           |            |
+    |        'Magick Webp Lossy' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png |  23.36 ms |  2.289 ms | 0.125 ms |  0.15 |    0.00 |           - |         - |         - |      67 KB |
+    |    'ImageSharp Webp Lossy' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 254.64 ms | 19.620 ms | 1.075 ms |  1.59 |    0.00 | 135000.0000 |         - |         - | 552,713 KB |
+    |     'Magick Webp Lossless' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 160.30 ms |  9.549 ms | 0.523 ms |  1.00 |    0.00 |           - |         - |         - |     518 KB |
+    | 'ImageSharp Webp Lossless' | Job-OJJAMD |        .NET Core 3.1 |               Default | Png/Bike.png | 320.35 ms | 22.924 ms | 1.257 ms |  2.00 |    0.01 |  34000.0000 | 5000.0000 | 2000.0000 | 161,669 KB |
+    |                            |            |                      |                       |              |           |           |          |       |         |             |           |           |            |
+    |        'Magick Webp Lossy' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png |  23.37 ms |  0.908 ms | 0.050 ms |  0.15 |    0.00 |           - |         - |         - |      68 KB |
+    |    'ImageSharp Webp Lossy' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 378.67 ms | 25.540 ms | 1.400 ms |  2.36 |    0.01 | 135000.0000 |         - |         - | 554,351 KB |
+    |     'Magick Webp Lossless' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 160.13 ms |  5.115 ms | 0.280 ms |  1.00 |    0.00 |           - |         - |         - |     520 KB |
+    | 'ImageSharp Webp Lossless' | Job-OMFOAS | .NET Framework 4.7.2 |               Default | Png/Bike.png | 379.01 ms | 71.192 ms | 3.902 ms |  2.37 |    0.02 |  34000.0000 | 5000.0000 | 2000.0000 | 162,119 KB |
+    */
 }

tests/ImageSharp.Benchmarks/Color/Bulk/FromRgba32Bytes.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
 using BenchmarkDotNet.Attributes;
 
@@ -9,82 +8,81 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    public abstract class FromRgba32Bytes<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        private IMemoryOwner<TPixel> destination;
-
-        private IMemoryOwner<byte> source;
 
-        private Configuration configuration;
+public abstract class FromRgba32Bytes<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    private IMemoryOwner<TPixel> destination;
 
-        [Params(
+    private IMemoryOwner<byte> source;
-            128,
-            1024,
-            2048)]
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    private Configuration configuration;
-        public void Setup()
-        {
-            this.configuration = Configuration.Default;
-            this.destination = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.source = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 4);
-        }
 
-        [GlobalCleanup]
+    [Params(
-        public void Cleanup()
+        128,
-        {
+        1024,
-            this.destination.Dispose();
+        2048)]
-            this.source.Dispose();
+    public int Count { get; set; }
-        }
 
-        // [Benchmark]
+    [GlobalSetup]
-        public void Naive()
+    public void Setup()
-        {
+    {
-            Span<byte> s = this.source.GetSpan();
+        this.configuration = Configuration.Default;
-            Span<TPixel> d = this.destination.GetSpan();
+        this.destination = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
+        this.source = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 4);
+    }
 
-            for (int i = 0; i < this.Count; i++)
+    [GlobalCleanup]
-            {
+    public void Cleanup()
-                int i4 = i * 4;
+    {
-                var c = default(TPixel);
+        this.destination.Dispose();
-                c.FromRgba32(new Rgba32(s[i4], s[i4 + 1], s[i4 + 2], s[i4 + 3]));
+        this.source.Dispose();
-                d[i] = c;
+    }
-            }
-        }
 
-        [Benchmark(Baseline = true)]
+    // [Benchmark]
-        public void CommonBulk()
+    public void Naive()
-        {
+    {
-            new PixelOperations<TPixel>().FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
+        Span<byte> s = this.source.GetSpan();
-        }
+        Span<TPixel> d = this.destination.GetSpan();
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void OptimizedBulk()
         {
-           PixelOperations<TPixel>.Instance.FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
+            int i4 = i * 4;
+            var c = default(TPixel);
+            c.FromRgba32(new Rgba32(s[i4], s[i4 + 1], s[i4 + 2], s[i4 + 3]));
+            d[i] = c;
         }
     }
 
-    public class FromRgba32Bytes_ToRgba32 : FromRgba32Bytes<Rgba32>
+    [Benchmark(Baseline = true)]
+    public void CommonBulk()
     {
+        new PixelOperations<TPixel>().FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
     }
 
-    public class FromRgba32Bytes_ToBgra32 : FromRgba32Bytes<Bgra32>
+    [Benchmark]
+    public void OptimizedBulk()
     {
-        // RESULTS:
+       PixelOperations<TPixel>.Instance.FromRgba32Bytes(this.configuration, this.source.GetSpan(), this.destination.GetSpan(), this.Count);
-        //         Method | Count |       Mean |     Error |    StdDev | Scaled |
-        // -------------- |------ |-----------:|----------:|----------:|-------:|
-        //     CommonBulk |   128 |   207.1 ns |  3.723 ns |  3.300 ns |   1.00 |
-        //  OptimizedBulk |   128 |   166.5 ns |  1.204 ns |  1.005 ns |   0.80 |
-        //                |       |            |           |           |        |
-        //     CommonBulk |  1024 | 1,333.9 ns | 12.426 ns | 11.624 ns |   1.00 |
-        //  OptimizedBulk |  1024 |   974.1 ns | 18.803 ns | 16.669 ns |   0.73 |
-        //                |       |            |           |           |        |
-        //     CommonBulk |  2048 | 2,625.4 ns | 30.143 ns | 26.721 ns |   1.00 |
-        //  OptimizedBulk |  2048 | 1,843.0 ns | 20.505 ns | 18.177 ns |   0.70 |
     }
 }
+
+public class FromRgba32Bytes_ToRgba32 : FromRgba32Bytes<Rgba32>
+{
+}
+
+public class FromRgba32Bytes_ToBgra32 : FromRgba32Bytes<Bgra32>
+{
+    // RESULTS:
+    //         Method | Count |       Mean |     Error |    StdDev | Scaled |
+    // -------------- |------ |-----------:|----------:|----------:|-------:|
+    //     CommonBulk |   128 |   207.1 ns |  3.723 ns |  3.300 ns |   1.00 |
+    //  OptimizedBulk |   128 |   166.5 ns |  1.204 ns |  1.005 ns |   0.80 |
+    //                |       |            |           |           |        |
+    //     CommonBulk |  1024 | 1,333.9 ns | 12.426 ns | 11.624 ns |   1.00 |
+    //  OptimizedBulk |  1024 |   974.1 ns | 18.803 ns | 16.669 ns |   0.73 |
+    //                |       |            |           |           |        |
+    //     CommonBulk |  2048 | 2,625.4 ns | 30.143 ns | 26.721 ns |   1.00 |
+    //  OptimizedBulk |  2048 | 1,843.0 ns | 20.505 ns | 18.177 ns |   0.70 |
+}

tests/ImageSharp.Benchmarks/Color/Bulk/FromVector4.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -13,156 +12,155 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    [Config(typeof(Config.ShortCore31))]
-    public abstract class FromVector4<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        protected IMemoryOwner<Vector4> source;
 
-        protected IMemoryOwner<TPixel> destination;
+[Config(typeof(Config.ShortCore31))]
+public abstract class FromVector4<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    protected IMemoryOwner<Vector4> source;
 
-        protected Configuration Configuration => Configuration.Default;
+    protected IMemoryOwner<TPixel> destination;
 
-        // [Params(64, 2048)]
+    protected Configuration Configuration => Configuration.Default;
-        [Params(64, 256, 2048)]
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    // [Params(64, 2048)]
-        public void Setup()
+    [Params(64, 256, 2048)]
-        {
+    public int Count { get; set; }
-            this.destination = this.Configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.source = this.Configuration.MemoryAllocator.Allocate<Vector4>(this.Count);
-        }
 
-        [GlobalCleanup]
+    [GlobalSetup]
-        public void Cleanup()
+    public void Setup()
-        {
+    {
-            this.destination.Dispose();
+        this.destination = this.Configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.source.Dispose();
+        this.source = this.Configuration.MemoryAllocator.Allocate<Vector4>(this.Count);
-        }
+    }
 
-        // [Benchmark]
+    [GlobalCleanup]
-        public void PerElement()
+    public void Cleanup()
-        {
+    {
-            ref Vector4 s = ref MemoryMarshal.GetReference(this.source.GetSpan());
+        this.destination.Dispose();
-            ref TPixel d = ref MemoryMarshal.GetReference(this.destination.GetSpan());
+        this.source.Dispose();
-            for (int i = 0; i < this.Count; i++)
+    }
-            {
-                Unsafe.Add(ref d, i).FromVector4(Unsafe.Add(ref s, i));
-            }
-        }
 
-        [Benchmark(Baseline = true)]
+    // [Benchmark]
-        public void PixelOperations_Base()
+    public void PerElement()
+    {
+        ref Vector4 s = ref MemoryMarshal.GetReference(this.source.GetSpan());
+        ref TPixel d = ref MemoryMarshal.GetReference(this.destination.GetSpan());
+        for (int i = 0; i < this.Count; i++)
         {
-            new PixelOperations<TPixel>().FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
+            Unsafe.Add(ref d, i).FromVector4(Unsafe.Add(ref s, i));
         }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void PixelOperations_Specialized()
+    public void PixelOperations_Base()
-        {
+    {
-            PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
+        new PixelOperations<TPixel>().FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
-        }
     }
 
-    public class FromVector4Rgba32 : FromVector4<Rgba32>
+    [Benchmark]
+    public void PixelOperations_Specialized()
     {
-        [Benchmark]
+        PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, this.source.GetSpan(), this.destination.GetSpan());
-        public void FallbackIntrinsics128()
+    }
-        {
+}
-            Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
-            Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-            SimdUtils.FallbackIntrinsics128.NormalizedFloatToByteSaturate(sBytes, dFloats);
+public class FromVector4Rgba32 : FromVector4<Rgba32>
-        }
+{
+    [Benchmark]
+    public void FallbackIntrinsics128()
+    {
+        Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
+        Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-        [Benchmark]
+        SimdUtils.FallbackIntrinsics128.NormalizedFloatToByteSaturate(sBytes, dFloats);
-        public void ExtendedIntrinsic()
+    }
-        {
-            Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
-            Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-            SimdUtils.ExtendedIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
+    [Benchmark]
-        }
+    public void ExtendedIntrinsic()
+    {
+        Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
+        Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-        [Benchmark]
+        SimdUtils.ExtendedIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
-        public void UseHwIntrinsics()
+    }
-        {
-            Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
-            Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-            SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
+    [Benchmark]
-        }
+    public void UseHwIntrinsics()
+    {
+        Span<float> sBytes = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
+        Span<byte> dFloats = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-        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 };
+        SimdUtils.HwIntrinsics.NormalizedFloatToByteSaturate(sBytes, dFloats);
+    }
 
-        [Benchmark]
+    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 };
-        public void UseAvx2_Grouped()
-        {
-            Span<float> src = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
-            Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-            int n = dest.Length / Vector<byte>.Count;
+    [Benchmark]
+    public void UseAvx2_Grouped()
+    {
+        Span<float> src = MemoryMarshal.Cast<Vector4, float>(this.source.GetSpan());
+        Span<byte> dest = MemoryMarshal.Cast<Rgba32, byte>(this.destination.GetSpan());
 
-            ref Vector256<float> sourceBase =
+        int n = dest.Length / Vector<byte>.Count;
-                ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(src));
-            ref Vector256<byte> destBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest));
 
-            ref byte maskBase = ref MemoryMarshal.GetReference(PermuteMaskDeinterleave8x32);
+        ref Vector256<float> sourceBase =
-            Vector256<int> mask = Unsafe.As<byte, Vector256<int>>(ref maskBase);
+            ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(src));
+        ref Vector256<byte> destBase = ref Unsafe.As<byte, Vector256<byte>>(ref MemoryMarshal.GetReference(dest));
 
-            var maxBytes = Vector256.Create(255f);
+        ref byte maskBase = ref MemoryMarshal.GetReference(PermuteMaskDeinterleave8x32);
+        Vector256<int> mask = Unsafe.As<byte, Vector256<int>>(ref maskBase);
 
-            for (int i = 0; i < n; i++)
+        var maxBytes = Vector256.Create(255f);
-            {
-                ref Vector256<float> s = ref Unsafe.Add(ref sourceBase, i * 4);
 
-                Vector256<float> f0 = s;
+        for (int i = 0; i < n; i++)
-                Vector256<float> f1 = Unsafe.Add(ref s, 1);
+        {
-                Vector256<float> f2 = Unsafe.Add(ref s, 2);
+            ref Vector256<float> s = ref Unsafe.Add(ref sourceBase, i * 4);
-                Vector256<float> f3 = Unsafe.Add(ref s, 3);
 
-                f0 = Avx.Multiply(maxBytes, f0);
+            Vector256<float> f0 = s;
-                f1 = Avx.Multiply(maxBytes, f1);
+            Vector256<float> f1 = Unsafe.Add(ref s, 1);
-                f2 = Avx.Multiply(maxBytes, f2);
+            Vector256<float> f2 = Unsafe.Add(ref s, 2);
-                f3 = Avx.Multiply(maxBytes, f3);
+            Vector256<float> f3 = Unsafe.Add(ref s, 3);
 
-                Vector256<int> w0 = Avx.ConvertToVector256Int32(f0);
+            f0 = Avx.Multiply(maxBytes, f0);
-                Vector256<int> w1 = Avx.ConvertToVector256Int32(f1);
+            f1 = Avx.Multiply(maxBytes, f1);
-                Vector256<int> w2 = Avx.ConvertToVector256Int32(f2);
+            f2 = Avx.Multiply(maxBytes, f2);
-                Vector256<int> w3 = Avx.ConvertToVector256Int32(f3);
+            f3 = Avx.Multiply(maxBytes, f3);
 
-                Vector256<short> u0 = Avx2.PackSignedSaturate(w0, w1);
+            Vector256<int> w0 = Avx.ConvertToVector256Int32(f0);
-                Vector256<short> u1 = Avx2.PackSignedSaturate(w2, w3);
+            Vector256<int> w1 = Avx.ConvertToVector256Int32(f1);
-                Vector256<byte> b = Avx2.PackUnsignedSaturate(u0, u1);
+            Vector256<int> w2 = Avx.ConvertToVector256Int32(f2);
-                b = Avx2.PermuteVar8x32(b.AsInt32(), mask).AsByte();
+            Vector256<int> w3 = Avx.ConvertToVector256Int32(f3);
 
-                Unsafe.Add(ref destBase, i) = b;
+            Vector256<short> u0 = Avx2.PackSignedSaturate(w0, w1);
-            }
+            Vector256<short> u1 = Avx2.PackSignedSaturate(w2, w3);
-        }
+            Vector256<byte> b = Avx2.PackUnsignedSaturate(u0, u1);
+            b = Avx2.PermuteVar8x32(b.AsInt32(), mask).AsByte();
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            Unsafe.Add(ref destBase, i) = b;
-        private static Vector256<int> ConvertToInt32(Vector256<float> vf, Vector256<float> scale)
-        {
-            vf = Avx.Multiply(scale, vf);
-            return Avx.ConvertToVector256Int32(vf);
         }
+    }
 
-        // *** RESULTS 2020 March: ***
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+    private static Vector256<int> ConvertToInt32(Vector256<float> vf, Vector256<float> scale)
-        // .NET Core SDK=3.1.200-preview-014971
+    {
-        //   Job-IUZXZT : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
+        vf = Avx.Multiply(scale, vf);
-        //
+        return Avx.ConvertToVector256Int32(vf);
-        // |                      Method | Count |       Mean |       Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-        // |---------------------------- |------ |-----------:|------------:|----------:|------:|--------:|------:|------:|------:|----------:|
-        // |       FallbackIntrinsics128 |  1024 | 2,952.6 ns | 1,680.77 ns |  92.13 ns |  3.32 |    0.16 |     - |     - |     - |         - |
-        // |          BasicIntrinsics256 |  1024 | 1,664.5 ns |   928.11 ns |  50.87 ns |  1.87 |    0.09 |     - |     - |     - |         - |
-        // |           ExtendedIntrinsic |  1024 |   890.6 ns |   375.48 ns |  20.58 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |                     UseAvx2 |  1024 |   299.0 ns |    30.47 ns |   1.67 ns |  0.34 |    0.01 |     - |     - |     - |         - |
-        // |             UseAvx2_Grouped |  1024 |   318.1 ns |    48.19 ns |   2.64 ns |  0.36 |    0.01 |     - |     - |     - |         - |
-        // |        PixelOperations_Base |  1024 | 8,136.9 ns | 1,834.82 ns | 100.57 ns |  9.14 |    0.26 |     - |     - |     - |      24 B |
-        // | PixelOperations_Specialized |  1024 |   951.1 ns |   123.93 ns |   6.79 ns |  1.07 |    0.03 |     - |     - |     - |         - |
     }
+
+    // *** RESULTS 2020 March: ***
+    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+    // .NET Core SDK=3.1.200-preview-014971
+    //   Job-IUZXZT : .NET Core 3.1.2 (CoreCLR 4.700.20.6602, CoreFX 4.700.20.6702), X64 RyuJIT
+    //
+    // |                      Method | Count |       Mean |       Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+    // |---------------------------- |------ |-----------:|------------:|----------:|------:|--------:|------:|------:|------:|----------:|
+    // |       FallbackIntrinsics128 |  1024 | 2,952.6 ns | 1,680.77 ns |  92.13 ns |  3.32 |    0.16 |     - |     - |     - |         - |
+    // |          BasicIntrinsics256 |  1024 | 1,664.5 ns |   928.11 ns |  50.87 ns |  1.87 |    0.09 |     - |     - |     - |         - |
+    // |           ExtendedIntrinsic |  1024 |   890.6 ns |   375.48 ns |  20.58 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |                     UseAvx2 |  1024 |   299.0 ns |    30.47 ns |   1.67 ns |  0.34 |    0.01 |     - |     - |     - |         - |
+    // |             UseAvx2_Grouped |  1024 |   318.1 ns |    48.19 ns |   2.64 ns |  0.36 |    0.01 |     - |     - |     - |         - |
+    // |        PixelOperations_Base |  1024 | 8,136.9 ns | 1,834.82 ns | 100.57 ns |  9.14 |    0.26 |     - |     - |     - |      24 B |
+    // | PixelOperations_Specialized |  1024 |   951.1 ns |   123.93 ns |   6.79 ns |  1.07 |    0.03 |     - |     - |     - |         - |
 }

tests/ImageSharp.Benchmarks/Color/Bulk/FromVector4_Rgb24.cs

@@ -4,12 +4,11 @@
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class FromVector4_Rgb24 : FromVector4<Rgb24>
 {
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class FromVector4_Rgb24 : FromVector4<Rgb24>
-    {
-    }
 }
 
 // 2020-11-02

tests/ImageSharp.Benchmarks/Color/Bulk/Pad3Shuffle4Channel.cs

@@ -1,87 +1,85 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
-    public class Pad3Shuffle4Channel
-    {
-        private static readonly DefaultPad3Shuffle4 Control = new DefaultPad3Shuffle4(1, 0, 3, 2);
-        private static readonly XYZWPad3Shuffle4 ControlFast = default;
-        private byte[] source;
-        private byte[] destination;
 
-        [GlobalSetup]
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
-        public void Setup()
+public class Pad3Shuffle4Channel
-        {
+{
-            this.source = new byte[this.Count];
+    private static readonly DefaultPad3Shuffle4 Control = new DefaultPad3Shuffle4(1, 0, 3, 2);
-            new Random(this.Count).NextBytes(this.source);
+    private static readonly XYZWPad3Shuffle4 ControlFast = default;
-            this.destination = new byte[this.Count * 4 / 3];
+    private byte[] source;
-        }
+    private byte[] destination;
 
-        [Params(96, 384, 768, 1536)]
+    [GlobalSetup]
-        public int Count { get; set; }
+    public void Setup()
+    {
+        this.source = new byte[this.Count];
+        new Random(this.Count).NextBytes(this.source);
+        this.destination = new byte[this.Count * 4 / 3];
+    }
 
-        [Benchmark]
+    [Params(96, 384, 768, 1536)]
-        public void Pad3Shuffle4()
+    public int Count { get; set; }
-        {
-            SimdUtils.Pad3Shuffle4(this.source, this.destination, Control);
-        }
 
-        [Benchmark]
+    [Benchmark]
-        public void Pad3Shuffle4FastFallback()
+    public void Pad3Shuffle4()
-        {
+    {
-            SimdUtils.Pad3Shuffle4(this.source, this.destination, ControlFast);
+        SimdUtils.Pad3Shuffle4(this.source, this.destination, Control);
-        }
     }
 
-    // 2020-10-30
+    [Benchmark]
-    // ##########
+    public void Pad3Shuffle4FastFallback()
-    //
+    {
-    // BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+        SimdUtils.Pad3Shuffle4(this.source, this.destination, ControlFast);
-    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+    }
-    // .NET Core SDK=3.1.403
-    //  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //
-    // Runtime=.NET Core 3.1
-    //
-    // |                   Method |                Job |                              EnvironmentVariables | Count |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    // |------------------------- |------------------- |-------------------------------------------------- |------ |------------:|----------:|----------:|------------:|------:|--------:|------:|------:|------:|----------:|
-    // |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |   120.64 ns |  7.190 ns | 21.200 ns |   114.26 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             2. AVX |                                             Empty |    96 |    23.63 ns |  0.175 ns |  0.155 ns |    23.65 ns |  0.15 |    0.01 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |    25.25 ns |  0.356 ns |  0.298 ns |    25.27 ns |  0.17 |    0.01 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |    14.80 ns |  0.358 ns |  1.032 ns |    14.64 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |    96 |    24.84 ns |  0.376 ns |  0.333 ns |    24.74 ns |  1.57 |    0.06 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |    24.58 ns |  0.471 ns |  0.704 ns |    24.38 ns |  1.60 |    0.09 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 |   258.92 ns |  4.873 ns |  4.069 ns |   257.95 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             2. AVX |                                             Empty |   384 |    41.41 ns |  0.859 ns |  1.204 ns |    41.33 ns |  0.16 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |    40.74 ns |  0.848 ns |  0.793 ns |    40.48 ns |  0.16 |    0.00 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 |    74.50 ns |  0.490 ns |  0.383 ns |    74.49 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |   384 |    40.74 ns |  0.624 ns |  0.584 ns |    40.72 ns |  0.55 |    0.01 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |    38.28 ns |  0.534 ns |  0.417 ns |    38.22 ns |  0.51 |    0.01 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 |   503.91 ns |  6.466 ns |  6.048 ns |   501.58 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             2. AVX |                                             Empty |   768 |    62.86 ns |  0.332 ns |  0.277 ns |    62.80 ns |  0.12 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |   768 |    64.59 ns |  0.469 ns |  0.415 ns |    64.62 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 |   110.51 ns |  0.592 ns |  0.554 ns |   110.33 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |   768 |    64.72 ns |  1.306 ns |  1.090 ns |    64.51 ns |  0.59 |    0.01 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   768 |    62.11 ns |  0.816 ns |  0.682 ns |    61.98 ns |  0.56 |    0.01 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 | 1,005.84 ns | 13.176 ns | 12.325 ns | 1,004.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             2. AVX |                                             Empty |  1536 |   110.05 ns |  0.256 ns |  0.214 ns |   110.04 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-    // |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 |   110.23 ns |  0.545 ns |  0.483 ns |   110.09 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-    // |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
-    // | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 |   220.37 ns |  1.601 ns |  1.419 ns |   220.13 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |  1536 |   111.54 ns |  2.173 ns |  2.901 ns |   111.27 ns |  0.51 |    0.01 |     - |     - |     - |         - |
-    // | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 |   110.23 ns |  0.456 ns |  0.427 ns |   110.25 ns |  0.50 |    0.00 |     - |     - |     - |         - |
 }
+
+// 2020-10-30
+// ##########
+//
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// .NET Core SDK=3.1.403
+//  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//
+// Runtime=.NET Core 3.1
+//
+// |                   Method |                Job |                              EnvironmentVariables | Count |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |------------------------- |------------------- |-------------------------------------------------- |------ |------------:|----------:|----------:|------------:|------:|--------:|------:|------:|------:|----------:|
+// |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |   120.64 ns |  7.190 ns | 21.200 ns |   114.26 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             2. AVX |                                             Empty |    96 |    23.63 ns |  0.175 ns |  0.155 ns |    23.65 ns |  0.15 |    0.01 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |    25.25 ns |  0.356 ns |  0.298 ns |    25.27 ns |  0.17 |    0.01 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |    14.80 ns |  0.358 ns |  1.032 ns |    14.64 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |    96 |    24.84 ns |  0.376 ns |  0.333 ns |    24.74 ns |  1.57 |    0.06 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |    24.58 ns |  0.471 ns |  0.704 ns |    24.38 ns |  1.60 |    0.09 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 |   258.92 ns |  4.873 ns |  4.069 ns |   257.95 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             2. AVX |                                             Empty |   384 |    41.41 ns |  0.859 ns |  1.204 ns |    41.33 ns |  0.16 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |    40.74 ns |  0.848 ns |  0.793 ns |    40.48 ns |  0.16 |    0.00 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 |    74.50 ns |  0.490 ns |  0.383 ns |    74.49 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |   384 |    40.74 ns |  0.624 ns |  0.584 ns |    40.72 ns |  0.55 |    0.01 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |    38.28 ns |  0.534 ns |  0.417 ns |    38.22 ns |  0.51 |    0.01 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 |   503.91 ns |  6.466 ns |  6.048 ns |   501.58 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             2. AVX |                                             Empty |   768 |    62.86 ns |  0.332 ns |  0.277 ns |    62.80 ns |  0.12 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |   768 |    64.59 ns |  0.469 ns |  0.415 ns |    64.62 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 |   110.51 ns |  0.592 ns |  0.554 ns |   110.33 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |   768 |    64.72 ns |  1.306 ns |  1.090 ns |    64.51 ns |  0.59 |    0.01 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   768 |    62.11 ns |  0.816 ns |  0.682 ns |    61.98 ns |  0.56 |    0.01 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// |             Pad3Shuffle4 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 | 1,005.84 ns | 13.176 ns | 12.325 ns | 1,004.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             2. AVX |                                             Empty |  1536 |   110.05 ns |  0.256 ns |  0.214 ns |   110.04 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+// |             Pad3Shuffle4 |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 |   110.23 ns |  0.545 ns |  0.483 ns |   110.09 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+// |                          |                    |                                                   |       |             |           |           |             |       |         |       |       |       |           |
+// | Pad3Shuffle4FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 |   220.37 ns |  1.601 ns |  1.419 ns |   220.13 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             2. AVX |                                             Empty |  1536 |   111.54 ns |  2.173 ns |  2.901 ns |   111.27 ns |  0.51 |    0.01 |     - |     - |     - |         - |
+// | Pad3Shuffle4FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 |   110.23 ns |  0.456 ns |  0.427 ns |   110.25 ns |  0.50 |    0.00 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/Color/Bulk/PremultiplyVector4.cs

@@ -1,68 +1,66 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    [Config(typeof(Config.ShortCore31))]
-    public class PremultiplyVector4
-    {
-        private static readonly Vector4[] Vectors = CreateVectors();
 
-        [Benchmark(Baseline = true)]
+[Config(typeof(Config.ShortCore31))]
-        public void PremultiplyBaseline()
+public class PremultiplyVector4
-        {
+{
-            ref Vector4 baseRef = ref MemoryMarshal.GetReference<Vector4>(Vectors);
+    private static readonly Vector4[] Vectors = CreateVectors();
 
-            for (int i = 0; i < Vectors.Length; i++)
+    [Benchmark(Baseline = true)]
-            {
+    public void PremultiplyBaseline()
-                ref Vector4 v = ref Unsafe.Add(ref baseRef, i);
+    {
-                Premultiply(ref v);
+        ref Vector4 baseRef = ref MemoryMarshal.GetReference<Vector4>(Vectors);
-            }
-        }
 
-        [Benchmark]
+        for (int i = 0; i < Vectors.Length; i++)
-        public void Premultiply()
         {
-            Numerics.Premultiply(Vectors);
+            ref Vector4 v = ref Unsafe.Add(ref baseRef, i);
+            Premultiply(ref v);
         }
+    }
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+    [Benchmark]
-        private static void Premultiply(ref Vector4 source)
+    public void Premultiply()
-        {
+    {
-            float w = source.W;
+        Numerics.Premultiply(Vectors);
-            source *= w;
+    }
-            source.W = w;
-        }
 
-        private static Vector4[] CreateVectors()
+    [MethodImpl(InliningOptions.ShortMethod)]
-        {
+    private static void Premultiply(ref Vector4 source)
-            var rnd = new Random(42);
+    {
-            return GenerateRandomVectorArray(rnd, 2048, 0, 1);
+        float w = source.W;
-        }
+        source *= w;
+        source.W = w;
+    }
 
-        private static Vector4[] GenerateRandomVectorArray(Random rnd, int length, float minVal, float maxVal)
+    private static Vector4[] CreateVectors()
-        {
+    {
-            var values = new Vector4[length];
+        var rnd = new Random(42);
+        return GenerateRandomVectorArray(rnd, 2048, 0, 1);
+    }
 
-            for (int i = 0; i < length; i++)
+    private static Vector4[] GenerateRandomVectorArray(Random rnd, int length, float minVal, float maxVal)
-            {
+    {
-                ref Vector4 v = ref values[i];
+        var values = new Vector4[length];
-                v.X = GetRandomFloat(rnd, minVal, maxVal);
-                v.Y = GetRandomFloat(rnd, minVal, maxVal);
-                v.Z = GetRandomFloat(rnd, minVal, maxVal);
-                v.W = GetRandomFloat(rnd, minVal, maxVal);
-            }
 
-            return values;
+        for (int i = 0; i < length; i++)
+        {
+            ref Vector4 v = ref values[i];
+            v.X = GetRandomFloat(rnd, minVal, maxVal);
+            v.Y = GetRandomFloat(rnd, minVal, maxVal);
+            v.Z = GetRandomFloat(rnd, minVal, maxVal);
+            v.W = GetRandomFloat(rnd, minVal, maxVal);
         }
 
-        private static float GetRandomFloat(Random rnd, float minVal, float maxVal)
+        return values;
-            => ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
     }
+
+    private static float GetRandomFloat(Random rnd, float minVal, float maxVal)
+        => ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
 }

tests/ImageSharp.Benchmarks/Color/Bulk/Rgb24Bytes.cs

@@ -7,53 +7,52 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+public abstract class Rgb24Bytes<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
 {
-    public abstract class Rgb24Bytes<TPixel>
+    private IMemoryOwner<TPixel> source;
-        where TPixel : unmanaged, IPixel<TPixel>
+
+    private IMemoryOwner<byte> destination;
+
+    private Configuration configuration;
+
+    [Params(16, 128, 1024)]
+    public int Count { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
     {
-        private IMemoryOwner<TPixel> source;
+        this.configuration = Configuration.Default;
-
+        this.source = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-        private IMemoryOwner<byte> destination;
+        this.destination = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 3);
-
-        private Configuration configuration;
-
-        [Params(16, 128, 1024)]
-        public int Count { get; set; }
-
-        [GlobalSetup]
-        public void Setup()
-        {
-            this.configuration = Configuration.Default;
-            this.source = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.destination = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 3);
-        }
-
-        [GlobalCleanup]
-        public void Cleanup()
-        {
-            this.source.Dispose();
-            this.destination.Dispose();
-        }
-
-        [Benchmark(Baseline = true)]
-        public void CommonBulk() =>
-            new PixelOperations<TPixel>().ToRgb24Bytes(
-                this.configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan(),
-                this.Count);
-
-        [Benchmark]
-        public void OptimizedBulk() =>
-            PixelOperations<TPixel>.Instance.ToRgb24Bytes(
-                this.configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan(),
-                this.Count);
     }
 
-    public class Rgb24Bytes_Rgba32 : Rgb24Bytes<Rgba32>
+    [GlobalCleanup]
+    public void Cleanup()
     {
+        this.source.Dispose();
+        this.destination.Dispose();
     }
+
+    [Benchmark(Baseline = true)]
+    public void CommonBulk() =>
+        new PixelOperations<TPixel>().ToRgb24Bytes(
+            this.configuration,
+            this.source.GetSpan(),
+            this.destination.GetSpan(),
+            this.Count);
+
+    [Benchmark]
+    public void OptimizedBulk() =>
+        PixelOperations<TPixel>.Instance.ToRgb24Bytes(
+            this.configuration,
+            this.source.GetSpan(),
+            this.destination.GetSpan(),
+            this.Count);
+}
+
+public class Rgb24Bytes_Rgba32 : Rgb24Bytes<Rgba32>
+{
 }

tests/ImageSharp.Benchmarks/Color/Bulk/Shuffle3Channel.cs

@@ -1,64 +1,62 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class Shuffle3Channel
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private static readonly DefaultShuffle3 Control = new DefaultShuffle3(1, 0, 2);
-    public class Shuffle3Channel
+    private byte[] source;
-    {
+    private byte[] destination;
-        private static readonly DefaultShuffle3 Control = new DefaultShuffle3(1, 0, 2);
-        private byte[] source;
-        private byte[] destination;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.source = new byte[this.Count];
+        this.source = new byte[this.Count];
-            new Random(this.Count).NextBytes(this.source);
+        new Random(this.Count).NextBytes(this.source);
-            this.destination = new byte[this.Count];
+        this.destination = new byte[this.Count];
-        }
+    }
 
-        [Params(96, 384, 768, 1536)]
+    [Params(96, 384, 768, 1536)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [Benchmark]
+    [Benchmark]
-        public void Shuffle3()
+    public void Shuffle3()
-        {
+    {
-            SimdUtils.Shuffle3(this.source, this.destination, Control);
+        SimdUtils.Shuffle3(this.source, this.destination, Control);
-        }
     }
-
-    // 2020-11-02
-    // ##########
-    //
-    // BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
-    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-    // .NET Core SDK=3.1.403
-    //  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //
-    // Runtime=.NET Core 3.1
-    //
-    // |               Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev |    Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    // |--------------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|----------:|------:|--------:|------:|------:|------:|----------:|
-    // |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |  48.46 ns | 1.034 ns | 2.438 ns |  47.46 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle3 |             2. AVX |                                             Empty |    96 |  32.42 ns | 0.537 ns | 0.476 ns |  32.34 ns |  0.66 |    0.04 |     - |     - |     - |         - |
-    // |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |  32.51 ns | 0.373 ns | 0.349 ns |  32.56 ns |  0.66 |    0.03 |     - |     - |     - |         - |
-    // |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 | 199.04 ns | 1.512 ns | 1.180 ns | 199.17 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle3 |             2. AVX |                                             Empty |   384 |  71.20 ns | 2.654 ns | 7.784 ns |  69.60 ns |  0.41 |    0.02 |     - |     - |     - |         - |
-    // |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |  63.23 ns | 0.569 ns | 0.505 ns |  63.21 ns |  0.32 |    0.00 |     - |     - |     - |         - |
-    // |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 | 391.28 ns | 5.087 ns | 3.972 ns | 391.22 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle3 |             2. AVX |                                             Empty |   768 | 109.12 ns | 2.149 ns | 2.010 ns | 108.66 ns |  0.28 |    0.01 |     - |     - |     - |         - |
-    // |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |   768 | 106.51 ns | 0.734 ns | 0.613 ns | 106.56 ns |  0.27 |    0.00 |     - |     - |     - |         - |
-    // |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 | 773.70 ns | 5.516 ns | 4.890 ns | 772.96 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle3 |             2. AVX |                                             Empty |  1536 | 190.41 ns | 1.090 ns | 0.851 ns | 190.38 ns |  0.25 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 | 190.94 ns | 0.985 ns | 0.769 ns | 190.85 ns |  0.25 |    0.00 |     - |     - |     - |         - |
 }
+
+// 2020-11-02
+// ##########
+//
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// .NET Core SDK=3.1.403
+//  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//
+// Runtime=.NET Core 3.1
+//
+// |               Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev |    Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |--------------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|----------:|------:|--------:|------:|------:|------:|----------:|
+// |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |    96 |  48.46 ns | 1.034 ns | 2.438 ns |  47.46 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle3 |             2. AVX |                                             Empty |    96 |  32.42 ns | 0.537 ns | 0.476 ns |  32.34 ns |  0.66 |    0.04 |     - |     - |     - |         - |
+// |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |    96 |  32.51 ns | 0.373 ns | 0.349 ns |  32.56 ns |  0.66 |    0.03 |     - |     - |     - |         - |
+// |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   384 | 199.04 ns | 1.512 ns | 1.180 ns | 199.17 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle3 |             2. AVX |                                             Empty |   384 |  71.20 ns | 2.654 ns | 7.784 ns |  69.60 ns |  0.41 |    0.02 |     - |     - |     - |         - |
+// |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |   384 |  63.23 ns | 0.569 ns | 0.505 ns |  63.21 ns |  0.32 |    0.00 |     - |     - |     - |         - |
+// |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   768 | 391.28 ns | 5.087 ns | 3.972 ns | 391.22 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle3 |             2. AVX |                                             Empty |   768 | 109.12 ns | 2.149 ns | 2.010 ns | 108.66 ns |  0.28 |    0.01 |     - |     - |     - |         - |
+// |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |   768 | 106.51 ns | 0.734 ns | 0.613 ns | 106.56 ns |  0.27 |    0.00 |     - |     - |     - |         - |
+// |                      |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1536 | 773.70 ns | 5.516 ns | 4.890 ns | 772.96 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle3 |             2. AVX |                                             Empty |  1536 | 190.41 ns | 1.090 ns | 0.851 ns | 190.38 ns |  0.25 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle3 |             3. SSE |                               COMPlus_EnableAVX=0 |  1536 | 190.94 ns | 0.985 ns | 0.769 ns | 190.85 ns |  0.25 |    0.00 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/Color/Bulk/Shuffle4Slice3Channel.cs

@@ -1,95 +1,93 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
-    public class Shuffle4Slice3Channel
-    {
-        private static readonly DefaultShuffle4Slice3 Control = new DefaultShuffle4Slice3(1, 0, 3, 2);
-        private static readonly XYZWShuffle4Slice3 ControlFast = default;
-        private byte[] source;
-        private byte[] destination;
 
-        [GlobalSetup]
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
-        public void Setup()
+public class Shuffle4Slice3Channel
-        {
+{
-            this.source = new byte[this.Count];
+    private static readonly DefaultShuffle4Slice3 Control = new DefaultShuffle4Slice3(1, 0, 3, 2);
-            new Random(this.Count).NextBytes(this.source);
+    private static readonly XYZWShuffle4Slice3 ControlFast = default;
-            this.destination = new byte[(int)(this.Count * (3 / 4F))];
+    private byte[] source;
-        }
+    private byte[] destination;
 
-        [Params(128, 256, 512, 1024, 2048)]
+    [GlobalSetup]
-        public int Count { get; set; }
+    public void Setup()
+    {
+        this.source = new byte[this.Count];
+        new Random(this.Count).NextBytes(this.source);
+        this.destination = new byte[(int)(this.Count * (3 / 4F))];
+    }
 
-        [Benchmark]
+    [Params(128, 256, 512, 1024, 2048)]
-        public void Shuffle4Slice3()
+    public int Count { get; set; }
-        {
-            SimdUtils.Shuffle4Slice3(this.source, this.destination, Control);
-        }
 
-        [Benchmark]
+    [Benchmark]
-        public void Shuffle4Slice3FastFallback()
+    public void Shuffle4Slice3()
-        {
+    {
-            SimdUtils.Shuffle4Slice3(this.source, this.destination, ControlFast);
+        SimdUtils.Shuffle4Slice3(this.source, this.destination, Control);
-        }
     }
 
-    // 2020-10-29
+    [Benchmark]
-    // ##########
+    public void Shuffle4Slice3FastFallback()
-    //
+    {
-    // BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+        SimdUtils.Shuffle4Slice3(this.source, this.destination, ControlFast);
-    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+    }
-    // .NET Core SDK=3.1.403
-    //  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //
-    // Runtime=.NET Core 3.1
-    //
-    // |                     Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev |    Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    // |--------------------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|----------:|------:|--------:|------:|------:|------:|----------:|
-    // |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  56.44 ns | 2.843 ns | 8.382 ns |  56.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             2. AVX |                                             Empty |   128 |  27.15 ns | 0.556 ns | 0.762 ns |  27.34 ns |  0.41 |    0.03 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  26.36 ns | 0.321 ns | 0.268 ns |  26.26 ns |  0.38 |    0.02 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  25.85 ns | 0.494 ns | 0.462 ns |  25.84 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   128 |  26.15 ns | 0.113 ns | 0.106 ns |  26.16 ns |  1.01 |    0.02 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  25.57 ns | 0.078 ns | 0.061 ns |  25.56 ns |  0.99 |    0.02 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  97.47 ns | 0.327 ns | 0.289 ns |  97.35 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             2. AVX |                                             Empty |   256 |  32.61 ns | 0.107 ns | 0.095 ns |  32.62 ns |  0.33 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  33.21 ns | 0.169 ns | 0.150 ns |  33.15 ns |  0.34 |    0.00 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  52.34 ns | 0.779 ns | 0.729 ns |  51.94 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   256 |  32.16 ns | 0.111 ns | 0.104 ns |  32.16 ns |  0.61 |    0.01 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  33.61 ns | 0.342 ns | 0.319 ns |  33.62 ns |  0.64 |    0.01 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 210.74 ns | 3.825 ns | 5.956 ns | 207.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             2. AVX |                                             Empty |   512 |  51.03 ns | 0.535 ns | 0.501 ns |  51.18 ns |  0.24 |    0.01 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  66.60 ns | 1.313 ns | 1.613 ns |  65.93 ns |  0.31 |    0.01 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 119.12 ns | 1.905 ns | 1.689 ns | 118.52 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   512 |  50.33 ns | 0.382 ns | 0.339 ns |  50.41 ns |  0.42 |    0.01 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  49.25 ns | 0.555 ns | 0.492 ns |  49.26 ns |  0.41 |    0.01 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 423.55 ns | 4.891 ns | 4.336 ns | 423.27 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             2. AVX |                                             Empty |  1024 |  77.13 ns | 1.355 ns | 2.264 ns |  76.19 ns |  0.19 |    0.01 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  79.39 ns | 0.103 ns | 0.086 ns |  79.37 ns |  0.19 |    0.00 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 226.57 ns | 2.930 ns | 2.598 ns | 226.10 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |  1024 |  80.25 ns | 1.647 ns | 2.082 ns |  80.98 ns |  0.35 |    0.01 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  84.99 ns | 1.234 ns | 1.155 ns |  85.60 ns |  0.38 |    0.01 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 794.96 ns | 1.735 ns | 1.538 ns | 795.15 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             2. AVX |                                             Empty |  2048 | 128.41 ns | 0.417 ns | 0.390 ns | 128.24 ns |  0.16 |    0.00 |     - |     - |     - |         - |
-    // |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 127.24 ns | 0.294 ns | 0.229 ns | 127.23 ns |  0.16 |    0.00 |     - |     - |     - |         - |
-    // |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
-    // | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 382.97 ns | 1.064 ns | 0.831 ns | 382.87 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |  2048 | 126.93 ns | 0.382 ns | 0.339 ns | 126.94 ns |  0.33 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 149.36 ns | 1.875 ns | 1.754 ns | 149.33 ns |  0.39 |    0.00 |     - |     - |     - |         - |
 }
+
+// 2020-10-29
+// ##########
+//
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// .NET Core SDK=3.1.403
+//  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//
+// Runtime=.NET Core 3.1
+//
+// |                     Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev |    Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |--------------------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|----------:|------:|--------:|------:|------:|------:|----------:|
+// |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  56.44 ns | 2.843 ns | 8.382 ns |  56.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             2. AVX |                                             Empty |   128 |  27.15 ns | 0.556 ns | 0.762 ns |  27.34 ns |  0.41 |    0.03 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  26.36 ns | 0.321 ns | 0.268 ns |  26.26 ns |  0.38 |    0.02 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  25.85 ns | 0.494 ns | 0.462 ns |  25.84 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   128 |  26.15 ns | 0.113 ns | 0.106 ns |  26.16 ns |  1.01 |    0.02 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  25.57 ns | 0.078 ns | 0.061 ns |  25.56 ns |  0.99 |    0.02 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  97.47 ns | 0.327 ns | 0.289 ns |  97.35 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             2. AVX |                                             Empty |   256 |  32.61 ns | 0.107 ns | 0.095 ns |  32.62 ns |  0.33 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  33.21 ns | 0.169 ns | 0.150 ns |  33.15 ns |  0.34 |    0.00 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  52.34 ns | 0.779 ns | 0.729 ns |  51.94 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   256 |  32.16 ns | 0.111 ns | 0.104 ns |  32.16 ns |  0.61 |    0.01 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  33.61 ns | 0.342 ns | 0.319 ns |  33.62 ns |  0.64 |    0.01 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 210.74 ns | 3.825 ns | 5.956 ns | 207.70 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             2. AVX |                                             Empty |   512 |  51.03 ns | 0.535 ns | 0.501 ns |  51.18 ns |  0.24 |    0.01 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  66.60 ns | 1.313 ns | 1.613 ns |  65.93 ns |  0.31 |    0.01 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 119.12 ns | 1.905 ns | 1.689 ns | 118.52 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |   512 |  50.33 ns | 0.382 ns | 0.339 ns |  50.41 ns |  0.42 |    0.01 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  49.25 ns | 0.555 ns | 0.492 ns |  49.26 ns |  0.41 |    0.01 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 423.55 ns | 4.891 ns | 4.336 ns | 423.27 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             2. AVX |                                             Empty |  1024 |  77.13 ns | 1.355 ns | 2.264 ns |  76.19 ns |  0.19 |    0.01 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  79.39 ns | 0.103 ns | 0.086 ns |  79.37 ns |  0.19 |    0.00 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 226.57 ns | 2.930 ns | 2.598 ns | 226.10 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |  1024 |  80.25 ns | 1.647 ns | 2.082 ns |  80.98 ns |  0.35 |    0.01 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  84.99 ns | 1.234 ns | 1.155 ns |  85.60 ns |  0.38 |    0.01 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// |             Shuffle4Slice3 | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 794.96 ns | 1.735 ns | 1.538 ns | 795.15 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             2. AVX |                                             Empty |  2048 | 128.41 ns | 0.417 ns | 0.390 ns | 128.24 ns |  0.16 |    0.00 |     - |     - |     - |         - |
+// |             Shuffle4Slice3 |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 127.24 ns | 0.294 ns | 0.229 ns | 127.23 ns |  0.16 |    0.00 |     - |     - |     - |         - |
+// |                            |                    |                                                   |       |           |          |          |           |       |         |       |       |       |           |
+// | Shuffle4Slice3FastFallback | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 382.97 ns | 1.064 ns | 0.831 ns | 382.87 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             2. AVX |                                             Empty |  2048 | 126.93 ns | 0.382 ns | 0.339 ns | 126.94 ns |  0.33 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Slice3FastFallback |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 149.36 ns | 1.875 ns | 1.754 ns | 149.33 ns |  0.39 |    0.00 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleByte4Channel.cs

@@ -1,67 +1,65 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class ShuffleByte4Channel
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private byte[] source;
-    public class ShuffleByte4Channel
+    private byte[] destination;
-    {
-        private byte[] source;
-        private byte[] destination;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.source = new byte[this.Count];
+        this.source = new byte[this.Count];
-            new Random(this.Count).NextBytes(this.source);
+        new Random(this.Count).NextBytes(this.source);
-            this.destination = new byte[this.Count];
+        this.destination = new byte[this.Count];
-        }
+    }
 
-        [Params(128, 256, 512, 1024, 2048)]
+    [Params(128, 256, 512, 1024, 2048)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [Benchmark]
+    [Benchmark]
-        public void Shuffle4Channel()
+    public void Shuffle4Channel()
-        {
+    {
-            SimdUtils.Shuffle4<WXYZShuffle4>(this.source, this.destination, default);
+        SimdUtils.Shuffle4<WXYZShuffle4>(this.source, this.destination, default);
-        }
     }
-
-    // 2020-10-29
-    // ##########
-    //
-    // BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
-    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-    // .NET Core SDK=3.1.403
-    //  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //
-    // Runtime=.NET Core 3.1
-    //
-    // |          Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    // |---------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|------:|--------:|------:|------:|------:|----------:|
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  17.39 ns | 0.187 ns | 0.175 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   128 |  21.72 ns | 0.299 ns | 0.279 ns |  1.25 |    0.02 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  18.10 ns | 0.346 ns | 0.289 ns |  1.04 |    0.02 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  35.51 ns | 0.711 ns | 0.790 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   256 |  23.90 ns | 0.508 ns | 0.820 ns |  0.69 |    0.02 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  20.40 ns | 0.133 ns | 0.111 ns |  0.57 |    0.01 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 |  73.39 ns | 0.310 ns | 0.259 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   512 |  26.10 ns | 0.418 ns | 0.391 ns |  0.36 |    0.01 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  27.59 ns | 0.556 ns | 0.571 ns |  0.38 |    0.01 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 150.64 ns | 2.903 ns | 2.716 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |  1024 |  38.67 ns | 0.801 ns | 1.889 ns |  0.24 |    0.02 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  47.13 ns | 0.948 ns | 1.054 ns |  0.31 |    0.01 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 315.29 ns | 5.206 ns | 6.583 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |  2048 |  57.37 ns | 1.152 ns | 1.078 ns |  0.18 |    0.01 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 |  65.75 ns | 1.198 ns | 1.600 ns |  0.21 |    0.01 |     - |     - |     - |         - |
 }
+
+// 2020-10-29
+// ##########
+//
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// .NET Core SDK=3.1.403
+//  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//
+// Runtime=.NET Core 3.1
+//
+// |          Method |                Job |                              EnvironmentVariables | Count |      Mean |    Error |   StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |---------------- |------------------- |-------------------------------------------------- |------ |----------:|---------:|---------:|------:|--------:|------:|------:|------:|----------:|
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  17.39 ns | 0.187 ns | 0.175 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   128 |  21.72 ns | 0.299 ns | 0.279 ns |  1.25 |    0.02 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  18.10 ns | 0.346 ns | 0.289 ns |  1.04 |    0.02 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 |  35.51 ns | 0.711 ns | 0.790 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   256 |  23.90 ns | 0.508 ns | 0.820 ns |  0.69 |    0.02 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  20.40 ns | 0.133 ns | 0.111 ns |  0.57 |    0.01 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 |  73.39 ns | 0.310 ns | 0.259 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   512 |  26.10 ns | 0.418 ns | 0.391 ns |  0.36 |    0.01 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  27.59 ns | 0.556 ns | 0.571 ns |  0.38 |    0.01 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 150.64 ns | 2.903 ns | 2.716 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |  1024 |  38.67 ns | 0.801 ns | 1.889 ns |  0.24 |    0.02 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 |  47.13 ns | 0.948 ns | 1.054 ns |  0.31 |    0.01 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |           |          |          |       |         |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 315.29 ns | 5.206 ns | 6.583 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |  2048 |  57.37 ns | 1.152 ns | 1.078 ns |  0.18 |    0.01 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 |  65.75 ns | 1.198 ns | 1.600 ns |  0.21 |    0.01 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/Color/Bulk/ShuffleFloat4Channel.cs

@@ -1,68 +1,66 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Tests;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+public class ShuffleFloat4Channel
 {
-    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    private static readonly byte Control = default(WXYZShuffle4).Control;
-    public class ShuffleFloat4Channel
+    private float[] source;
-    {
+    private float[] destination;
-        private static readonly byte Control = default(WXYZShuffle4).Control;
-        private float[] source;
-        private float[] destination;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.source = new Random(this.Count).GenerateRandomFloatArray(this.Count, 0, 256);
+        this.source = new Random(this.Count).GenerateRandomFloatArray(this.Count, 0, 256);
-            this.destination = new float[this.Count];
+        this.destination = new float[this.Count];
-        }
+    }
 
-        [Params(128, 256, 512, 1024, 2048)]
+    [Params(128, 256, 512, 1024, 2048)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [Benchmark]
+    [Benchmark]
-        public void Shuffle4Channel()
+    public void Shuffle4Channel()
-        {
+    {
-            SimdUtils.Shuffle4(this.source, this.destination, Control);
+        SimdUtils.Shuffle4(this.source, this.destination, Control);
-        }
     }
-
-    // 2020-10-29
-    // ##########
-    //
-    // BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
-    // Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-    // .NET Core SDK=3.1.403
-    //  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
-    //
-    // Runtime=.NET Core 3.1
-    //
-    // |          Method |                Job |                              EnvironmentVariables | Count |       Mean |     Error |    StdDev | Ratio | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    // |---------------- |------------------- |-------------------------------------------------- |------ |-----------:|----------:|----------:|------:|------:|------:|------:|----------:|
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  63.647 ns | 0.5475 ns | 0.4853 ns |  1.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   128 |   9.818 ns | 0.1457 ns | 0.1292 ns |  0.15 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  15.267 ns | 0.1005 ns | 0.0940 ns |  0.24 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 | 125.586 ns | 1.9312 ns | 1.8064 ns |  1.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   256 |  15.878 ns | 0.1983 ns | 0.1758 ns |  0.13 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  29.170 ns | 0.2925 ns | 0.2442 ns |  0.23 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 263.859 ns | 2.6660 ns | 2.3634 ns |  1.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |   512 |  29.452 ns | 0.3334 ns | 0.3118 ns |  0.11 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  52.912 ns | 0.1932 ns | 0.1713 ns |  0.20 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 495.717 ns | 1.9850 ns | 1.8567 ns |  1.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |  1024 |  53.757 ns | 0.3212 ns | 0.2847 ns |  0.11 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 | 107.815 ns | 1.6201 ns | 1.3528 ns |  0.22 |     - |     - |     - |         - |
-    // |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
-    // | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 980.134 ns | 3.7407 ns | 3.1237 ns |  1.00 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             2. AVX |                                             Empty |  2048 | 105.120 ns | 0.6140 ns | 0.5443 ns |  0.11 |     - |     - |     - |         - |
-    // | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 216.473 ns | 2.3268 ns | 2.0627 ns |  0.22 |     - |     - |     - |         - |
 }
+
+// 2020-10-29
+// ##########
+//
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.572 (2004/?/20H1)
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// .NET Core SDK=3.1.403
+//  [Host]             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  1. No HwIntrinsics : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  2. AVX             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//  3. SSE             : .NET Core 3.1.9 (CoreCLR 4.700.20.47201, CoreFX 4.700.20.47203), X64 RyuJIT
+//
+// Runtime=.NET Core 3.1
+//
+// |          Method |                Job |                              EnvironmentVariables | Count |       Mean |     Error |    StdDev | Ratio | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |---------------- |------------------- |-------------------------------------------------- |------ |-----------:|----------:|----------:|------:|------:|------:|------:|----------:|
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   128 |  63.647 ns | 0.5475 ns | 0.4853 ns |  1.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   128 |   9.818 ns | 0.1457 ns | 0.1292 ns |  0.15 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   128 |  15.267 ns | 0.1005 ns | 0.0940 ns |  0.24 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   256 | 125.586 ns | 1.9312 ns | 1.8064 ns |  1.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   256 |  15.878 ns | 0.1983 ns | 0.1758 ns |  0.13 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   256 |  29.170 ns | 0.2925 ns | 0.2442 ns |  0.23 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |   512 | 263.859 ns | 2.6660 ns | 2.3634 ns |  1.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |   512 |  29.452 ns | 0.3334 ns | 0.3118 ns |  0.11 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |   512 |  52.912 ns | 0.1932 ns | 0.1713 ns |  0.20 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  1024 | 495.717 ns | 1.9850 ns | 1.8567 ns |  1.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |  1024 |  53.757 ns | 0.3212 ns | 0.2847 ns |  0.11 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  1024 | 107.815 ns | 1.6201 ns | 1.3528 ns |  0.22 |     - |     - |     - |         - |
+// |                 |                    |                                                   |       |            |           |           |       |       |       |       |           |
+// | Shuffle4Channel | 1. No HwIntrinsics | COMPlus_EnableHWIntrinsic=0,COMPlus_FeatureSIMD=0 |  2048 | 980.134 ns | 3.7407 ns | 3.1237 ns |  1.00 |     - |     - |     - |         - |
+// | Shuffle4Channel |             2. AVX |                                             Empty |  2048 | 105.120 ns | 0.6140 ns | 0.5443 ns |  0.11 |     - |     - |     - |         - |
+// | Shuffle4Channel |             3. SSE |                               COMPlus_EnableAVX=0 |  2048 | 216.473 ns | 2.3268 ns | 2.0627 ns |  0.22 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/Color/Bulk/ToRgba32Bytes.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
 using BenchmarkDotNet.Attributes;
 
@@ -9,80 +8,79 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    public abstract class ToRgba32Bytes<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        private IMemoryOwner<TPixel> source;
-
-        private IMemoryOwner<byte> destination;
-
-        private Configuration configuration;
 
-        [Params(16, 128, 1024)]
+public abstract class ToRgba32Bytes<TPixel>
-        public int Count { get; set; }
+    where TPixel : unmanaged, IPixel<TPixel>
-
+{
-        [GlobalSetup]
+    private IMemoryOwner<TPixel> source;
-        public void Setup()
-        {
-            this.configuration = Configuration.Default;
-            this.source = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.destination = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 4);
-        }
 
-        [GlobalCleanup]
+    private IMemoryOwner<byte> destination;
-        public void Cleanup()
-        {
-            this.source.Dispose();
-            this.destination.Dispose();
-        }
 
-        // [Benchmark]
+    private Configuration configuration;
-        public void Naive()
-        {
-            Span<TPixel> s = this.source.GetSpan();
-            Span<byte> d = this.destination.GetSpan();
-
-            for (int i = 0; i < this.Count; i++)
-            {
-                TPixel c = s[i];
-                int i4 = i * 4;
-                Rgba32 rgba = default;
-                c.ToRgba32(ref rgba);
-                d[i4] = rgba.R;
-                d[i4 + 1] = rgba.G;
-                d[i4 + 2] = rgba.B;
-                d[i4 + 3] = rgba.A;
-            }
-        }
 
-        [Benchmark(Baseline = true)]
+    [Params(16, 128, 1024)]
-        public void CommonBulk() =>
+    public int Count { get; set; }
-            new PixelOperations<TPixel>().ToRgba32Bytes(
-                this.configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan(),
-                this.Count);
-
-        [Benchmark]
-        public void OptimizedBulk() =>
-            PixelOperations<TPixel>.Instance.ToRgba32Bytes(
-                this.configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan(),
-                this.Count);
-    }
 
-    public class ToRgba32Bytes_FromRgba32 : ToRgba32Bytes<Rgba32>
+    [GlobalSetup]
+    public void Setup()
     {
+        this.configuration = Configuration.Default;
+        this.source = this.configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
+        this.destination = this.configuration.MemoryAllocator.Allocate<byte>(this.Count * 4);
     }
 
-    public class ToRgba32Bytes_FromArgb32 : ToRgba32Bytes<Argb32>
+    [GlobalCleanup]
+    public void Cleanup()
     {
+        this.source.Dispose();
+        this.destination.Dispose();
     }
 
-    public class ToRgba32Bytes_FromBgra32 : ToRgba32Bytes<Bgra32>
+    // [Benchmark]
+    public void Naive()
     {
+        Span<TPixel> s = this.source.GetSpan();
+        Span<byte> d = this.destination.GetSpan();
+
+        for (int i = 0; i < this.Count; i++)
+        {
+            TPixel c = s[i];
+            int i4 = i * 4;
+            Rgba32 rgba = default;
+            c.ToRgba32(ref rgba);
+            d[i4] = rgba.R;
+            d[i4 + 1] = rgba.G;
+            d[i4 + 2] = rgba.B;
+            d[i4 + 3] = rgba.A;
+        }
     }
+
+    [Benchmark(Baseline = true)]
+    public void CommonBulk() =>
+        new PixelOperations<TPixel>().ToRgba32Bytes(
+            this.configuration,
+            this.source.GetSpan(),
+            this.destination.GetSpan(),
+            this.Count);
+
+    [Benchmark]
+    public void OptimizedBulk() =>
+        PixelOperations<TPixel>.Instance.ToRgba32Bytes(
+            this.configuration,
+            this.source.GetSpan(),
+            this.destination.GetSpan(),
+            this.Count);
+}
+
+public class ToRgba32Bytes_FromRgba32 : ToRgba32Bytes<Rgba32>
+{
+}
+
+public class ToRgba32Bytes_FromArgb32 : ToRgba32Bytes<Argb32>
+{
+}
+
+public class ToRgba32Bytes_FromBgra32 : ToRgba32Bytes<Bgra32>
+{
 }

tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
@@ -10,53 +9,52 @@ using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    public abstract class ToVector4<TPixel>
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        protected IMemoryOwner<TPixel> source;
 
-        protected IMemoryOwner<Vector4> destination;
+public abstract class ToVector4<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    protected IMemoryOwner<TPixel> source;
 
-        protected Configuration Configuration => Configuration.Default;
+    protected IMemoryOwner<Vector4> destination;
 
-        [Params(64, 256, 2048)] // 512, 1024
+    protected Configuration Configuration => Configuration.Default;
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(64, 256, 2048)] // 512, 1024
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.source = this.Configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.destination = this.Configuration.MemoryAllocator.Allocate<Vector4>(this.Count);
-        }
 
-        [GlobalCleanup]
+    [GlobalSetup]
-        public void Cleanup()
+    public void Setup()
-        {
+    {
-            this.source.Dispose();
+        this.source = this.Configuration.MemoryAllocator.Allocate<TPixel>(this.Count);
-            this.destination.Dispose();
+        this.destination = this.Configuration.MemoryAllocator.Allocate<Vector4>(this.Count);
-        }
+    }
 
-        // [Benchmark]
+    [GlobalCleanup]
-        public void Naive()
+    public void Cleanup()
-        {
+    {
-            Span<TPixel> s = this.source.GetSpan();
+        this.source.Dispose();
-            Span<Vector4> d = this.destination.GetSpan();
+        this.destination.Dispose();
+    }
 
-            for (int i = 0; i < this.Count; i++)
+    // [Benchmark]
-            {
+    public void Naive()
-                d[i] = s[i].ToVector4();
+    {
-            }
+        Span<TPixel> s = this.source.GetSpan();
-        }
+        Span<Vector4> d = this.destination.GetSpan();
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void PixelOperations_Specialized()
         {
-            PixelOperations<TPixel>.Instance.ToVector4(
+            d[i] = s[i].ToVector4();
-                this.Configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan());
         }
     }
+
+    [Benchmark]
+    public void PixelOperations_Specialized()
+    {
+        PixelOperations<TPixel>.Instance.ToVector4(
+            this.Configuration,
+            this.source.GetSpan(),
+            this.destination.GetSpan());
+    }
 }

tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4_Bgra32.cs

@@ -6,39 +6,38 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class ToVector4_Bgra32 : ToVector4<Bgra32>
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    [Benchmark(Baseline = true)]
-    public class ToVector4_Bgra32 : ToVector4<Bgra32>
+    public void PixelOperations_Base()
     {
-        [Benchmark(Baseline = true)]
+        new PixelOperations<Bgra32>().ToVector4(
-        public void PixelOperations_Base()
+            this.Configuration,
-        {
+            this.source.GetSpan(),
-            new PixelOperations<Bgra32>().ToVector4(
+            this.destination.GetSpan());
-                this.Configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan());
-        }
-
-        // RESULTS:
-        //                       Method | Runtime | Count |       Mean |       Error |     StdDev | Scaled | ScaledSD |  Gen 0 | Allocated |
-        // ---------------------------- |-------- |------ |-----------:|------------:|-----------:|-------:|---------:|-------:|----------:|
-        //         PixelOperations_Base |     Clr |    64 |   339.9 ns |   138.30 ns |  7.8144 ns |   1.00 |     0.00 | 0.0072 |      24 B |
-        //  PixelOperations_Specialized |     Clr |    64 |   338.1 ns |    13.30 ns |  0.7515 ns |   0.99 |     0.02 |      - |       0 B |
-        //                              |         |       |            |             |            |        |          |        |           |
-        //         PixelOperations_Base |    Core |    64 |   245.6 ns |    29.05 ns |  1.6413 ns |   1.00 |     0.00 | 0.0072 |      24 B |
-        //  PixelOperations_Specialized |    Core |    64 |   257.1 ns |    37.89 ns |  2.1407 ns |   1.05 |     0.01 |      - |       0 B |
-        //                              |         |       |            |             |            |        |          |        |           |
-        //         PixelOperations_Base |     Clr |   256 |   972.7 ns |    61.98 ns |  3.5020 ns |   1.00 |     0.00 | 0.0057 |      24 B |
-        //  PixelOperations_Specialized |     Clr |   256 |   882.9 ns |   126.21 ns |  7.1312 ns |   0.91 |     0.01 |      - |       0 B |
-        //                              |         |       |            |             |            |        |          |        |           |
-        //         PixelOperations_Base |    Core |   256 |   910.0 ns |    90.87 ns |  5.1346 ns |   1.00 |     0.00 | 0.0067 |      24 B |
-        //  PixelOperations_Specialized |    Core |   256 |   448.4 ns |    15.77 ns |  0.8910 ns |   0.49 |     0.00 |      - |       0 B |
-        //                              |         |       |            |             |            |        |          |        |           |
-        //         PixelOperations_Base |     Clr |  2048 | 6,951.8 ns | 1,299.01 ns | 73.3963 ns |   1.00 |     0.00 |      - |      24 B |
-        //  PixelOperations_Specialized |     Clr |  2048 | 5,852.3 ns |   630.56 ns | 35.6279 ns |   0.84 |     0.01 |      - |       0 B |
-        //                              |         |       |            |             |            |        |          |        |           |
-        //         PixelOperations_Base |    Core |  2048 | 6,937.5 ns | 1,692.19 ns | 95.6121 ns |   1.00 |     0.00 |      - |      24 B |
-        //  PixelOperations_Specialized |    Core |  2048 | 2,994.5 ns | 1,126.65 ns | 63.6578 ns |   0.43 |     0.01 |      - |       0 B |
     }
+
+    // RESULTS:
+    //                       Method | Runtime | Count |       Mean |       Error |     StdDev | Scaled | ScaledSD |  Gen 0 | Allocated |
+    // ---------------------------- |-------- |------ |-----------:|------------:|-----------:|-------:|---------:|-------:|----------:|
+    //         PixelOperations_Base |     Clr |    64 |   339.9 ns |   138.30 ns |  7.8144 ns |   1.00 |     0.00 | 0.0072 |      24 B |
+    //  PixelOperations_Specialized |     Clr |    64 |   338.1 ns |    13.30 ns |  0.7515 ns |   0.99 |     0.02 |      - |       0 B |
+    //                              |         |       |            |             |            |        |          |        |           |
+    //         PixelOperations_Base |    Core |    64 |   245.6 ns |    29.05 ns |  1.6413 ns |   1.00 |     0.00 | 0.0072 |      24 B |
+    //  PixelOperations_Specialized |    Core |    64 |   257.1 ns |    37.89 ns |  2.1407 ns |   1.05 |     0.01 |      - |       0 B |
+    //                              |         |       |            |             |            |        |          |        |           |
+    //         PixelOperations_Base |     Clr |   256 |   972.7 ns |    61.98 ns |  3.5020 ns |   1.00 |     0.00 | 0.0057 |      24 B |
+    //  PixelOperations_Specialized |     Clr |   256 |   882.9 ns |   126.21 ns |  7.1312 ns |   0.91 |     0.01 |      - |       0 B |
+    //                              |         |       |            |             |            |        |          |        |           |
+    //         PixelOperations_Base |    Core |   256 |   910.0 ns |    90.87 ns |  5.1346 ns |   1.00 |     0.00 | 0.0067 |      24 B |
+    //  PixelOperations_Specialized |    Core |   256 |   448.4 ns |    15.77 ns |  0.8910 ns |   0.49 |     0.00 |      - |       0 B |
+    //                              |         |       |            |             |            |        |          |        |           |
+    //         PixelOperations_Base |     Clr |  2048 | 6,951.8 ns | 1,299.01 ns | 73.3963 ns |   1.00 |     0.00 |      - |      24 B |
+    //  PixelOperations_Specialized |     Clr |  2048 | 5,852.3 ns |   630.56 ns | 35.6279 ns |   0.84 |     0.01 |      - |       0 B |
+    //                              |         |       |            |             |            |        |          |        |           |
+    //         PixelOperations_Base |    Core |  2048 | 6,937.5 ns | 1,692.19 ns | 95.6121 ns |   1.00 |     0.00 |      - |      24 B |
+    //  PixelOperations_Specialized |    Core |  2048 | 2,994.5 ns | 1,126.65 ns | 63.6578 ns |   0.43 |     0.01 |      - |       0 B |
 }

tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4_Rgb24.cs

@@ -6,19 +6,18 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class ToVector4_Rgb24 : ToVector4<Rgb24>
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    [Benchmark(Baseline = true)]
-    public class ToVector4_Rgb24 : ToVector4<Rgb24>
+    public void PixelOperations_Base()
     {
-        [Benchmark(Baseline = true)]
+        new PixelOperations<Rgb24>().ToVector4(
-        public void PixelOperations_Base()
+            this.Configuration,
-        {
+            this.source.GetSpan(),
-            new PixelOperations<Rgb24>().ToVector4(
+            this.destination.GetSpan());
-                this.Configuration,
-                this.source.GetSpan(),
-                this.destination.GetSpan());
-        }
     }
 }
 

tests/ImageSharp.Benchmarks/Color/Bulk/ToVector4_Rgba32.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -10,156 +9,155 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
+
+[Config(typeof(Config.ShortCore31))]
+public class ToVector4_Rgba32 : ToVector4<Rgba32>
 {
-    [Config(typeof(Config.ShortCore31))]
+    [Benchmark]
-    public class ToVector4_Rgba32 : ToVector4<Rgba32>
+    public void FallbackIntrinsics128()
     {
-        [Benchmark]
+        Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-        public void FallbackIntrinsics128()
+        Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
-        {
-            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
 
-            SimdUtils.FallbackIntrinsics128.ByteToNormalizedFloat(sBytes, dFloats);
+        SimdUtils.FallbackIntrinsics128.ByteToNormalizedFloat(sBytes, dFloats);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void PixelOperations_Base()
+    public void PixelOperations_Base()
-            => new PixelOperations<Rgba32>().ToVector4(
+        => new PixelOperations<Rgba32>().ToVector4(
-                this.Configuration,
+            this.Configuration,
-                this.source.GetSpan(),
+            this.source.GetSpan(),
-                this.destination.GetSpan());
+            this.destination.GetSpan());
 
-        [Benchmark]
+    [Benchmark]
-        public void ExtendedIntrinsics()
+    public void ExtendedIntrinsics()
-        {
+    {
-            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
+        Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
+        Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
 
-            SimdUtils.ExtendedIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
+        SimdUtils.ExtendedIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void HwIntrinsics()
+    public void HwIntrinsics()
-        {
+    {
-            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
+        Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
+        Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
 
-            SimdUtils.HwIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
+        SimdUtils.HwIntrinsics.ByteToNormalizedFloat(sBytes, dFloats);
-        }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat_2Loops()
+    public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat_2Loops()
-        {
+    {
-            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
+        Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
+        Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
 
-            int n = dFloats.Length / Vector<byte>.Count;
+        int n = dFloats.Length / Vector<byte>.Count;
 
-            ref Vector<byte> sourceBase = ref Unsafe.As<byte, Vector<byte>>(ref MemoryMarshal.GetReference((ReadOnlySpan<byte>)sBytes));
+        ref Vector<byte> sourceBase = ref Unsafe.As<byte, Vector<byte>>(ref MemoryMarshal.GetReference((ReadOnlySpan<byte>)sBytes));
-            ref Vector<float> destBase = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(dFloats));
+        ref Vector<float> destBase = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(dFloats));
-            ref Vector<uint> destBaseU = ref Unsafe.As<Vector<float>, Vector<uint>>(ref destBase);
+        ref Vector<uint> destBaseU = ref Unsafe.As<Vector<float>, Vector<uint>>(ref destBase);
 
-            for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++)
-            {
+        {
-                Vector<byte> b = Unsafe.Add(ref sourceBase, i);
+            Vector<byte> b = Unsafe.Add(ref sourceBase, i);
 
-                Vector.Widen(b, out Vector<ushort> s0, out Vector<ushort> s1);
+            Vector.Widen(b, out Vector<ushort> s0, out Vector<ushort> s1);
-                Vector.Widen(s0, out Vector<uint> w0, out Vector<uint> w1);
+            Vector.Widen(s0, out Vector<uint> w0, out Vector<uint> w1);
-                Vector.Widen(s1, out Vector<uint> w2, out Vector<uint> w3);
+            Vector.Widen(s1, out Vector<uint> w2, out Vector<uint> w3);
 
-                ref Vector<uint> d = ref Unsafe.Add(ref destBaseU, i * 4);
+            ref Vector<uint> d = ref Unsafe.Add(ref destBaseU, i * 4);
-                d = w0;
+            d = w0;
-                Unsafe.Add(ref d, 1) = w1;
+            Unsafe.Add(ref d, 1) = w1;
-                Unsafe.Add(ref d, 2) = w2;
+            Unsafe.Add(ref d, 2) = w2;
-                Unsafe.Add(ref d, 3) = w3;
+            Unsafe.Add(ref d, 3) = w3;
-            }
+        }
 
-            n = dFloats.Length / Vector<float>.Count;
+        n = dFloats.Length / Vector<float>.Count;
-            var scale = new Vector<float>(1f / 255f);
+        var scale = new Vector<float>(1f / 255f);
 
-            for (int i = 0; i < n; i++)
+        for (int i = 0; i < n; i++)
-            {
+        {
-                ref Vector<float> dRef = ref Unsafe.Add(ref destBase, i);
+            ref Vector<float> dRef = ref Unsafe.Add(ref destBase, i);
 
-                var du = Vector.AsVectorInt32(dRef);
+            var du = Vector.AsVectorInt32(dRef);
-                var v = Vector.ConvertToSingle(du);
+            var v = Vector.ConvertToSingle(du);
-                v *= scale;
+            v *= scale;
 
-                dRef = v;
+            dRef = v;
-            }
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat_ConvertInSameLoop()
+    public void ExtendedIntrinsics_BulkConvertByteToNormalizedFloat_ConvertInSameLoop()
-        {
+    {
-            Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
+        Span<byte> sBytes = MemoryMarshal.Cast<Rgba32, byte>(this.source.GetSpan());
-            Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
+        Span<float> dFloats = MemoryMarshal.Cast<Vector4, float>(this.destination.GetSpan());
-
+
-            int n = dFloats.Length / Vector<byte>.Count;
+        int n = dFloats.Length / Vector<byte>.Count;
-
-            ref Vector<byte> sourceBase = ref Unsafe.As<byte, Vector<byte>>(ref MemoryMarshal.GetReference((ReadOnlySpan<byte>)sBytes));
-            ref Vector<float> destBase = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(dFloats));
-            var scale = new Vector<float>(1f / 255f);
-
-            for (int i = 0; i < n; i++)
-            {
-                Vector<byte> b = Unsafe.Add(ref sourceBase, i);
-
-                Vector.Widen(b, out Vector<ushort> s0, out Vector<ushort> s1);
-                Vector.Widen(s0, out Vector<uint> w0, out Vector<uint> w1);
-                Vector.Widen(s1, out Vector<uint> w2, out Vector<uint> w3);
-
-                Vector<float> f0 = ConvertToNormalizedSingle(w0, scale);
-                Vector<float> f1 = ConvertToNormalizedSingle(w1, scale);
-                Vector<float> f2 = ConvertToNormalizedSingle(w2, scale);
-                Vector<float> f3 = ConvertToNormalizedSingle(w3, scale);
-
-                ref Vector<float> d = ref Unsafe.Add(ref destBase, i * 4);
-                d = f0;
-                Unsafe.Add(ref d, 1) = f1;
-                Unsafe.Add(ref d, 2) = f2;
-                Unsafe.Add(ref d, 3) = f3;
-            }
-        }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        ref Vector<byte> sourceBase = ref Unsafe.As<byte, Vector<byte>>(ref MemoryMarshal.GetReference((ReadOnlySpan<byte>)sBytes));
-        private static Vector<float> ConvertToNormalizedSingle(Vector<uint> u, Vector<float> scale)
+        ref Vector<float> destBase = ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(dFloats));
+        var scale = new Vector<float>(1f / 255f);
+
+        for (int i = 0; i < n; i++)
         {
-            var vi = Vector.AsVectorInt32(u);
+            Vector<byte> b = Unsafe.Add(ref sourceBase, i);
-            var v = Vector.ConvertToSingle(vi);
+
-            v *= scale;
+            Vector.Widen(b, out Vector<ushort> s0, out Vector<ushort> s1);
-            return v;
+            Vector.Widen(s0, out Vector<uint> w0, out Vector<uint> w1);
+            Vector.Widen(s1, out Vector<uint> w2, out Vector<uint> w3);
+
+            Vector<float> f0 = ConvertToNormalizedSingle(w0, scale);
+            Vector<float> f1 = ConvertToNormalizedSingle(w1, scale);
+            Vector<float> f2 = ConvertToNormalizedSingle(w2, scale);
+            Vector<float> f3 = ConvertToNormalizedSingle(w3, scale);
+
+            ref Vector<float> d = ref Unsafe.Add(ref destBase, i * 4);
+            d = f0;
+            Unsafe.Add(ref d, 1) = f1;
+            Unsafe.Add(ref d, 2) = f2;
+            Unsafe.Add(ref d, 3) = f3;
         }
+    }
 
-        /*RESULTS (2018 October):
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
+    private static Vector<float> ConvertToNormalizedSingle(Vector<uint> u, Vector<float> scale)
-                              Method | Runtime | Count |        Mean |        Error |      StdDev | Scaled | ScaledSD |  Gen 0 | Allocated |
+    {
-        ---------------------------- |-------- |------ |------------:|-------------:|------------:|-------:|---------:|-------:|----------:|
+        var vi = Vector.AsVectorInt32(u);
-               FallbackIntrinsics128 |     Clr |    64 |   287.62 ns |     6.026 ns |   0.3405 ns |   1.19 |     0.00 |      - |       0 B |
+        var v = Vector.ConvertToSingle(vi);
-                  BasicIntrinsics256 |     Clr |    64 |   240.83 ns |    10.585 ns |   0.5981 ns |   1.00 |     0.00 |      - |       0 B |
+        v *= scale;
-                  ExtendedIntrinsics |     Clr |    64 |   168.28 ns |    11.478 ns |   0.6485 ns |   0.70 |     0.00 |      - |       0 B |
+        return v;
-                PixelOperations_Base |     Clr |    64 |   334.08 ns |    38.048 ns |   2.1498 ns |   1.39 |     0.01 | 0.0072 |      24 B |
-         PixelOperations_Specialized |     Clr |    64 |   255.41 ns |    10.939 ns |   0.6181 ns |   1.06 |     0.00 |      - |       0 B | <--- ceremonial overhead has been minimized!
-                                     |         |       |             |              |             |        |          |        |           |
-               FallbackIntrinsics128 |    Core |    64 |   183.29 ns |     8.931 ns |   0.5046 ns |   1.32 |     0.00 |      - |       0 B |
-                  BasicIntrinsics256 |    Core |    64 |   139.18 ns |     7.633 ns |   0.4313 ns |   1.00 |     0.00 |      - |       0 B |
-                  ExtendedIntrinsics |    Core |    64 |    66.29 ns |    16.366 ns |   0.9247 ns |   0.48 |     0.01 |      - |       0 B |
-                PixelOperations_Base |    Core |    64 |   257.75 ns |    16.959 ns |   0.9582 ns |   1.85 |     0.01 | 0.0072 |      24 B |
-         PixelOperations_Specialized |    Core |    64 |    90.14 ns |     9.955 ns |   0.5625 ns |   0.65 |     0.00 |      - |       0 B |
-                                     |         |       |             |              |             |        |          |        |           |
-               FallbackIntrinsics128 |     Clr |  2048 | 5,011.84 ns |   347.991 ns |  19.6621 ns |   1.22 |     0.01 |      - |       0 B |
-                  BasicIntrinsics256 |     Clr |  2048 | 4,119.35 ns |   720.153 ns |  40.6900 ns |   1.00 |     0.00 |      - |       0 B |
-                  ExtendedIntrinsics |     Clr |  2048 | 1,195.29 ns |   164.389 ns |   9.2883 ns |!! 0.29 |     0.00 |      - |       0 B | <--- ExtendedIntrinsics rock!
-                PixelOperations_Base |     Clr |  2048 | 6,820.58 ns |   823.433 ns |  46.5255 ns |   1.66 |     0.02 |      - |      24 B |
-         PixelOperations_Specialized |     Clr |  2048 | 4,203.53 ns |   176.714 ns |   9.9847 ns |   1.02 |     0.01 |      - |       0 B | <--- can't yet detect whether ExtendedIntrinsics are available :(
-                                     |         |       |             |              |             |        |          |        |           |
-               FallbackIntrinsics128 |    Core |  2048 | 5,017.89 ns | 4,021.533 ns | 227.2241 ns |   1.24 |     0.05 |      - |       0 B |
-                  BasicIntrinsics256 |    Core |  2048 | 4,046.51 ns | 1,150.390 ns |  64.9992 ns |   1.00 |     0.00 |      - |       0 B |
-                  ExtendedIntrinsics |    Core |  2048 | 1,130.59 ns |   832.588 ns |  47.0427 ns |!! 0.28 |     0.01 |      - |       0 B | <--- ExtendedIntrinsics rock!
-                PixelOperations_Base |    Core |  2048 | 6,752.68 ns |   272.820 ns |  15.4148 ns |   1.67 |     0.02 |      - |      24 B |
-         PixelOperations_Specialized |    Core |  2048 | 1,126.13 ns |    79.192 ns |   4.4745 ns |!! 0.28 |     0.00 |      - |       0 B | <--- ExtendedIntrinsics rock!
-         */
     }
+
+    /*RESULTS (2018 October):
+
+                          Method | Runtime | Count |        Mean |        Error |      StdDev | Scaled | ScaledSD |  Gen 0 | Allocated |
+    ---------------------------- |-------- |------ |------------:|-------------:|------------:|-------:|---------:|-------:|----------:|
+           FallbackIntrinsics128 |     Clr |    64 |   287.62 ns |     6.026 ns |   0.3405 ns |   1.19 |     0.00 |      - |       0 B |
+              BasicIntrinsics256 |     Clr |    64 |   240.83 ns |    10.585 ns |   0.5981 ns |   1.00 |     0.00 |      - |       0 B |
+              ExtendedIntrinsics |     Clr |    64 |   168.28 ns |    11.478 ns |   0.6485 ns |   0.70 |     0.00 |      - |       0 B |
+            PixelOperations_Base |     Clr |    64 |   334.08 ns |    38.048 ns |   2.1498 ns |   1.39 |     0.01 | 0.0072 |      24 B |
+     PixelOperations_Specialized |     Clr |    64 |   255.41 ns |    10.939 ns |   0.6181 ns |   1.06 |     0.00 |      - |       0 B | <--- ceremonial overhead has been minimized!
+                                 |         |       |             |              |             |        |          |        |           |
+           FallbackIntrinsics128 |    Core |    64 |   183.29 ns |     8.931 ns |   0.5046 ns |   1.32 |     0.00 |      - |       0 B |
+              BasicIntrinsics256 |    Core |    64 |   139.18 ns |     7.633 ns |   0.4313 ns |   1.00 |     0.00 |      - |       0 B |
+              ExtendedIntrinsics |    Core |    64 |    66.29 ns |    16.366 ns |   0.9247 ns |   0.48 |     0.01 |      - |       0 B |
+            PixelOperations_Base |    Core |    64 |   257.75 ns |    16.959 ns |   0.9582 ns |   1.85 |     0.01 | 0.0072 |      24 B |
+     PixelOperations_Specialized |    Core |    64 |    90.14 ns |     9.955 ns |   0.5625 ns |   0.65 |     0.00 |      - |       0 B |
+                                 |         |       |             |              |             |        |          |        |           |
+           FallbackIntrinsics128 |     Clr |  2048 | 5,011.84 ns |   347.991 ns |  19.6621 ns |   1.22 |     0.01 |      - |       0 B |
+              BasicIntrinsics256 |     Clr |  2048 | 4,119.35 ns |   720.153 ns |  40.6900 ns |   1.00 |     0.00 |      - |       0 B |
+              ExtendedIntrinsics |     Clr |  2048 | 1,195.29 ns |   164.389 ns |   9.2883 ns |!! 0.29 |     0.00 |      - |       0 B | <--- ExtendedIntrinsics rock!
+            PixelOperations_Base |     Clr |  2048 | 6,820.58 ns |   823.433 ns |  46.5255 ns |   1.66 |     0.02 |      - |      24 B |
+     PixelOperations_Specialized |     Clr |  2048 | 4,203.53 ns |   176.714 ns |   9.9847 ns |   1.02 |     0.01 |      - |       0 B | <--- can't yet detect whether ExtendedIntrinsics are available :(
+                                 |         |       |             |              |             |        |          |        |           |
+           FallbackIntrinsics128 |    Core |  2048 | 5,017.89 ns | 4,021.533 ns | 227.2241 ns |   1.24 |     0.05 |      - |       0 B |
+              BasicIntrinsics256 |    Core |  2048 | 4,046.51 ns | 1,150.390 ns |  64.9992 ns |   1.00 |     0.00 |      - |       0 B |
+              ExtendedIntrinsics |    Core |  2048 | 1,130.59 ns |   832.588 ns |  47.0427 ns |!! 0.28 |     0.01 |      - |       0 B | <--- ExtendedIntrinsics rock!
+            PixelOperations_Base |    Core |  2048 | 6,752.68 ns |   272.820 ns |  15.4148 ns |   1.67 |     0.02 |      - |      24 B |
+     PixelOperations_Specialized |    Core |  2048 | 1,126.13 ns |    79.192 ns |   4.4745 ns |!! 0.28 |     0.00 |      - |       0 B | <--- ExtendedIntrinsics rock!
+     */
 }

tests/ImageSharp.Benchmarks/Color/Bulk/UnPremultiplyVector4.cs

@@ -1,68 +1,66 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk;
-{
-    [Config(typeof(Config.ShortCore31))]
-    public class UnPremultiplyVector4
-    {
-        private static readonly Vector4[] Vectors = CreateVectors();
 
-        [Benchmark(Baseline = true)]
+[Config(typeof(Config.ShortCore31))]
-        public void UnPremultiplyBaseline()
+public class UnPremultiplyVector4
-        {
+{
-            ref Vector4 baseRef = ref MemoryMarshal.GetReference<Vector4>(Vectors);
+    private static readonly Vector4[] Vectors = CreateVectors();
 
-            for (int i = 0; i < Vectors.Length; i++)
+    [Benchmark(Baseline = true)]
-            {
+    public void UnPremultiplyBaseline()
-                ref Vector4 v = ref Unsafe.Add(ref baseRef, i);
+    {
-                UnPremultiply(ref v);
+        ref Vector4 baseRef = ref MemoryMarshal.GetReference<Vector4>(Vectors);
-            }
-        }
 
-        [Benchmark]
+        for (int i = 0; i < Vectors.Length; i++)
-        public void UnPremultiply()
         {
-            Numerics.UnPremultiply(Vectors);
+            ref Vector4 v = ref Unsafe.Add(ref baseRef, i);
+            UnPremultiply(ref v);
         }
+    }
 
-        [MethodImpl(InliningOptions.ShortMethod)]
+    [Benchmark]
-        private static void UnPremultiply(ref Vector4 source)
+    public void UnPremultiply()
-        {
+    {
-            float w = source.W;
+        Numerics.UnPremultiply(Vectors);
-            source /= w;
+    }
-            source.W = w;
-        }
 
-        private static Vector4[] CreateVectors()
+    [MethodImpl(InliningOptions.ShortMethod)]
-        {
+    private static void UnPremultiply(ref Vector4 source)
-            var rnd = new Random(42);
+    {
-            return GenerateRandomVectorArray(rnd, 2048, 0, 1);
+        float w = source.W;
-        }
+        source /= w;
+        source.W = w;
+    }
 
-        private static Vector4[] GenerateRandomVectorArray(Random rnd, int length, float minVal, float maxVal)
+    private static Vector4[] CreateVectors()
-        {
+    {
-            var values = new Vector4[length];
+        var rnd = new Random(42);
+        return GenerateRandomVectorArray(rnd, 2048, 0, 1);
+    }
 
-            for (int i = 0; i < length; i++)
+    private static Vector4[] GenerateRandomVectorArray(Random rnd, int length, float minVal, float maxVal)
-            {
+    {
-                ref Vector4 v = ref values[i];
+        var values = new Vector4[length];
-                v.X = GetRandomFloat(rnd, minVal, maxVal);
-                v.Y = GetRandomFloat(rnd, minVal, maxVal);
-                v.Z = GetRandomFloat(rnd, minVal, maxVal);
-                v.W = GetRandomFloat(rnd, minVal, maxVal);
-            }
 
-            return values;
+        for (int i = 0; i < length; i++)
+        {
+            ref Vector4 v = ref values[i];
+            v.X = GetRandomFloat(rnd, minVal, maxVal);
+            v.Y = GetRandomFloat(rnd, minVal, maxVal);
+            v.Z = GetRandomFloat(rnd, minVal, maxVal);
+            v.W = GetRandomFloat(rnd, minVal, maxVal);
         }
 
-        private static float GetRandomFloat(Random rnd, float minVal, float maxVal)
+        return values;
-            => ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
     }
+
+    private static float GetRandomFloat(Random rnd, float minVal, float maxVal)
+        => ((float)rnd.NextDouble() * (maxVal - minVal)) + minVal;
 }

tests/ImageSharp.Benchmarks/Color/ColorEquality.cs

@@ -5,22 +5,21 @@ using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks
+namespace SixLabors.ImageSharp.Benchmarks;
-{
+
-    using SystemColor = System.Drawing.Color;
+using SystemColor = System.Drawing.Color;
 
-    public class ColorEquality
+public class ColorEquality
+{
+    [Benchmark(Baseline = true, Description = "System.Drawing Color Equals")]
+    public bool SystemDrawingColorEqual()
     {
-        [Benchmark(Baseline = true, Description = "System.Drawing Color Equals")]
+        return SystemColor.FromArgb(128, 128, 128, 128).Equals(SystemColor.FromArgb(128, 128, 128, 128));
-        public bool SystemDrawingColorEqual()
+    }
-        {
-            return SystemColor.FromArgb(128, 128, 128, 128).Equals(SystemColor.FromArgb(128, 128, 128, 128));
-        }
 
-        [Benchmark(Description = "ImageSharp Color Equals")]
+    [Benchmark(Description = "ImageSharp Color Equals")]
-        public bool ColorEqual()
+    public bool ColorEqual()
-        {
+    {
-            return new Rgba32(128, 128, 128, 128).Equals(new Rgba32(128, 128, 128, 128));
+        return new Rgba32(128, 128, 128, 128).Equals(new Rgba32(128, 128, 128, 128));
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/ColorspaceCieXyzToCieLabConvert.cs

@@ -9,28 +9,27 @@ using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using Illuminants = Colourful.Illuminants;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces;
+
+public class ColorspaceCieXyzToCieLabConvert
 {
-    public class ColorspaceCieXyzToCieLabConvert
+    private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
-    {
-        private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
 
-        private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
+    private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
 
-        private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
+    private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
 
-        private static readonly IColorConverter<XYZColor, LabColor> ColourfulConverter = new ConverterBuilder().FromXYZ(Illuminants.D50).ToLab(Illuminants.D50).Build();
+    private static readonly IColorConverter<XYZColor, LabColor> ColourfulConverter = new ConverterBuilder().FromXYZ(Illuminants.D50).ToLab(Illuminants.D50).Build();
 
-        [Benchmark(Baseline = true, Description = "Colourful Convert")]
+    [Benchmark(Baseline = true, Description = "Colourful Convert")]
-        public double ColourfulConvert()
+    public double ColourfulConvert()
-        {
+    {
-            return ColourfulConverter.Convert(XYZColor).L;
+        return ColourfulConverter.Convert(XYZColor).L;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Convert")]
+    [Benchmark(Description = "ImageSharp Convert")]
-        public float ColorSpaceConvert()
+    public float ColorSpaceConvert()
-        {
+    {
-            return ColorSpaceConverter.ToCieLab(CieXyz).L;
+        return ColorSpaceConverter.ToCieLab(CieXyz).L;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/ColorspaceCieXyzToHunterLabConvert.cs

@@ -9,28 +9,27 @@ using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using Illuminants = Colourful.Illuminants;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces;
+
+public class ColorspaceCieXyzToHunterLabConvert
 {
-    public class ColorspaceCieXyzToHunterLabConvert
+    private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
-    {
-        private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
 
-        private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
+    private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
 
-        private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
+    private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
 
-        private static readonly IColorConverter<XYZColor, HunterLabColor> ColourfulConverter = new ConverterBuilder().FromXYZ(Illuminants.C).ToHunterLab(Illuminants.C).Build();
+    private static readonly IColorConverter<XYZColor, HunterLabColor> ColourfulConverter = new ConverterBuilder().FromXYZ(Illuminants.C).ToHunterLab(Illuminants.C).Build();
 
-        [Benchmark(Baseline = true, Description = "Colourful Convert")]
+    [Benchmark(Baseline = true, Description = "Colourful Convert")]
-        public double ColourfulConvert()
+    public double ColourfulConvert()
-        {
+    {
-            return ColourfulConverter.Convert(XYZColor).L;
+        return ColourfulConverter.Convert(XYZColor).L;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Convert")]
+    [Benchmark(Description = "ImageSharp Convert")]
-        public float ColorSpaceConvert()
+    public float ColorSpaceConvert()
-        {
+    {
-            return ColorSpaceConverter.ToHunterLab(CieXyz).L;
+        return ColorSpaceConverter.ToHunterLab(CieXyz).L;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/ColorspaceCieXyzToLmsConvert.cs

@@ -8,28 +8,27 @@ using Colourful;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces;
+
+public class ColorspaceCieXyzToLmsConvert
 {
-    public class ColorspaceCieXyzToLmsConvert
+    private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
-    {
-        private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
 
-        private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
+    private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
 
-        private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
+    private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
 
-        private static readonly IColorConverter<XYZColor, LMSColor> ColourfulConverter = new ConverterBuilder().FromXYZ().ToLMS().Build();
+    private static readonly IColorConverter<XYZColor, LMSColor> ColourfulConverter = new ConverterBuilder().FromXYZ().ToLMS().Build();
 
-        [Benchmark(Baseline = true, Description = "Colourful Convert")]
+    [Benchmark(Baseline = true, Description = "Colourful Convert")]
-        public double ColourfulConvert()
+    public double ColourfulConvert()
-        {
+    {
-            return ColourfulConverter.Convert(XYZColor).L;
+        return ColourfulConverter.Convert(XYZColor).L;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Convert")]
+    [Benchmark(Description = "ImageSharp Convert")]
-        public float ColorSpaceConvert()
+    public float ColorSpaceConvert()
-        {
+    {
-            return ColorSpaceConverter.ToLms(CieXyz).L;
+        return ColorSpaceConverter.ToLms(CieXyz).L;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/ColorspaceCieXyzToRgbConvert.cs

@@ -8,28 +8,27 @@ using Colourful;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces;
+
+public class ColorspaceCieXyzToRgbConvert
 {
-    public class ColorspaceCieXyzToRgbConvert
+    private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
-    {
-        private static readonly CieXyz CieXyz = new CieXyz(0.95047F, 1, 1.08883F);
 
-        private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
+    private static readonly XYZColor XYZColor = new XYZColor(0.95047, 1, 1.08883);
 
-        private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
+    private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter();
 
-        private static readonly IColorConverter<XYZColor, RGBColor> ColourfulConverter = new ConverterBuilder().FromXYZ(RGBWorkingSpaces.sRGB.WhitePoint).ToRGB(RGBWorkingSpaces.sRGB).Build();
+    private static readonly IColorConverter<XYZColor, RGBColor> ColourfulConverter = new ConverterBuilder().FromXYZ(RGBWorkingSpaces.sRGB.WhitePoint).ToRGB(RGBWorkingSpaces.sRGB).Build();
 
-        [Benchmark(Baseline = true, Description = "Colourful Convert")]
+    [Benchmark(Baseline = true, Description = "Colourful Convert")]
-        public double ColourfulConvert()
+    public double ColourfulConvert()
-        {
+    {
-            return ColourfulConverter.Convert(XYZColor).R;
+        return ColourfulConverter.Convert(XYZColor).R;
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Convert")]
+    [Benchmark(Description = "ImageSharp Convert")]
-        public float ColorSpaceConvert()
+    public float ColorSpaceConvert()
-        {
+    {
-            return ColorSpaceConverter.ToRgb(CieXyz).R;
+        return ColorSpaceConverter.ToRgb(CieXyz).R;
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/RgbWorkingSpaceAdapt.cs

@@ -8,28 +8,27 @@ using Colourful;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 
-namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces
+namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces;
+
+public class RgbWorkingSpaceAdapt
 {
-    public class RgbWorkingSpaceAdapt
+    private static readonly Rgb Rgb = new Rgb(0.206162F, 0.260277F, 0.746717F, RgbWorkingSpaces.WideGamutRgb);
-    {
-        private static readonly Rgb Rgb = new Rgb(0.206162F, 0.260277F, 0.746717F, RgbWorkingSpaces.WideGamutRgb);
 
-        private static readonly RGBColor RGBColor = new RGBColor(0.206162, 0.260277, 0.746717);
+    private static readonly RGBColor RGBColor = new RGBColor(0.206162, 0.260277, 0.746717);
 
-        private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter(new ColorSpaceConverterOptions { TargetRgbWorkingSpace = RgbWorkingSpaces.SRgb });
+    private static readonly ColorSpaceConverter ColorSpaceConverter = new ColorSpaceConverter(new ColorSpaceConverterOptions { TargetRgbWorkingSpace = RgbWorkingSpaces.SRgb });
 
-        private static readonly IColorConverter<RGBColor, RGBColor> ColourfulConverter = new ConverterBuilder().FromRGB(RGBWorkingSpaces.WideGamutRGB).ToRGB(RGBWorkingSpaces.sRGB).Build();
+    private static readonly IColorConverter<RGBColor, RGBColor> ColourfulConverter = new ConverterBuilder().FromRGB(RGBWorkingSpaces.WideGamutRGB).ToRGB(RGBWorkingSpaces.sRGB).Build();
 
-        [Benchmark(Baseline = true, Description = "Colourful Adapt")]
+    [Benchmark(Baseline = true, Description = "Colourful Adapt")]
-        public RGBColor ColourfulConvert()
+    public RGBColor ColourfulConvert()
-        {
+    {
-            return ColourfulConverter.Convert(RGBColor);
+        return ColourfulConverter.Convert(RGBColor);
-        }
+    }
 
-        [Benchmark(Description = "ImageSharp Adapt")]
+    [Benchmark(Description = "ImageSharp Adapt")]
-        public Rgb ColorSpaceConvert()
+    public Rgb ColorSpaceConvert()
-        {
+    {
-            return ColorSpaceConverter.Adapt(Rgb);
+        return ColorSpaceConverter.Adapt(Rgb);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Color/YcbCrToRgb.cs

@@ -4,48 +4,47 @@
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks
+namespace SixLabors.ImageSharp.Benchmarks;
+
+public class YcbCrToRgb
 {
-    public class YcbCrToRgb
+    [Benchmark(Baseline = true, Description = "Floating Point Conversion")]
+    public Vector3 YcbCrToRgba()
     {
-        [Benchmark(Baseline = true, Description = "Floating Point Conversion")]
+        int y = 255;
-        public Vector3 YcbCrToRgba()
+        int cb = 128;
-        {
+        int cr = 128;
-            int y = 255;
+
-            int cb = 128;
+        int ccb = cb - 128;
-            int cr = 128;
+        int ccr = cr - 128;
-
+
-            int ccb = cb - 128;
+        byte r = (byte)Numerics.Clamp(y + (1.402F * ccr), 0, 255);
-            int ccr = cr - 128;
+        byte g = (byte)Numerics.Clamp(y - (0.34414F * ccb) - (0.71414F * ccr), 0, 255);
-
+        byte b = (byte)Numerics.Clamp(y + (1.772F * ccb), 0, 255);
-            byte r = (byte)Numerics.Clamp(y + (1.402F * ccr), 0, 255);
+
-            byte g = (byte)Numerics.Clamp(y - (0.34414F * ccb) - (0.71414F * ccr), 0, 255);
+        return new Vector3(r, g, b);
-            byte b = (byte)Numerics.Clamp(y + (1.772F * ccb), 0, 255);
+    }
-
+
-            return new Vector3(r, g, b);
+    [Benchmark(Description = "Scaled Integer Conversion")]
-        }
+    public Vector3 YcbCrToRgbaScaled()
-
+    {
-        [Benchmark(Description = "Scaled Integer Conversion")]
+        int y = 255;
-        public Vector3 YcbCrToRgbaScaled()
+        int cb = 128;
-        {
+        int cr = 128;
-            int y = 255;
+
-            int cb = 128;
+        int ccb = cb - 128;
-            int cr = 128;
+        int ccr = cr - 128;
-
+
-            int ccb = cb - 128;
+        // Scale by 1024, add .5F and truncate value
-            int ccr = cr - 128;
+        int r0 = 1436 * ccr; // (1.402F * 1024) + .5F
-
+        int g0 = 352 * ccb; // (0.34414F * 1024) + .5F
-            // Scale by 1024, add .5F and truncate value
+        int g1 = 731 * ccr; // (0.71414F  * 1024) + .5F
-            int r0 = 1436 * ccr; // (1.402F * 1024) + .5F
+        int b0 = 1815 * ccb; // (1.772F * 1024) + .5F
-            int g0 = 352 * ccb; // (0.34414F * 1024) + .5F
+
-            int g1 = 731 * ccr; // (0.71414F  * 1024) + .5F
+        byte r = (byte)Numerics.Clamp(y + (r0 >> 10), 0, 255);
-            int b0 = 1815 * ccb; // (1.772F * 1024) + .5F
+        byte g = (byte)Numerics.Clamp(y - (g0 >> 10) - (g1 >> 10), 0, 255);
-
+        byte b = (byte)Numerics.Clamp(y + (b0 >> 10), 0, 255);
-            byte r = (byte)Numerics.Clamp(y + (r0 >> 10), 0, 255);
+
-            byte g = (byte)Numerics.Clamp(y - (g0 >> 10) - (g1 >> 10), 0, 255);
+        return new Vector3(r, g, b);
-            byte b = (byte)Numerics.Clamp(y + (b0 >> 10), 0, 255);
-
-            return new Vector3(r, g, b);
-        }
     }
 }

tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs

@@ -5,75 +5,74 @@ using System.Runtime.Intrinsics.X86;
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
 
-namespace SixLabors.ImageSharp.Benchmarks
+namespace SixLabors.ImageSharp.Benchmarks;
+
+public partial class Config
 {
-    public partial class Config
+    private const string On = "1";
-    {
+    private const string Off = "0";
-        private const string On = "1";
-        private const string Off = "0";
 
-        // See https://github.com/SixLabors/ImageSharp/pull/1229#discussion_r440477861
+    // See https://github.com/SixLabors/ImageSharp/pull/1229#discussion_r440477861
-        // * EnableHWIntrinsic
+    // * EnableHWIntrinsic
-        //   * EnableSSE
+    //   * EnableSSE
-        //     * EnableSSE2
+    //     * EnableSSE2
-        //       * EnableAES
+    //       * EnableAES
-        //       * EnablePCLMULQDQ
+    //       * EnablePCLMULQDQ
-        //       * EnableSSE3
+    //       * EnableSSE3
-        //         * EnableSSSE3
+    //         * EnableSSSE3
-        //           * EnableSSE41
+    //           * EnableSSE41
-        //             * EnableSSE42
+    //             * EnableSSE42
-        //               * EnablePOPCNT
+    //               * EnablePOPCNT
-        //               * EnableAVX
+    //               * EnableAVX
-        //                 * EnableFMA
+    //                 * EnableFMA
-        //                 * EnableAVX2
+    //                 * EnableAVX2
-        //   * EnableBMI1
+    //   * EnableBMI1
-        //   * EnableBMI2
+    //   * EnableBMI2
-        //   * EnableLZCNT
+    //   * EnableLZCNT
-        //
+    //
-        // `FeatureSIMD` ends up impacting all SIMD support(including `System.Numerics`) but not things
+    // `FeatureSIMD` ends up impacting all SIMD support(including `System.Numerics`) but not things
-        // like `LZCNT`, `BMI1`, or `BMI2`
+    // like `LZCNT`, `BMI1`, or `BMI2`
-        // `EnableSSE3_4` is a legacy switch that exists for compat and is basically the same as `EnableSSE3`
+    // `EnableSSE3_4` is a legacy switch that exists for compat and is basically the same as `EnableSSE3`
-        private const string EnableAES = "COMPlus_EnableAES";
+    private const string EnableAES = "COMPlus_EnableAES";
-        private const string EnableAVX = "COMPlus_EnableAVX";
+    private const string EnableAVX = "COMPlus_EnableAVX";
-        private const string EnableAVX2 = "COMPlus_EnableAVX2";
+    private const string EnableAVX2 = "COMPlus_EnableAVX2";
-        private const string EnableBMI1 = "COMPlus_EnableBMI1";
+    private const string EnableBMI1 = "COMPlus_EnableBMI1";
-        private const string EnableBMI2 = "COMPlus_EnableBMI2";
+    private const string EnableBMI2 = "COMPlus_EnableBMI2";
-        private const string EnableFMA = "COMPlus_EnableFMA";
+    private const string EnableFMA = "COMPlus_EnableFMA";
-        private const string EnableHWIntrinsic = "COMPlus_EnableHWIntrinsic";
+    private const string EnableHWIntrinsic = "COMPlus_EnableHWIntrinsic";
-        private const string EnableLZCNT = "COMPlus_EnableLZCNT";
+    private const string EnableLZCNT = "COMPlus_EnableLZCNT";
-        private const string EnablePCLMULQDQ = "COMPlus_EnablePCLMULQDQ";
+    private const string EnablePCLMULQDQ = "COMPlus_EnablePCLMULQDQ";
-        private const string EnablePOPCNT = "COMPlus_EnablePOPCNT";
+    private const string EnablePOPCNT = "COMPlus_EnablePOPCNT";
-        private const string EnableSSE = "COMPlus_EnableSSE";
+    private const string EnableSSE = "COMPlus_EnableSSE";
-        private const string EnableSSE2 = "COMPlus_EnableSSE2";
+    private const string EnableSSE2 = "COMPlus_EnableSSE2";
-        private const string EnableSSE3 = "COMPlus_EnableSSE3";
+    private const string EnableSSE3 = "COMPlus_EnableSSE3";
-        private const string EnableSSE3_4 = "COMPlus_EnableSSE3_4";
+    private const string EnableSSE3_4 = "COMPlus_EnableSSE3_4";
-        private const string EnableSSE41 = "COMPlus_EnableSSE41";
+    private const string EnableSSE41 = "COMPlus_EnableSSE41";
-        private const string EnableSSE42 = "COMPlus_EnableSSE42";
+    private const string EnableSSE42 = "COMPlus_EnableSSE42";
-        private const string EnableSSSE3 = "COMPlus_EnableSSSE3";
+    private const string EnableSSSE3 = "COMPlus_EnableSSSE3";
-        private const string FeatureSIMD = "COMPlus_FeatureSIMD";
+    private const string FeatureSIMD = "COMPlus_FeatureSIMD";
 
-        public class HwIntrinsics_SSE_AVX : Config
+    public class HwIntrinsics_SSE_AVX : Config
+    {
+        public HwIntrinsics_SSE_AVX()
         {
-            public HwIntrinsics_SSE_AVX()
+            this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core60)
+                .WithEnvironmentVariables(
+                    new EnvironmentVariable(EnableHWIntrinsic, Off),
+                    new EnvironmentVariable(FeatureSIMD, Off))
+                .WithId("1. No HwIntrinsics").AsBaseline());
+
+            if (Sse.IsSupported)
             {
                 this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core60)
-                    .WithEnvironmentVariables(
+                    .WithEnvironmentVariables(new EnvironmentVariable(EnableAVX, Off))
-                        new EnvironmentVariable(EnableHWIntrinsic, Off),
+                    .WithId("2. SSE"));
-                        new EnvironmentVariable(FeatureSIMD, Off))
+            }
-                    .WithId("1. No HwIntrinsics").AsBaseline());
-
-                if (Sse.IsSupported)
-                {
-                    this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core60)
-                        .WithEnvironmentVariables(new EnvironmentVariable(EnableAVX, Off))
-                        .WithId("2. SSE"));
-                }
 
-                if (Avx.IsSupported)
+            if (Avx.IsSupported)
-                {
+            {
-                    this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core60)
+                this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core60)
-                        .WithId("3. AVX"));
+                    .WithId("3. AVX"));
-                }
             }
         }
     }

tests/ImageSharp.Benchmarks/Config.cs

@@ -11,44 +11,43 @@ using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Reports;
 
-namespace SixLabors.ImageSharp.Benchmarks
+namespace SixLabors.ImageSharp.Benchmarks;
+
+public partial class Config : ManualConfig
 {
-    public partial class Config : ManualConfig
+    public Config()
     {
-        public Config()
+        this.AddDiagnoser(MemoryDiagnoser.Default);
-        {
-            this.AddDiagnoser(MemoryDiagnoser.Default);
 
 #if OS_WINDOWS
-            if (this.IsElevated)
+        if (this.IsElevated)
-            {
+        {
-                this.AddDiagnoser(new NativeMemoryProfiler());
+            this.AddDiagnoser(new NativeMemoryProfiler());
-            }
+        }
 #endif
 
-            this.SummaryStyle = SummaryStyle.Default.WithMaxParameterColumnWidth(50);
+        this.SummaryStyle = SummaryStyle.Default.WithMaxParameterColumnWidth(50);
-        }
+    }
 
-        public class MultiFramework : Config
+    public class MultiFramework : Config
-        {
+    {
-            public MultiFramework() => this.AddJob(
+        public MultiFramework() => this.AddJob(
-                    Job.Default.WithRuntime(CoreRuntime.Core60).WithArguments(new Argument[] { new MsBuildArgument("/p:DebugType=portable") }));
+                Job.Default.WithRuntime(CoreRuntime.Core60).WithArguments(new Argument[] { new MsBuildArgument("/p:DebugType=portable") }));
-        }
+    }
 
-        public class ShortMultiFramework : Config
+    public class ShortMultiFramework : Config
-        {
+    {
-            public ShortMultiFramework() => this.AddJob(
+        public ShortMultiFramework() => this.AddJob(
-                    Job.Default.WithRuntime(CoreRuntime.Core60).WithLaunchCount(1).WithWarmupCount(3).WithIterationCount(3).WithArguments(new Argument[] { new MsBuildArgument("/p:DebugType=portable") }));
+                Job.Default.WithRuntime(CoreRuntime.Core60).WithLaunchCount(1).WithWarmupCount(3).WithIterationCount(3).WithArguments(new Argument[] { new MsBuildArgument("/p:DebugType=portable") }));
-        }
+    }
 
-        public class ShortCore31 : Config
+    public class ShortCore31 : Config
-        {
+    {
-            public ShortCore31()
+        public ShortCore31()
-                => this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core31).WithLaunchCount(1).WithWarmupCount(3).WithIterationCount(3));
+            => this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core31).WithLaunchCount(1).WithWarmupCount(3).WithIterationCount(3));
-        }
+    }
 
 #if OS_WINDOWS
-        private bool IsElevated => new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);
+    private bool IsElevated => new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);
 #endif
-    }
 }

tests/ImageSharp.Benchmarks/General/Adler32Benchmark.cs

@@ -1,72 +1,70 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Compression.Zlib;
 using SharpAdler32 = ICSharpCode.SharpZipLib.Checksum.Adler32;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
-{
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class Adler32Benchmark
-    {
-        private byte[] data;
-        private readonly SharpAdler32 adler = new SharpAdler32();
 
-        [Params(1024, 2048, 4096)]
+[Config(typeof(Config.ShortMultiFramework))]
-        public int Count { get; set; }
+public class Adler32Benchmark
+{
+    private byte[] data;
+    private readonly SharpAdler32 adler = new SharpAdler32();
 
-        [GlobalSetup]
+    [Params(1024, 2048, 4096)]
-        public void SetUp()
+    public int Count { get; set; }
-        {
-            this.data = new byte[this.Count];
-            new Random(1).NextBytes(this.data);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public long SharpZipLibCalculate()
+    public void SetUp()
-        {
+    {
-            this.adler.Reset();
+        this.data = new byte[this.Count];
-            this.adler.Update(this.data);
+        new Random(1).NextBytes(this.data);
-            return this.adler.Value;
+    }
-        }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public uint SixLaborsCalculate()
+    public long SharpZipLibCalculate()
-        {
+    {
-            return Adler32.Calculate(this.data);
+        this.adler.Reset();
-        }
+        this.adler.Update(this.data);
+        return this.adler.Value;
     }
 
-    // ########## 17/05/2020 ##########
+    [Benchmark]
-    //
+    public uint SixLaborsCalculate()
-    // |               Method |       Runtime | Count |        Mean |       Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+    {
-    // |--------------------- |-------------- |------ |------------:|------------:|----------:|------:|--------:|------:|------:|------:|----------:|
+        return Adler32.Calculate(this.data);
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  1024 |   793.18 ns |   775.66 ns | 42.516 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    }
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  1024 |   384.86 ns |    15.64 ns |  0.857 ns |  0.49 |    0.03 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  1024 |   790.31 ns |   353.34 ns | 19.368 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  1024 |   465.28 ns |   652.41 ns | 35.761 ns |  0.59 |    0.03 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  1024 |   877.25 ns |    97.89 ns |  5.365 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  1024 |    45.60 ns |    13.28 ns |  0.728 ns |  0.05 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  2048 | 1,537.04 ns |   428.44 ns | 23.484 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  2048 |   849.76 ns | 1,066.34 ns | 58.450 ns |  0.55 |    0.04 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  2048 | 1,616.97 ns |   276.70 ns | 15.167 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  2048 |   790.77 ns |   691.71 ns | 37.915 ns |  0.49 |    0.03 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  2048 | 1,735.11 ns | 1,374.22 ns | 75.325 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  2048 |    87.80 ns |    56.84 ns |  3.116 ns |  0.05 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  4096 | 3,054.53 ns |   796.41 ns | 43.654 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  4096 | 1,538.90 ns |   487.02 ns | 26.695 ns |  0.50 |    0.01 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  4096 | 3,223.48 ns |    32.32 ns |  1.771 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  4096 | 1,547.60 ns |   309.72 ns | 16.977 ns |  0.48 |    0.01 |     - |     - |     - |         - |
-    // |                      |               |       |             |             |           |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  4096 | 3,672.33 ns | 1,095.81 ns | 60.065 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  4096 |   159.44 ns |    36.31 ns |  1.990 ns |  0.04 |    0.00 |     - |     - |     - |         - |
 }
+
+// ########## 17/05/2020 ##########
+//
+// |               Method |       Runtime | Count |        Mean |       Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |--------------------- |-------------- |------ |------------:|------------:|----------:|------:|--------:|------:|------:|------:|----------:|
+// | SharpZipLibCalculate |    .NET 4.7.2 |  1024 |   793.18 ns |   775.66 ns | 42.516 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  1024 |   384.86 ns |    15.64 ns |  0.857 ns |  0.49 |    0.03 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  1024 |   790.31 ns |   353.34 ns | 19.368 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  1024 |   465.28 ns |   652.41 ns | 35.761 ns |  0.59 |    0.03 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  1024 |   877.25 ns |    97.89 ns |  5.365 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  1024 |    45.60 ns |    13.28 ns |  0.728 ns |  0.05 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate |    .NET 4.7.2 |  2048 | 1,537.04 ns |   428.44 ns | 23.484 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  2048 |   849.76 ns | 1,066.34 ns | 58.450 ns |  0.55 |    0.04 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  2048 | 1,616.97 ns |   276.70 ns | 15.167 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  2048 |   790.77 ns |   691.71 ns | 37.915 ns |  0.49 |    0.03 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  2048 | 1,735.11 ns | 1,374.22 ns | 75.325 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  2048 |    87.80 ns |    56.84 ns |  3.116 ns |  0.05 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate |    .NET 4.7.2 |  4096 | 3,054.53 ns |   796.41 ns | 43.654 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  4096 | 1,538.90 ns |   487.02 ns | 26.695 ns |  0.50 |    0.01 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  4096 | 3,223.48 ns |    32.32 ns |  1.771 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  4096 | 1,547.60 ns |   309.72 ns | 16.977 ns |  0.48 |    0.01 |     - |     - |     - |         - |
+// |                      |               |       |             |             |           |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  4096 | 3,672.33 ns | 1,095.81 ns | 60.065 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  4096 |   159.44 ns |    36.31 ns |  1.990 ns |  0.04 |    0.00 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/General/Array2D.cs

@@ -1,130 +1,126 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-using SixLabors.ImageSharp;
+namespace SixLabors.ImageSharp.Benchmarks.General;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+/*
-{
+                                  Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
-    /*
-                                      Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
 -------------------------------------------- |------ |---------:|---------:|---------:|-------:|---------:|
- 'Emulated 2D array access using flat array' |    32 | 224.2 ns | 4.739 ns | 13.75 ns |   0.65 |     0.07 |
+'Emulated 2D array access using flat array' |    32 | 224.2 ns | 4.739 ns | 13.75 ns |   0.65 |     0.07 |
-               'Array access using 2D array' |    32 | 346.6 ns | 9.225 ns | 26.91 ns |   1.00 |     0.00 |
+           'Array access using 2D array' |    32 | 346.6 ns | 9.225 ns | 26.91 ns |   1.00 |     0.00 |
-         'Array access using a jagged array' |    32 | 229.3 ns | 6.028 ns | 17.58 ns |   0.67 |     0.07 |
+     'Array access using a jagged array' |    32 | 229.3 ns | 6.028 ns | 17.58 ns |   0.67 |     0.07 |
-            'Array access using DenseMatrix' |    32 | 223.2 ns | 5.248 ns | 15.22 ns |   0.65 |     0.07 |
+        'Array access using DenseMatrix' |    32 | 223.2 ns | 5.248 ns | 15.22 ns |   0.65 |     0.07 |
-
+
-     *
+ *
-     */
+ */
-    public class Array2D
+public class Array2D
-    {
+{
-        private float[] flatArray;
+    private float[] flatArray;
 
-        private float[,] array2D;
+    private float[,] array2D;
 
-        private float[][] jaggedData;
+    private float[][] jaggedData;
 
-        private DenseMatrix<float> matrix;
+    private DenseMatrix<float> matrix;
 
-        [Params(4, 16, 32)]
+    [Params(4, 16, 32)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        public int Min { get; private set; }
+    public int Min { get; private set; }
 
-        public int Max { get; private set; }
+    public int Max { get; private set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void SetUp()
+    public void SetUp()
-        {
+    {
-            this.flatArray = new float[this.Count * this.Count];
+        this.flatArray = new float[this.Count * this.Count];
-            this.array2D = new float[this.Count, this.Count];
+        this.array2D = new float[this.Count, this.Count];
-            this.jaggedData = new float[this.Count][];
+        this.jaggedData = new float[this.Count][];
 
-            for (int i = 0; i < this.Count; i++)
+        for (int i = 0; i < this.Count; i++)
-            {
+        {
-                this.jaggedData[i] = new float[this.Count];
+            this.jaggedData[i] = new float[this.Count];
-            }
+        }
 
-            this.matrix = new DenseMatrix<float>(this.array2D);
+        this.matrix = new DenseMatrix<float>(this.array2D);
 
-            this.Min = (this.Count / 2) - 10;
+        this.Min = (this.Count / 2) - 10;
-            this.Min = Math.Max(0, this.Min);
+        this.Min = Math.Max(0, this.Min);
-            this.Max = this.Min + Math.Min(10, this.Count);
+        this.Max = this.Min + Math.Min(10, this.Count);
-        }
+    }
 
-        [Benchmark(Description = "Emulated 2D array access using flat array")]
+    [Benchmark(Description = "Emulated 2D array access using flat array")]
-        public float FlatArrayIndex()
+    public float FlatArrayIndex()
+    {
+        float[] a = this.flatArray;
+        float s = 0;
+        int count = this.Count;
+        for (int i = this.Min; i < this.Max; i++)
         {
-            float[] a = this.flatArray;
+            for (int j = this.Min; j < this.Max; j++)
-            float s = 0;
-            int count = this.Count;
-            for (int i = this.Min; i < this.Max; i++)
             {
-                for (int j = this.Min; j < this.Max; j++)
+                ref float v = ref a[(count * i) + j];
-                {
+                v = i * j;
-                    ref float v = ref a[(count * i) + j];
+                s += v;
-                    v = i * j;
-                    s += v;
-                }
             }
-
-            return s;
         }
 
-        [Benchmark(Baseline = true, Description = "Array access using 2D array")]
+        return s;
-        public float Array2DIndex()
+    }
+
+    [Benchmark(Baseline = true, Description = "Array access using 2D array")]
+    public float Array2DIndex()
+    {
+        float s = 0;
+        float[,] a = this.array2D;
+        for (int i = this.Min; i < this.Max; i++)
         {
-            float s = 0;
+            for (int j = this.Min; j < this.Max; j++)
-            float[,] a = this.array2D;
-            for (int i = this.Min; i < this.Max; i++)
             {
-                for (int j = this.Min; j < this.Max; j++)
+                ref float v = ref a[i, j];
-                {
+                v = i * j;
-                    ref float v = ref a[i, j];
+                s += v;
-                    v = i * j;
-                    s += v;
-                }
             }
-
-            return s;
         }
 
-        [Benchmark(Description = "Array access using a jagged array")]
+        return s;
-        public float ArrayJaggedIndex()
+    }
+
+    [Benchmark(Description = "Array access using a jagged array")]
+    public float ArrayJaggedIndex()
+    {
+        float s = 0;
+        float[][] a = this.jaggedData;
+        for (int i = this.Min; i < this.Max; i++)
         {
-            float s = 0;
+            for (int j = this.Min; j < this.Max; j++)
-            float[][] a = this.jaggedData;
-            for (int i = this.Min; i < this.Max; i++)
             {
-                for (int j = this.Min; j < this.Max; j++)
+                ref float v = ref a[i][j];
-                {
+                v = i * j;
-                    ref float v = ref a[i][j];
+                s += v;
-                    v = i * j;
-                    s += v;
-                }
             }
-
-            return s;
         }
 
-        [Benchmark(Description = "Array access using DenseMatrix")]
+        return s;
-        public float ArrayMatrixIndex()
+    }
+
+    [Benchmark(Description = "Array access using DenseMatrix")]
+    public float ArrayMatrixIndex()
+    {
+        float s = 0;
+        DenseMatrix<float> a = this.matrix;
+        for (int i = this.Min; i < this.Max; i++)
         {
-            float s = 0;
+            for (int j = this.Min; j < this.Max; j++)
-            DenseMatrix<float> a = this.matrix;
-            for (int i = this.Min; i < this.Max; i++)
             {
-                for (int j = this.Min; j < this.Max; j++)
+                ref float v = ref a[i, j];
-                {
+                v = i * j;
-                    ref float v = ref a[i, j];
+                s += v;
-                    v = i * j;
-                    s += v;
-                }
             }
-
-            return s;
         }
+
+        return s;
     }
 }

tests/ImageSharp.Benchmarks/General/ArrayReverse.cs

@@ -1,59 +1,57 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
+
+public class ArrayReverse
 {
-    public class ArrayReverse
+    [Params(4, 16, 32)]
-    {
+    public int Count { get; set; }
-        [Params(4, 16, 32)]
-        public int Count { get; set; }
 
-        private byte[] source;
+    private byte[] source;
 
-        private byte[] destination;
+    private byte[] destination;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void SetUp()
+    public void SetUp()
-        {
+    {
-            this.source = new byte[this.Count];
+        this.source = new byte[this.Count];
-            this.destination = new byte[this.Count];
+        this.destination = new byte[this.Count];
-        }
+    }
 
-        [Benchmark(Baseline = true, Description = "Copy using Array.Reverse()")]
+    [Benchmark(Baseline = true, Description = "Copy using Array.Reverse()")]
-        public void ReverseArray()
+    public void ReverseArray()
-        {
+    {
-            Array.Reverse(this.source, 0, this.Count);
+        Array.Reverse(this.source, 0, this.Count);
-        }
+    }
+
+    [Benchmark(Description = "Reverse using loop")]
+    public void ReverseLoop()
+    {
+        this.ReverseBytes(this.source, 0, this.Count);
 
-        [Benchmark(Description = "Reverse using loop")]
+        /*
-        public void ReverseLoop()
+         for (int i = 0; i < this.source.Length / 2; i++)
         {
-            this.ReverseBytes(this.source, 0, this.Count);
+            byte tmp = this.source[i];
-
+            this.source[i] = this.source[this.source.Length - i - 1];
-            /*
+            this.source[this.source.Length - i - 1] = tmp;
-             for (int i = 0; i < this.source.Length / 2; i++)
+        }*/
-            {
+    }
-                byte tmp = this.source[i];
-                this.source[i] = this.source[this.source.Length - i - 1];
-                this.source[this.source.Length - i - 1] = tmp;
-            }*/
-        }
 
-        public void ReverseBytes(byte[] source, int index, int length)
+    public void ReverseBytes(byte[] source, int index, int length)
+    {
+        int i = index;
+        int j = index + length - 1;
+        while (i < j)
         {
-            int i = index;
+            byte temp = source[i];
-            int j = index + length - 1;
+            source[i] = source[j];
-            while (i < j)
+            source[j] = temp;
-            {
+            i++;
-                byte temp = source[i];
+            j--;
-                source[i] = source[j];
-                source[j] = temp;
-                i++;
-                j--;
-            }
         }
     }
 }

tests/ImageSharp.Benchmarks/General/BasicMath/Abs.cs

@@ -1,43 +1,41 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class Abs
 {
-    public class Abs
+    [Params(-1, 1)]
-    {
+    public int X { get; set; }
-        [Params(-1, 1)]
-        public int X { get; set; }
 
-        [Benchmark(Baseline = true, Description = "Maths Abs")]
+    [Benchmark(Baseline = true, Description = "Maths Abs")]
-        public int MathAbs()
+    public int MathAbs()
-        {
+    {
-            int x = this.X;
+        int x = this.X;
-            return Math.Abs(x);
+        return Math.Abs(x);
-        }
+    }
 
-        [Benchmark(Description = "Conditional Abs")]
+    [Benchmark(Description = "Conditional Abs")]
-        public int ConditionalAbs()
+    public int ConditionalAbs()
-        {
+    {
-            int x = this.X;
+        int x = this.X;
-            return x < 0 ? -x : x;
+        return x < 0 ? -x : x;
-        }
+    }
 
-        [Benchmark(Description = "Bitwise Abs")]
+    [Benchmark(Description = "Bitwise Abs")]
-        public int AbsBitwise()
+    public int AbsBitwise()
-        {
+    {
-            int x = this.X;
+        int x = this.X;
-            return (x ^ (x >> 31)) - (x >> 31);
+        return (x ^ (x >> 31)) - (x >> 31);
-        }
+    }
 
-        [Benchmark(Description = "Bitwise Abs With Variable")]
+    [Benchmark(Description = "Bitwise Abs With Variable")]
-        public int AbsBitwiseVer()
+    public int AbsBitwiseVer()
-        {
+    {
-            int x = this.X;
+        int x = this.X;
-            int y = x >> 31;
+        int y = x >> 31;
-            return (x ^ y) - y;
+        return (x ^ y) - y;
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/BasicMath/ClampFloat.cs

@@ -1,70 +1,68 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class ClampFloat
 {
-    public class ClampFloat
+    private readonly float min = -1.5f;
+    private readonly float max = 2.5f;
+    private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
+
+    [Benchmark(Baseline = true)]
+    public float UsingMathF()
     {
-        private readonly float min = -1.5f;
+        float acc = 0;
-        private readonly float max = 2.5f;
-        private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
 
-        [Benchmark(Baseline = true)]
+        for (int i = 0; i < Values.Length; i++)
-        public float UsingMathF()
         {
-            float acc = 0;
+            acc += ClampUsingMathF(Values[i], this.min, this.max);
+        }
 
-            for (int i = 0; i < Values.Length; i++)
+        return acc;
-            {
+    }
-                acc += ClampUsingMathF(Values[i], this.min, this.max);
-            }
 
-            return acc;
+    [Benchmark]
-        }
+    public float UsingBranching()
+    {
+        float acc = 0;
 
-        [Benchmark]
+        for (int i = 0; i < Values.Length; i++)
-        public float UsingBranching()
         {
-            float acc = 0;
+            acc += ClampUsingBranching(Values[i], this.min, this.max);
+        }
 
-            for (int i = 0; i < Values.Length; i++)
+        return acc;
-            {
+    }
-                acc += ClampUsingBranching(Values[i], this.min, this.max);
-            }
 
-            return acc;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        }
+    private static float ClampUsingMathF(float x, float min, float max)
+    {
+        return Math.Min(max, Math.Max(min, x));
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static float ClampUsingMathF(float x, float min, float max)
+    private static float ClampUsingBranching(float x, float min, float max)
+    {
+        if (x >= max)
         {
-            return Math.Min(max, Math.Max(min, x));
+            return max;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        if (x <= min)
-        private static float ClampUsingBranching(float x, float min, float max)
         {
-            if (x >= max)
+            return min;
-            {
-                return max;
-            }
-
-            if (x <= min)
-            {
-                return min;
-            }
-
-            return x;
         }
 
-        // RESULTS:
+        return x;
-        //          Method |     Mean |     Error |    StdDev | Scaled |
-        // --------------- |---------:|----------:|----------:|-------:|
-        //      UsingMathF | 30.37 ns | 0.3764 ns | 0.3337 ns |   1.00 |
-        //  UsingBranching | 18.66 ns | 0.1043 ns | 0.0871 ns |   0.61 |
     }
+
+    // RESULTS:
+    //          Method |     Mean |     Error |    StdDev | Scaled |
+    // --------------- |---------:|----------:|----------:|-------:|
+    //      UsingMathF | 30.37 ns | 0.3764 ns | 0.3337 ns |   1.00 |
+    //  UsingBranching | 18.66 ns | 0.1043 ns | 0.0871 ns |   0.61 |
 }

tests/ImageSharp.Benchmarks/General/BasicMath/ClampInt32IntoByte.cs

@@ -1,92 +1,90 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class ClampInt32IntoByte
 {
-    public class ClampInt32IntoByte
+    [Params(-1, 0, 255, 256)]
+    public int Value { get; set; }
+
+    [Benchmark(Baseline = true, Description = "Maths Clamp")]
+    public byte ClampMaths()
     {
-        [Params(-1, 0, 255, 256)]
+       int value = this.Value;
-        public int Value { get; set; }
+       return (byte)Math.Min(Math.Max(byte.MinValue, value), byte.MaxValue);
+    }
 
-        [Benchmark(Baseline = true, Description = "Maths Clamp")]
+    [Benchmark(Description = "No Maths Clamp")]
-        public byte ClampMaths()
+    public byte ClampNoMaths()
-        {
+    {
-           int value = this.Value;
+       int value = this.Value;
-           return (byte)Math.Min(Math.Max(byte.MinValue, value), byte.MaxValue);
+       value = value >= byte.MaxValue ? byte.MaxValue : value;
-        }
+       return (byte)(value <= byte.MinValue ? byte.MinValue : value);
+    }
 
-        [Benchmark(Description = "No Maths Clamp")]
+    [Benchmark(Description = "No Maths No Equals Clamp")]
-        public byte ClampNoMaths()
+    public byte ClampNoMathsNoEquals()
-        {
+    {
-           int value = this.Value;
+       int value = this.Value;
-           value = value >= byte.MaxValue ? byte.MaxValue : value;
+       value = value > byte.MaxValue ? byte.MaxValue : value;
-           return (byte)(value <= byte.MinValue ? byte.MinValue : value);
+       return (byte)(value < byte.MinValue ? byte.MinValue : value);
-        }
+    }
 
-        [Benchmark(Description = "No Maths No Equals Clamp")]
+    [Benchmark(Description = "No Maths Clamp No Ternary")]
-        public byte ClampNoMathsNoEquals()
+    public byte ClampNoMathsNoTernary()
+    {
+        int value = this.Value;
+
+        if (value >= byte.MaxValue)
         {
-           int value = this.Value;
+            return byte.MaxValue;
-           value = value > byte.MaxValue ? byte.MaxValue : value;
-           return (byte)(value < byte.MinValue ? byte.MinValue : value);
         }
 
-        [Benchmark(Description = "No Maths Clamp No Ternary")]
+        if (value <= byte.MinValue)
-        public byte ClampNoMathsNoTernary()
         {
-            int value = this.Value;
+            return byte.MinValue;
-
-            if (value >= byte.MaxValue)
-            {
-                return byte.MaxValue;
-            }
-
-            if (value <= byte.MinValue)
-            {
-                return byte.MinValue;
-            }
-
-            return (byte)value;
         }
 
-        [Benchmark(Description = "No Maths No Equals Clamp No Ternary")]
+        return (byte)value;
-        public byte ClampNoMathsEqualsNoTernary()
+    }
-        {
-           int value = this.Value;
 
-           if (value > byte.MaxValue)
+    [Benchmark(Description = "No Maths No Equals Clamp No Ternary")]
-           {
+    public byte ClampNoMathsEqualsNoTernary()
-               return byte.MaxValue;
+    {
-           }
+       int value = this.Value;
 
-           if (value < byte.MinValue)
+       if (value > byte.MaxValue)
-           {
+       {
-               return byte.MinValue;
+           return byte.MaxValue;
-           }
+       }
 
-           return (byte)value;
+       if (value < byte.MinValue)
-        }
+       {
+           return byte.MinValue;
+       }
 
-        [Benchmark(Description = "Clamp using Bitwise Abs")]
+       return (byte)value;
-        public byte ClampBitwise()
+    }
-        {
-            int x = this.Value;
-            int absMax = byte.MaxValue - x;
-            x = (x + byte.MaxValue - AbsBitwiseVer(ref absMax)) >> 1;
-            x = (x + byte.MinValue + AbsBitwiseVer(ref x)) >> 1;
 
-            return (byte)x;
+    [Benchmark(Description = "Clamp using Bitwise Abs")]
-        }
+    public byte ClampBitwise()
+    {
+        int x = this.Value;
+        int absMax = byte.MaxValue - x;
+        x = (x + byte.MaxValue - AbsBitwiseVer(ref absMax)) >> 1;
+        x = (x + byte.MinValue + AbsBitwiseVer(ref x)) >> 1;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return (byte)x;
-        private static int AbsBitwiseVer(ref int x)
+    }
-        {
+
-            int y = x >> 31;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            return (x ^ y) - y;
+    private static int AbsBitwiseVer(ref int x)
-        }
+    {
+        int y = x >> 31;
+        return (x ^ y) - y;
     }
 }

tests/ImageSharp.Benchmarks/General/BasicMath/ClampSpan.cs

@@ -1,43 +1,41 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class ClampSpan
 {
-    public class ClampSpan
+    private static readonly int[] A = new int[2048];
+    private static readonly int[] B = new int[2048];
+
+    public void Setup()
     {
-        private static readonly int[] A = new int[2048];
+        var r = new Random();
-        private static readonly int[] B = new int[2048];
 
-        public void Setup()
+        for (int i = 0; i < A.Length; i++)
         {
-            var r = new Random();
+            int x = r.Next();
-
+            A[i] = x;
-            for (int i = 0; i < A.Length; i++)
+            B[i] = x;
-            {
-                int x = r.Next();
-                A[i] = x;
-                B[i] = x;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void ClampNoIntrinsics()
+    public void ClampNoIntrinsics()
+    {
+        for (int i = 0; i < A.Length; i++)
         {
-            for (int i = 0; i < A.Length; i++)
+            ref int x = ref A[i];
-            {
+            x = Numerics.Clamp(x, 64, 128);
-                ref int x = ref A[i];
-                x = Numerics.Clamp(x, 64, 128);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void ClampVectorIntrinsics()
+    public void ClampVectorIntrinsics()
-        {
+    {
-            Numerics.Clamp(B, 64, 128);
+        Numerics.Clamp(B, 64, 128);
-        }
     }
 }
 

tests/ImageSharp.Benchmarks/General/BasicMath/ClampVector4.cs

@@ -5,56 +5,55 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class ClampVector4
 {
-    public class ClampVector4
+    private readonly float min = -1.5f;
+    private readonly float max = 2.5f;
+    private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
+
+    [Benchmark(Baseline = true)]
+    public Vector4 UsingVectorClamp()
     {
-        private readonly float min = -1.5f;
+        Vector4 acc = Vector4.Zero;
-        private readonly float max = 2.5f;
-        private static readonly float[] Values = { -10, -5, -3, -1.5f, -0.5f, 0f, 1f, 1.5f, 2.5f, 3, 10 };
 
-        [Benchmark(Baseline = true)]
+        for (int i = 0; i < Values.Length; i++)
-        public Vector4 UsingVectorClamp()
         {
-            Vector4 acc = Vector4.Zero;
+            acc += ClampUsingVectorClamp(Values[i], this.min, this.max);
-
-            for (int i = 0; i < Values.Length; i++)
-            {
-                acc += ClampUsingVectorClamp(Values[i], this.min, this.max);
-            }
-
-            return acc;
         }
 
-        [Benchmark]
+        return acc;
-        public Vector4 UsingVectorMinMax()
+    }
-        {
-            Vector4 acc = Vector4.Zero;
-
-            for (int i = 0; i < Values.Length; i++)
-            {
-                acc += ClampUsingVectorMinMax(Values[i], this.min, this.max);
-            }
 
-            return acc;
+    [Benchmark]
-        }
+    public Vector4 UsingVectorMinMax()
+    {
+        Vector4 acc = Vector4.Zero;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        for (int i = 0; i < Values.Length; i++)
-        private static Vector4 ClampUsingVectorClamp(float x, float min, float max)
         {
-            return Vector4.Clamp(new Vector4(x), new Vector4(min), new Vector4(max));
+            acc += ClampUsingVectorMinMax(Values[i], this.min, this.max);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return acc;
-        private static Vector4 ClampUsingVectorMinMax(float x, float min, float max)
+    }
-        {
+
-            return Vector4.Min(new Vector4(max), Vector4.Max(new Vector4(min), new Vector4(x)));
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        }
+    private static Vector4 ClampUsingVectorClamp(float x, float min, float max)
+    {
+        return Vector4.Clamp(new Vector4(x), new Vector4(min), new Vector4(max));
+    }
 
-        // RESULTS
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        // |            Method |     Mean |    Error |   StdDev | Ratio |
+    private static Vector4 ClampUsingVectorMinMax(float x, float min, float max)
-        // |------------------ |---------:|---------:|---------:|------:|
+    {
-        // |  UsingVectorClamp | 75.21 ns | 1.572 ns | 4.057 ns |  1.00 |
+        return Vector4.Min(new Vector4(max), Vector4.Max(new Vector4(min), new Vector4(x)));
-        // | UsingVectorMinMax | 15.35 ns | 0.356 ns | 0.789 ns |  0.20 |
     }
+
+    // RESULTS
+    // |            Method |     Mean |    Error |   StdDev | Ratio |
+    // |------------------ |---------:|---------:|---------:|------:|
+    // |  UsingVectorClamp | 75.21 ns | 1.572 ns | 4.057 ns |  1.00 |
+    // | UsingVectorMinMax | 15.35 ns | 0.356 ns | 0.789 ns |  0.20 |
 }

tests/ImageSharp.Benchmarks/General/BasicMath/ModuloPowerOfTwoConstant.cs

@@ -3,23 +3,22 @@
 
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+[LongRunJob]
+public class ModuloPowerOfTwoConstant
 {
-    [LongRunJob]
+    private readonly int value = 42;
-    public class ModuloPowerOfTwoConstant
-    {
-        private readonly int value = 42;
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public int Standard()
+    public int Standard()
-        {
+    {
-            return this.value % 8;
+        return this.value % 8;
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public int Bitwise()
+    public int Bitwise()
-        {
+    {
-            return Numerics.Modulo8(this.value);
+        return Numerics.Modulo8(this.value);
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/BasicMath/ModuloPowerOfTwoVariable.cs

@@ -3,32 +3,31 @@
 
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
-{
-    [LongRunJob]
-    public class ModuloPowerOfTwoVariable
-    {
-        private readonly int value = 42;
 
-        private readonly int m = 32;
+[LongRunJob]
+public class ModuloPowerOfTwoVariable
+{
+    private readonly int value = 42;
 
-        [Benchmark(Baseline = true)]
+    private readonly int m = 32;
-        public int Standard()
-        {
-            return this.value % this.m;
-        }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public int Bitwise()
+    public int Standard()
-        {
+    {
-            return Numerics.ModuloP2(this.value, this.m);
+        return this.value % this.m;
-        }
+    }
 
-        // RESULTS:
+    [Benchmark]
-        //
+    public int Bitwise()
-        //    Method |      Mean |     Error |    StdDev |    Median | Scaled | ScaledSD |
+    {
-        // --------- |----------:|----------:|----------:|----------:|-------:|---------:|
+        return Numerics.ModuloP2(this.value, this.m);
-        //  Standard | 1.2465 ns | 0.0093 ns | 0.0455 ns | 1.2423 ns |   1.00 |     0.00 |
-        //   Bitwise | 0.0265 ns | 0.0103 ns | 0.0515 ns | 0.0000 ns |   0.02 |     0.04 |
     }
+
+    // RESULTS:
+    //
+    //    Method |      Mean |     Error |    StdDev |    Median | Scaled | ScaledSD |
+    // --------- |----------:|----------:|----------:|----------:|-------:|---------:|
+    //  Standard | 1.2465 ns | 0.0093 ns | 0.0455 ns | 1.2423 ns |   1.00 |     0.00 |
+    //   Bitwise | 0.0265 ns | 0.0103 ns | 0.0515 ns | 0.0000 ns |   0.02 |     0.04 |
 }

tests/ImageSharp.Benchmarks/General/BasicMath/Pow.cs

@@ -1,42 +1,40 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class Pow
 {
-    public class Pow
+    [Params(-1.333F, 1.333F)]
-    {
+    public float X { get; set; }
-        [Params(-1.333F, 1.333F)]
-        public float X { get; set; }
 
-        [Benchmark(Baseline = true, Description = "Math.Pow 2")]
+    [Benchmark(Baseline = true, Description = "Math.Pow 2")]
-        public float MathPow()
+    public float MathPow()
-        {
+    {
-            float x = this.X;
+        float x = this.X;
-            return (float)Math.Pow(x, 2);
+        return (float)Math.Pow(x, 2);
-        }
+    }
 
-        [Benchmark(Description = "Pow x2")]
+    [Benchmark(Description = "Pow x2")]
-        public float PowMult()
+    public float PowMult()
-        {
+    {
-            float x = this.X;
+        float x = this.X;
-            return x * x;
+        return x * x;
-        }
+    }
 
-        [Benchmark(Description = "Math.Pow 3")]
+    [Benchmark(Description = "Math.Pow 3")]
-        public float MathPow3()
+    public float MathPow3()
-        {
+    {
-            float x = this.X;
+        float x = this.X;
-            return (float)Math.Pow(x, 3);
+        return (float)Math.Pow(x, 3);
-        }
+    }
 
-        [Benchmark(Description = "Pow x3")]
+    [Benchmark(Description = "Pow x3")]
-        public float PowMult3()
+    public float PowMult3()
-        {
+    {
-            float x = this.X;
+        float x = this.X;
-            return x * x * x;
+        return x * x * x;
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/BasicMath/Round.cs

@@ -1,25 +1,23 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath
+namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath;
+
+public class Round
 {
-    public class Round
+    private const float Input = .51F;
-    {
-        private const float Input = .51F;
 
-        [Benchmark]
+    [Benchmark]
-        public int ConvertTo() => Convert.ToInt32(Input);
+    public int ConvertTo() => Convert.ToInt32(Input);
 
-        [Benchmark]
+    [Benchmark]
-        public int MathRound() => (int)Math.Round(Input);
+    public int MathRound() => (int)Math.Round(Input);
 
-        // Results 20th Jan 2019
+    // Results 20th Jan 2019
-        //    Method |      Mean |     Error |    StdDev |    Median |
+    //    Method |      Mean |     Error |    StdDev |    Median |
-        //---------- |----------:|----------:|----------:|----------:|
+    //---------- |----------:|----------:|----------:|----------:|
-        // ConvertTo | 3.1967 ns | 0.1234 ns | 0.2129 ns | 3.2340 ns |
+    // ConvertTo | 3.1967 ns | 0.1234 ns | 0.2129 ns | 3.2340 ns |
-        // MathRound | 0.0528 ns | 0.0374 ns | 0.1079 ns | 0.0000 ns |
+    // MathRound | 0.0528 ns | 0.0374 ns | 0.1079 ns | 0.0000 ns |
-    }
 }

tests/ImageSharp.Benchmarks/General/Buffer2D_DangerousGetRowSpan.cs

@@ -5,42 +5,41 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
+
+public class Buffer2D_DangerousGetRowSpan
 {
-    public class Buffer2D_DangerousGetRowSpan
+    private const int Height = 1024;
+
+    [Params(0.5, 2.0, 10.0)]
+    public double SizeMegaBytes { get; set; }
+
+    private Buffer2D<Rgba32> buffer;
+
+    [GlobalSetup]
+    public unsafe void Setup()
     {
-        private const int Height = 1024;
+        int totalElements = (int)(1024 * 1024 * this.SizeMegaBytes) / sizeof(Rgba32);
-
+
-        [Params(0.5, 2.0, 10.0)]
+        int width = totalElements / Height;
-        public double SizeMegaBytes { get; set; }
+        MemoryAllocator allocator = Configuration.Default.MemoryAllocator;
-
+        this.buffer = allocator.Allocate2D<Rgba32>(width, Height);
-        private Buffer2D<Rgba32> buffer;
-
-        [GlobalSetup]
-        public unsafe void Setup()
-        {
-            int totalElements = (int)(1024 * 1024 * this.SizeMegaBytes) / sizeof(Rgba32);
-
-            int width = totalElements / Height;
-            MemoryAllocator allocator = Configuration.Default.MemoryAllocator;
-            this.buffer = allocator.Allocate2D<Rgba32>(width, Height);
-        }
-
-        [GlobalCleanup]
-        public void Cleanup() => this.buffer.Dispose();
-
-        [Benchmark]
-        public int DangerousGetRowSpan() =>
-            this.buffer.DangerousGetRowSpan(1).Length +
-            this.buffer.DangerousGetRowSpan(Height - 1).Length;
-
-        // BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19044
-        // Intel Core i9-10900X CPU 3.70GHz, 1 CPU, 20 logical and 10 physical cores
-        //
-        // |              Method | SizeMegaBytes |      Mean |     Error |    StdDev |
-        // |-------------------- |-------------- |----------:|----------:|----------:|
-        // | DangerousGetRowSpan |           0.5 |  7.498 ns | 0.1784 ns | 0.3394 ns |
-        // | DangerousGetRowSpan |             2 |  6.542 ns | 0.1565 ns | 0.3659 ns |
-        // | DangerousGetRowSpan |            10 | 38.556 ns | 0.6604 ns | 0.8587 ns |
     }
+
+    [GlobalCleanup]
+    public void Cleanup() => this.buffer.Dispose();
+
+    [Benchmark]
+    public int DangerousGetRowSpan() =>
+        this.buffer.DangerousGetRowSpan(1).Length +
+        this.buffer.DangerousGetRowSpan(Height - 1).Length;
+
+    // BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19044
+    // Intel Core i9-10900X CPU 3.70GHz, 1 CPU, 20 logical and 10 physical cores
+    //
+    // |              Method | SizeMegaBytes |      Mean |     Error |    StdDev |
+    // |-------------------- |-------------- |----------:|----------:|----------:|
+    // | DangerousGetRowSpan |           0.5 |  7.498 ns | 0.1784 ns | 0.3394 ns |
+    // | DangerousGetRowSpan |             2 |  6.542 ns | 0.1565 ns | 0.3659 ns |
+    // | DangerousGetRowSpan |            10 | 38.556 ns | 0.6604 ns | 0.8587 ns |
 }

tests/ImageSharp.Benchmarks/General/CopyBuffers.cs

@@ -1,228 +1,226 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
+
+/// <summary>
+/// Compare different methods for copying native and/or managed buffers.
+/// Conclusions:
+/// - Span.CopyTo() has terrible performance on classic .NET Framework
+/// - Buffer.MemoryCopy() performance is good enough for all sizes (but needs pinning)
+/// </summary>
+[Config(typeof(Config.ShortMultiFramework))]
+public class CopyBuffers
 {
-    /// <summary>
+    private byte[] destArray;
-    /// Compare different methods for copying native and/or managed buffers.
+
-    /// Conclusions:
+    private MemoryHandle destHandle;
-    /// - Span.CopyTo() has terrible performance on classic .NET Framework
+
-    /// - Buffer.MemoryCopy() performance is good enough for all sizes (but needs pinning)
+    private Memory<byte> destMemory;
-    /// </summary>
+
-    [Config(typeof(Config.ShortMultiFramework))]
+    private byte[] sourceArray;
-    public class CopyBuffers
+
+    private MemoryHandle sourceHandle;
+
+    private Memory<byte> sourceMemory;
+
+    [Params(10, 50, 100, 1000, 10000)]
+    public int Count { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        this.sourceArray = new byte[this.Count];
+        this.sourceMemory = new Memory<byte>(this.sourceArray);
+        this.sourceHandle = this.sourceMemory.Pin();
+
+        this.destArray = new byte[this.Count];
+        this.destMemory = new Memory<byte>(this.destArray);
+        this.destHandle = this.destMemory.Pin();
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        this.sourceHandle.Dispose();
+        this.destHandle.Dispose();
+    }
+
+    [Benchmark(Baseline = true, Description = "Array.Copy()")]
+    public void ArrayCopy()
+    {
+        Array.Copy(this.sourceArray, this.destArray, this.Count);
+    }
+
+    [Benchmark(Description = "Buffer.BlockCopy()")]
+    public void BufferBlockCopy()
+    {
+        Buffer.BlockCopy(this.sourceArray, 0, this.destArray, 0, this.Count);
+    }
+
+    [Benchmark(Description = "Buffer.MemoryCopy()")]
+    public unsafe void BufferMemoryCopy()
+    {
+        void* pinnedDestination = this.destHandle.Pointer;
+        void* pinnedSource = this.sourceHandle.Pointer;
+        Buffer.MemoryCopy(pinnedSource, pinnedDestination, this.Count, this.Count);
+    }
+
+    [Benchmark(Description = "Marshal.Copy()")]
+    public unsafe void MarshalCopy()
+    {
+        void* pinnedDestination = this.destHandle.Pointer;
+        Marshal.Copy(this.sourceArray, 0, (IntPtr)pinnedDestination, this.Count);
+    }
+
+    [Benchmark(Description = "Span.CopyTo()")]
+    public void SpanCopyTo()
+    {
+        this.sourceMemory.Span.CopyTo(this.destMemory.Span);
+    }
+
+    [Benchmark(Description = "Unsafe.CopyBlock(ref)")]
+    public void UnsafeCopyBlockReferences()
     {
-        private byte[] destArray;
+        Unsafe.CopyBlock(ref this.destArray[0], ref this.sourceArray[0], (uint)this.Count);
-
-        private MemoryHandle destHandle;
-
-        private Memory<byte> destMemory;
-
-        private byte[] sourceArray;
-
-        private MemoryHandle sourceHandle;
-
-        private Memory<byte> sourceMemory;
-
-        [Params(10, 50, 100, 1000, 10000)]
-        public int Count { get; set; }
-
-        [GlobalSetup]
-        public void Setup()
-        {
-            this.sourceArray = new byte[this.Count];
-            this.sourceMemory = new Memory<byte>(this.sourceArray);
-            this.sourceHandle = this.sourceMemory.Pin();
-
-            this.destArray = new byte[this.Count];
-            this.destMemory = new Memory<byte>(this.destArray);
-            this.destHandle = this.destMemory.Pin();
-        }
-
-        [GlobalCleanup]
-        public void Cleanup()
-        {
-            this.sourceHandle.Dispose();
-            this.destHandle.Dispose();
-        }
-
-        [Benchmark(Baseline = true, Description = "Array.Copy()")]
-        public void ArrayCopy()
-        {
-            Array.Copy(this.sourceArray, this.destArray, this.Count);
-        }
-
-        [Benchmark(Description = "Buffer.BlockCopy()")]
-        public void BufferBlockCopy()
-        {
-            Buffer.BlockCopy(this.sourceArray, 0, this.destArray, 0, this.Count);
-        }
-
-        [Benchmark(Description = "Buffer.MemoryCopy()")]
-        public unsafe void BufferMemoryCopy()
-        {
-            void* pinnedDestination = this.destHandle.Pointer;
-            void* pinnedSource = this.sourceHandle.Pointer;
-            Buffer.MemoryCopy(pinnedSource, pinnedDestination, this.Count, this.Count);
-        }
-
-        [Benchmark(Description = "Marshal.Copy()")]
-        public unsafe void MarshalCopy()
-        {
-            void* pinnedDestination = this.destHandle.Pointer;
-            Marshal.Copy(this.sourceArray, 0, (IntPtr)pinnedDestination, this.Count);
-        }
-
-        [Benchmark(Description = "Span.CopyTo()")]
-        public void SpanCopyTo()
-        {
-            this.sourceMemory.Span.CopyTo(this.destMemory.Span);
-        }
-
-        [Benchmark(Description = "Unsafe.CopyBlock(ref)")]
-        public void UnsafeCopyBlockReferences()
-        {
-            Unsafe.CopyBlock(ref this.destArray[0], ref this.sourceArray[0], (uint)this.Count);
-        }
-
-        [Benchmark(Description = "Unsafe.CopyBlock(ptr)")]
-        public unsafe void UnsafeCopyBlockPointers()
-        {
-            void* pinnedDestination = this.destHandle.Pointer;
-            void* pinnedSource = this.sourceHandle.Pointer;
-            Unsafe.CopyBlock(pinnedDestination, pinnedSource, (uint)this.Count);
-        }
-
-        [Benchmark(Description = "Unsafe.CopyBlockUnaligned(ref)")]
-        public void UnsafeCopyBlockUnalignedReferences()
-        {
-            Unsafe.CopyBlockUnaligned(ref this.destArray[0], ref this.sourceArray[0], (uint)this.Count);
-        }
-
-        [Benchmark(Description = "Unsafe.CopyBlockUnaligned(ptr)")]
-        public unsafe void UnsafeCopyBlockUnalignedPointers()
-        {
-            void* pinnedDestination = this.destHandle.Pointer;
-            void* pinnedSource = this.sourceHandle.Pointer;
-            Unsafe.CopyBlockUnaligned(pinnedDestination, pinnedSource, (uint)this.Count);
-        }
-
-        // BenchmarkDotNet=v0.11.3, OS=Windows 10.0.17134.706 (1803/April2018Update/Redstone4)
-        // Intel Core i7-7700HQ CPU 2.80GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
-        // Frequency=2742189 Hz, Resolution=364.6722 ns, Timer=TSC
-        // .NET Core SDK=2.2.202
-        //   [Host] : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
-        //   Clr    : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3394.0
-        //   Core   : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
-        //
-        // IterationCount=3  LaunchCount=1  WarmupCount=3
-        //
-        // |                         Method |  Job | Runtime | Count |       Mean |      Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-        // |------------------------------- |----- |-------- |------ |-----------:|-----------:|----------:|------:|--------:|------:|------:|------:|----------:|
-        // |                   Array.Copy() |  Clr |     Clr |    10 |  23.636 ns |  2.5299 ns | 0.1387 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() |  Clr |     Clr |    10 |  11.420 ns |  2.3341 ns | 0.1279 ns |  0.48 |    0.01 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() |  Clr |     Clr |    10 |   2.861 ns |  0.5059 ns | 0.0277 ns |  0.12 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() |  Clr |     Clr |    10 |  14.870 ns |  2.4541 ns | 0.1345 ns |  0.63 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() |  Clr |     Clr |    10 |  31.906 ns |  1.2213 ns | 0.0669 ns |  1.35 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |    10 |   3.513 ns |  0.7392 ns | 0.0405 ns |  0.15 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |    10 |   3.053 ns |  0.2010 ns | 0.0110 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |    10 |   3.497 ns |  0.4911 ns | 0.0269 ns |  0.15 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |    10 |   3.109 ns |  0.5958 ns | 0.0327 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() | Core |    Core |    10 |  19.709 ns |  2.1867 ns | 0.1199 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() | Core |    Core |    10 |   7.377 ns |  1.1582 ns | 0.0635 ns |  0.37 |    0.01 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() | Core |    Core |    10 |   2.581 ns |  1.1607 ns | 0.0636 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() | Core |    Core |    10 |  15.197 ns |  2.8446 ns | 0.1559 ns |  0.77 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() | Core |    Core |    10 |  25.394 ns |  0.9782 ns | 0.0536 ns |  1.29 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) | Core |    Core |    10 |   2.254 ns |  0.1590 ns | 0.0087 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) | Core |    Core |    10 |   1.878 ns |  0.1035 ns | 0.0057 ns |  0.10 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |    10 |   2.263 ns |  0.1383 ns | 0.0076 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |    10 |   1.877 ns |  0.0602 ns | 0.0033 ns |  0.10 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() |  Clr |     Clr |    50 |  35.068 ns |  5.9137 ns | 0.3242 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() |  Clr |     Clr |    50 |  23.299 ns |  2.3797 ns | 0.1304 ns |  0.66 |    0.01 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() |  Clr |     Clr |    50 |   3.598 ns |  4.8536 ns | 0.2660 ns |  0.10 |    0.01 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() |  Clr |     Clr |    50 |  27.720 ns |  4.6602 ns | 0.2554 ns |  0.79 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() |  Clr |     Clr |    50 |  35.673 ns | 16.2972 ns | 0.8933 ns |  1.02 |    0.03 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |    50 |   5.534 ns |  2.8119 ns | 0.1541 ns |  0.16 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |    50 |   4.511 ns |  0.9555 ns | 0.0524 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |    50 |   5.613 ns |  1.6679 ns | 0.0914 ns |  0.16 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |    50 |   4.884 ns |  7.3153 ns | 0.4010 ns |  0.14 |    0.01 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() | Core |    Core |    50 |  20.232 ns |  1.5720 ns | 0.0862 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() | Core |    Core |    50 |   8.142 ns |  0.7860 ns | 0.0431 ns |  0.40 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() | Core |    Core |    50 |   2.962 ns |  0.0611 ns | 0.0033 ns |  0.15 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() | Core |    Core |    50 |  16.802 ns |  2.9686 ns | 0.1627 ns |  0.83 |    0.00 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() | Core |    Core |    50 |  26.571 ns |  0.9228 ns | 0.0506 ns |  1.31 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) | Core |    Core |    50 |   2.219 ns |  0.7191 ns | 0.0394 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) | Core |    Core |    50 |   1.751 ns |  0.1884 ns | 0.0103 ns |  0.09 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |    50 |   2.177 ns |  0.4489 ns | 0.0246 ns |  0.11 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |    50 |   1.806 ns |  0.1063 ns | 0.0058 ns |  0.09 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() |  Clr |     Clr |   100 |  39.158 ns |  4.3068 ns | 0.2361 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() |  Clr |     Clr |   100 |  27.623 ns |  0.4611 ns | 0.0253 ns |  0.71 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() |  Clr |     Clr |   100 |   5.018 ns |  0.5689 ns | 0.0312 ns |  0.13 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() |  Clr |     Clr |   100 |  33.527 ns |  1.9019 ns | 0.1042 ns |  0.86 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() |  Clr |     Clr |   100 |  35.604 ns |  2.7039 ns | 0.1482 ns |  0.91 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |   100 |   7.853 ns |  0.4925 ns | 0.0270 ns |  0.20 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |   100 |   7.406 ns |  1.9733 ns | 0.1082 ns |  0.19 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |   100 |   7.822 ns |  0.6837 ns | 0.0375 ns |  0.20 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |   100 |   7.392 ns |  1.2832 ns | 0.0703 ns |  0.19 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() | Core |    Core |   100 |  22.909 ns |  2.9754 ns | 0.1631 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() | Core |    Core |   100 |  10.687 ns |  1.1262 ns | 0.0617 ns |  0.47 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() | Core |    Core |   100 |   4.063 ns |  0.1607 ns | 0.0088 ns |  0.18 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() | Core |    Core |   100 |  18.067 ns |  4.0557 ns | 0.2223 ns |  0.79 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() | Core |    Core |   100 |  28.352 ns |  1.2762 ns | 0.0700 ns |  1.24 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) | Core |    Core |   100 |   4.130 ns |  0.2013 ns | 0.0110 ns |  0.18 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) | Core |    Core |   100 |   4.096 ns |  0.2460 ns | 0.0135 ns |  0.18 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |   100 |   4.160 ns |  0.3174 ns | 0.0174 ns |  0.18 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |   100 |   3.480 ns |  1.1683 ns | 0.0640 ns |  0.15 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() |  Clr |     Clr |  1000 |  49.059 ns |  2.0729 ns | 0.1136 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() |  Clr |     Clr |  1000 |  38.270 ns | 23.6970 ns | 1.2989 ns |  0.78 |    0.03 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() |  Clr |     Clr |  1000 |  27.599 ns |  6.8328 ns | 0.3745 ns |  0.56 |    0.01 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() |  Clr |     Clr |  1000 |  42.752 ns |  5.1357 ns | 0.2815 ns |  0.87 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() |  Clr |     Clr |  1000 |  69.983 ns |  2.1860 ns | 0.1198 ns |  1.43 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |  1000 |  44.822 ns |  0.1625 ns | 0.0089 ns |  0.91 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |  1000 |  45.072 ns |  1.4053 ns | 0.0770 ns |  0.92 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |  1000 |  45.306 ns |  5.2646 ns | 0.2886 ns |  0.92 |    0.01 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |  1000 |  44.813 ns |  0.9117 ns | 0.0500 ns |  0.91 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() | Core |    Core |  1000 |  51.907 ns |  3.1827 ns | 0.1745 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() | Core |    Core |  1000 |  40.700 ns |  3.1488 ns | 0.1726 ns |  0.78 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() | Core |    Core |  1000 |  23.711 ns |  1.3004 ns | 0.0713 ns |  0.46 |    0.00 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() | Core |    Core |  1000 |  42.586 ns |  2.5390 ns | 0.1392 ns |  0.82 |    0.00 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() | Core |    Core |  1000 |  44.109 ns |  4.5604 ns | 0.2500 ns |  0.85 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) | Core |    Core |  1000 |  33.926 ns |  5.1633 ns | 0.2830 ns |  0.65 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) | Core |    Core |  1000 |  33.267 ns |  0.2708 ns | 0.0148 ns |  0.64 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |  1000 |  34.018 ns |  2.3238 ns | 0.1274 ns |  0.66 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |  1000 |  33.667 ns |  2.1983 ns | 0.1205 ns |  0.65 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() |  Clr |     Clr | 10000 | 153.429 ns |  6.1735 ns | 0.3384 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() |  Clr |     Clr | 10000 | 201.373 ns |  4.3670 ns | 0.2394 ns |  1.31 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() |  Clr |     Clr | 10000 | 211.768 ns | 71.3510 ns | 3.9110 ns |  1.38 |    0.02 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() |  Clr |     Clr | 10000 | 215.299 ns | 17.2677 ns | 0.9465 ns |  1.40 |    0.01 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() |  Clr |     Clr | 10000 | 486.325 ns | 32.4445 ns | 1.7784 ns |  3.17 |    0.01 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) |  Clr |     Clr | 10000 | 452.314 ns | 33.0593 ns | 1.8121 ns |  2.95 |    0.02 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr | 10000 | 455.600 ns | 56.7534 ns | 3.1108 ns |  2.97 |    0.02 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr | 10000 | 452.279 ns |  8.6457 ns | 0.4739 ns |  2.95 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr | 10000 | 453.146 ns | 12.3776 ns | 0.6785 ns |  2.95 |    0.00 |     - |     - |     - |         - |
-        // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
-        // |                   Array.Copy() | Core |    Core | 10000 | 204.508 ns |  3.1652 ns | 0.1735 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-        // |             Buffer.BlockCopy() | Core |    Core | 10000 | 193.345 ns |  1.3742 ns | 0.0753 ns |  0.95 |    0.00 |     - |     - |     - |         - |
-        // |            Buffer.MemoryCopy() | Core |    Core | 10000 | 196.978 ns | 18.3279 ns | 1.0046 ns |  0.96 |    0.01 |     - |     - |     - |         - |
-        // |                 Marshal.Copy() | Core |    Core | 10000 | 206.878 ns |  6.9938 ns | 0.3834 ns |  1.01 |    0.00 |     - |     - |     - |         - |
-        // |                  Span.CopyTo() | Core |    Core | 10000 | 215.733 ns | 15.4824 ns | 0.8486 ns |  1.05 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ref) | Core |    Core | 10000 | 186.894 ns |  8.7617 ns | 0.4803 ns |  0.91 |    0.00 |     - |     - |     - |         - |
-        // |          Unsafe.CopyBlock(ptr) | Core |    Core | 10000 | 186.662 ns | 10.6059 ns | 0.5813 ns |  0.91 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core | 10000 | 187.489 ns | 13.1527 ns | 0.7209 ns |  0.92 |    0.00 |     - |     - |     - |         - |
-        // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core | 10000 | 186.586 ns |  4.6274 ns | 0.2536 ns |  0.91 |    0.00 |     - |     - |     - |         - |
     }
+
+    [Benchmark(Description = "Unsafe.CopyBlock(ptr)")]
+    public unsafe void UnsafeCopyBlockPointers()
+    {
+        void* pinnedDestination = this.destHandle.Pointer;
+        void* pinnedSource = this.sourceHandle.Pointer;
+        Unsafe.CopyBlock(pinnedDestination, pinnedSource, (uint)this.Count);
+    }
+
+    [Benchmark(Description = "Unsafe.CopyBlockUnaligned(ref)")]
+    public void UnsafeCopyBlockUnalignedReferences()
+    {
+        Unsafe.CopyBlockUnaligned(ref this.destArray[0], ref this.sourceArray[0], (uint)this.Count);
+    }
+
+    [Benchmark(Description = "Unsafe.CopyBlockUnaligned(ptr)")]
+    public unsafe void UnsafeCopyBlockUnalignedPointers()
+    {
+        void* pinnedDestination = this.destHandle.Pointer;
+        void* pinnedSource = this.sourceHandle.Pointer;
+        Unsafe.CopyBlockUnaligned(pinnedDestination, pinnedSource, (uint)this.Count);
+    }
+
+    // BenchmarkDotNet=v0.11.3, OS=Windows 10.0.17134.706 (1803/April2018Update/Redstone4)
+    // Intel Core i7-7700HQ CPU 2.80GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
+    // Frequency=2742189 Hz, Resolution=364.6722 ns, Timer=TSC
+    // .NET Core SDK=2.2.202
+    //   [Host] : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
+    //   Clr    : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3394.0
+    //   Core   : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
+    //
+    // IterationCount=3  LaunchCount=1  WarmupCount=3
+    //
+    // |                         Method |  Job | Runtime | Count |       Mean |      Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+    // |------------------------------- |----- |-------- |------ |-----------:|-----------:|----------:|------:|--------:|------:|------:|------:|----------:|
+    // |                   Array.Copy() |  Clr |     Clr |    10 |  23.636 ns |  2.5299 ns | 0.1387 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() |  Clr |     Clr |    10 |  11.420 ns |  2.3341 ns | 0.1279 ns |  0.48 |    0.01 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() |  Clr |     Clr |    10 |   2.861 ns |  0.5059 ns | 0.0277 ns |  0.12 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() |  Clr |     Clr |    10 |  14.870 ns |  2.4541 ns | 0.1345 ns |  0.63 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() |  Clr |     Clr |    10 |  31.906 ns |  1.2213 ns | 0.0669 ns |  1.35 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |    10 |   3.513 ns |  0.7392 ns | 0.0405 ns |  0.15 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |    10 |   3.053 ns |  0.2010 ns | 0.0110 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |    10 |   3.497 ns |  0.4911 ns | 0.0269 ns |  0.15 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |    10 |   3.109 ns |  0.5958 ns | 0.0327 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() | Core |    Core |    10 |  19.709 ns |  2.1867 ns | 0.1199 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() | Core |    Core |    10 |   7.377 ns |  1.1582 ns | 0.0635 ns |  0.37 |    0.01 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() | Core |    Core |    10 |   2.581 ns |  1.1607 ns | 0.0636 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() | Core |    Core |    10 |  15.197 ns |  2.8446 ns | 0.1559 ns |  0.77 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() | Core |    Core |    10 |  25.394 ns |  0.9782 ns | 0.0536 ns |  1.29 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) | Core |    Core |    10 |   2.254 ns |  0.1590 ns | 0.0087 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) | Core |    Core |    10 |   1.878 ns |  0.1035 ns | 0.0057 ns |  0.10 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |    10 |   2.263 ns |  0.1383 ns | 0.0076 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |    10 |   1.877 ns |  0.0602 ns | 0.0033 ns |  0.10 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() |  Clr |     Clr |    50 |  35.068 ns |  5.9137 ns | 0.3242 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() |  Clr |     Clr |    50 |  23.299 ns |  2.3797 ns | 0.1304 ns |  0.66 |    0.01 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() |  Clr |     Clr |    50 |   3.598 ns |  4.8536 ns | 0.2660 ns |  0.10 |    0.01 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() |  Clr |     Clr |    50 |  27.720 ns |  4.6602 ns | 0.2554 ns |  0.79 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() |  Clr |     Clr |    50 |  35.673 ns | 16.2972 ns | 0.8933 ns |  1.02 |    0.03 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |    50 |   5.534 ns |  2.8119 ns | 0.1541 ns |  0.16 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |    50 |   4.511 ns |  0.9555 ns | 0.0524 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |    50 |   5.613 ns |  1.6679 ns | 0.0914 ns |  0.16 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |    50 |   4.884 ns |  7.3153 ns | 0.4010 ns |  0.14 |    0.01 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() | Core |    Core |    50 |  20.232 ns |  1.5720 ns | 0.0862 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() | Core |    Core |    50 |   8.142 ns |  0.7860 ns | 0.0431 ns |  0.40 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() | Core |    Core |    50 |   2.962 ns |  0.0611 ns | 0.0033 ns |  0.15 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() | Core |    Core |    50 |  16.802 ns |  2.9686 ns | 0.1627 ns |  0.83 |    0.00 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() | Core |    Core |    50 |  26.571 ns |  0.9228 ns | 0.0506 ns |  1.31 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) | Core |    Core |    50 |   2.219 ns |  0.7191 ns | 0.0394 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) | Core |    Core |    50 |   1.751 ns |  0.1884 ns | 0.0103 ns |  0.09 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |    50 |   2.177 ns |  0.4489 ns | 0.0246 ns |  0.11 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |    50 |   1.806 ns |  0.1063 ns | 0.0058 ns |  0.09 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() |  Clr |     Clr |   100 |  39.158 ns |  4.3068 ns | 0.2361 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() |  Clr |     Clr |   100 |  27.623 ns |  0.4611 ns | 0.0253 ns |  0.71 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() |  Clr |     Clr |   100 |   5.018 ns |  0.5689 ns | 0.0312 ns |  0.13 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() |  Clr |     Clr |   100 |  33.527 ns |  1.9019 ns | 0.1042 ns |  0.86 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() |  Clr |     Clr |   100 |  35.604 ns |  2.7039 ns | 0.1482 ns |  0.91 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |   100 |   7.853 ns |  0.4925 ns | 0.0270 ns |  0.20 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |   100 |   7.406 ns |  1.9733 ns | 0.1082 ns |  0.19 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |   100 |   7.822 ns |  0.6837 ns | 0.0375 ns |  0.20 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |   100 |   7.392 ns |  1.2832 ns | 0.0703 ns |  0.19 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() | Core |    Core |   100 |  22.909 ns |  2.9754 ns | 0.1631 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() | Core |    Core |   100 |  10.687 ns |  1.1262 ns | 0.0617 ns |  0.47 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() | Core |    Core |   100 |   4.063 ns |  0.1607 ns | 0.0088 ns |  0.18 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() | Core |    Core |   100 |  18.067 ns |  4.0557 ns | 0.2223 ns |  0.79 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() | Core |    Core |   100 |  28.352 ns |  1.2762 ns | 0.0700 ns |  1.24 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) | Core |    Core |   100 |   4.130 ns |  0.2013 ns | 0.0110 ns |  0.18 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) | Core |    Core |   100 |   4.096 ns |  0.2460 ns | 0.0135 ns |  0.18 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |   100 |   4.160 ns |  0.3174 ns | 0.0174 ns |  0.18 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |   100 |   3.480 ns |  1.1683 ns | 0.0640 ns |  0.15 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() |  Clr |     Clr |  1000 |  49.059 ns |  2.0729 ns | 0.1136 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() |  Clr |     Clr |  1000 |  38.270 ns | 23.6970 ns | 1.2989 ns |  0.78 |    0.03 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() |  Clr |     Clr |  1000 |  27.599 ns |  6.8328 ns | 0.3745 ns |  0.56 |    0.01 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() |  Clr |     Clr |  1000 |  42.752 ns |  5.1357 ns | 0.2815 ns |  0.87 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() |  Clr |     Clr |  1000 |  69.983 ns |  2.1860 ns | 0.1198 ns |  1.43 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) |  Clr |     Clr |  1000 |  44.822 ns |  0.1625 ns | 0.0089 ns |  0.91 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr |  1000 |  45.072 ns |  1.4053 ns | 0.0770 ns |  0.92 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr |  1000 |  45.306 ns |  5.2646 ns | 0.2886 ns |  0.92 |    0.01 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr |  1000 |  44.813 ns |  0.9117 ns | 0.0500 ns |  0.91 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() | Core |    Core |  1000 |  51.907 ns |  3.1827 ns | 0.1745 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() | Core |    Core |  1000 |  40.700 ns |  3.1488 ns | 0.1726 ns |  0.78 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() | Core |    Core |  1000 |  23.711 ns |  1.3004 ns | 0.0713 ns |  0.46 |    0.00 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() | Core |    Core |  1000 |  42.586 ns |  2.5390 ns | 0.1392 ns |  0.82 |    0.00 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() | Core |    Core |  1000 |  44.109 ns |  4.5604 ns | 0.2500 ns |  0.85 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) | Core |    Core |  1000 |  33.926 ns |  5.1633 ns | 0.2830 ns |  0.65 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) | Core |    Core |  1000 |  33.267 ns |  0.2708 ns | 0.0148 ns |  0.64 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core |  1000 |  34.018 ns |  2.3238 ns | 0.1274 ns |  0.66 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core |  1000 |  33.667 ns |  2.1983 ns | 0.1205 ns |  0.65 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() |  Clr |     Clr | 10000 | 153.429 ns |  6.1735 ns | 0.3384 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() |  Clr |     Clr | 10000 | 201.373 ns |  4.3670 ns | 0.2394 ns |  1.31 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() |  Clr |     Clr | 10000 | 211.768 ns | 71.3510 ns | 3.9110 ns |  1.38 |    0.02 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() |  Clr |     Clr | 10000 | 215.299 ns | 17.2677 ns | 0.9465 ns |  1.40 |    0.01 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() |  Clr |     Clr | 10000 | 486.325 ns | 32.4445 ns | 1.7784 ns |  3.17 |    0.01 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) |  Clr |     Clr | 10000 | 452.314 ns | 33.0593 ns | 1.8121 ns |  2.95 |    0.02 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) |  Clr |     Clr | 10000 | 455.600 ns | 56.7534 ns | 3.1108 ns |  2.97 |    0.02 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) |  Clr |     Clr | 10000 | 452.279 ns |  8.6457 ns | 0.4739 ns |  2.95 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) |  Clr |     Clr | 10000 | 453.146 ns | 12.3776 ns | 0.6785 ns |  2.95 |    0.00 |     - |     - |     - |         - |
+    // |                                |      |         |       |            |            |           |       |         |       |       |       |           |
+    // |                   Array.Copy() | Core |    Core | 10000 | 204.508 ns |  3.1652 ns | 0.1735 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    // |             Buffer.BlockCopy() | Core |    Core | 10000 | 193.345 ns |  1.3742 ns | 0.0753 ns |  0.95 |    0.00 |     - |     - |     - |         - |
+    // |            Buffer.MemoryCopy() | Core |    Core | 10000 | 196.978 ns | 18.3279 ns | 1.0046 ns |  0.96 |    0.01 |     - |     - |     - |         - |
+    // |                 Marshal.Copy() | Core |    Core | 10000 | 206.878 ns |  6.9938 ns | 0.3834 ns |  1.01 |    0.00 |     - |     - |     - |         - |
+    // |                  Span.CopyTo() | Core |    Core | 10000 | 215.733 ns | 15.4824 ns | 0.8486 ns |  1.05 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ref) | Core |    Core | 10000 | 186.894 ns |  8.7617 ns | 0.4803 ns |  0.91 |    0.00 |     - |     - |     - |         - |
+    // |          Unsafe.CopyBlock(ptr) | Core |    Core | 10000 | 186.662 ns | 10.6059 ns | 0.5813 ns |  0.91 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ref) | Core |    Core | 10000 | 187.489 ns | 13.1527 ns | 0.7209 ns |  0.92 |    0.00 |     - |     - |     - |         - |
+    // | Unsafe.CopyBlockUnaligned(ptr) | Core |    Core | 10000 | 186.586 ns |  4.6274 ns | 0.2536 ns |  0.91 |    0.00 |     - |     - |     - |         - |
 }

tests/ImageSharp.Benchmarks/General/Crc32Benchmark.cs

@@ -1,72 +1,70 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Compression.Zlib;
 using SharpCrc32 = ICSharpCode.SharpZipLib.Checksum.Crc32;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
-{
-    [Config(typeof(Config.ShortMultiFramework))]
-    public class Crc32Benchmark
-    {
-        private byte[] data;
-        private readonly SharpCrc32 crc = new SharpCrc32();
 
-        [Params(1024, 2048, 4096)]
+[Config(typeof(Config.ShortMultiFramework))]
-        public int Count { get; set; }
+public class Crc32Benchmark
+{
+    private byte[] data;
+    private readonly SharpCrc32 crc = new SharpCrc32();
 
-        [GlobalSetup]
+    [Params(1024, 2048, 4096)]
-        public void SetUp()
+    public int Count { get; set; }
-        {
-            this.data = new byte[this.Count];
-            new Random(1).NextBytes(this.data);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public long SharpZipLibCalculate()
+    public void SetUp()
-        {
+    {
-            this.crc.Reset();
+        this.data = new byte[this.Count];
-            this.crc.Update(this.data);
+        new Random(1).NextBytes(this.data);
-            return this.crc.Value;
+    }
-        }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public long SixLaborsCalculate()
+    public long SharpZipLibCalculate()
-        {
+    {
-            return Crc32.Calculate(this.data);
+        this.crc.Reset();
-        }
+        this.crc.Update(this.data);
+        return this.crc.Value;
     }
 
-    // ########## 17/05/2020 ##########
+    [Benchmark]
-    //
+    public long SixLaborsCalculate()
-    // |               Method |       Runtime | Count |         Mean |        Error |     StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+    {
-    // |--------------------- |-------------- |------ |-------------:|-------------:|-----------:|------:|--------:|------:|------:|------:|----------:|
+        return Crc32.Calculate(this.data);
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  1024 |  2,797.77 ns |   278.697 ns |  15.276 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+    }
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  1024 |  2,275.56 ns |   216.100 ns |  11.845 ns |  0.81 |    0.01 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  1024 |  2,923.43 ns | 2,656.882 ns | 145.633 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  1024 |  2,257.79 ns |    75.081 ns |   4.115 ns |  0.77 |    0.04 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  1024 |  2,764.14 ns |    86.281 ns |   4.729 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  1024 |     49.32 ns |     1.813 ns |   0.099 ns |  0.02 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  2048 |  5,603.71 ns |   427.240 ns |  23.418 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  2048 |  4,525.02 ns |    33.931 ns |   1.860 ns |  0.81 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  2048 |  5,563.32 ns |    49.337 ns |   2.704 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  2048 |  4,519.61 ns |    29.837 ns |   1.635 ns |  0.81 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  2048 |  5,543.37 ns |   518.551 ns |  28.424 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  2048 |     89.07 ns |     3.312 ns |   0.182 ns |  0.02 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate |    .NET 4.7.2 |  4096 | 11,396.95 ns |   373.450 ns |  20.470 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate |    .NET 4.7.2 |  4096 |  9,070.35 ns |   271.083 ns |  14.859 ns |  0.80 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 2.1 |  4096 | 11,127.81 ns |   239.177 ns |  13.110 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 2.1 |  4096 |  9,050.46 ns |   230.916 ns |  12.657 ns |  0.81 |    0.00 |     - |     - |     - |         - |
-    // |                      |               |       |              |              |            |       |         |       |       |       |           |
-    // | SharpZipLibCalculate | .NET Core 3.1 |  4096 | 11,098.62 ns |   687.978 ns |  37.710 ns |  1.00 |    0.00 |     - |     - |     - |         - |
-    // |   SixLaborsCalculate | .NET Core 3.1 |  4096 |    168.11 ns |     3.633 ns |   0.199 ns |  0.02 |    0.00 |     - |     - |     - |         - |
 }
+
+// ########## 17/05/2020 ##########
+//
+// |               Method |       Runtime | Count |         Mean |        Error |     StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// |--------------------- |-------------- |------ |-------------:|-------------:|-----------:|------:|--------:|------:|------:|------:|----------:|
+// | SharpZipLibCalculate |    .NET 4.7.2 |  1024 |  2,797.77 ns |   278.697 ns |  15.276 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  1024 |  2,275.56 ns |   216.100 ns |  11.845 ns |  0.81 |    0.01 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  1024 |  2,923.43 ns | 2,656.882 ns | 145.633 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  1024 |  2,257.79 ns |    75.081 ns |   4.115 ns |  0.77 |    0.04 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  1024 |  2,764.14 ns |    86.281 ns |   4.729 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  1024 |     49.32 ns |     1.813 ns |   0.099 ns |  0.02 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate |    .NET 4.7.2 |  2048 |  5,603.71 ns |   427.240 ns |  23.418 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  2048 |  4,525.02 ns |    33.931 ns |   1.860 ns |  0.81 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  2048 |  5,563.32 ns |    49.337 ns |   2.704 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  2048 |  4,519.61 ns |    29.837 ns |   1.635 ns |  0.81 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  2048 |  5,543.37 ns |   518.551 ns |  28.424 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  2048 |     89.07 ns |     3.312 ns |   0.182 ns |  0.02 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate |    .NET 4.7.2 |  4096 | 11,396.95 ns |   373.450 ns |  20.470 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate |    .NET 4.7.2 |  4096 |  9,070.35 ns |   271.083 ns |  14.859 ns |  0.80 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 2.1 |  4096 | 11,127.81 ns |   239.177 ns |  13.110 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 2.1 |  4096 |  9,050.46 ns |   230.916 ns |  12.657 ns |  0.81 |    0.00 |     - |     - |     - |         - |
+// |                      |               |       |              |              |            |       |         |       |       |       |           |
+// | SharpZipLibCalculate | .NET Core 3.1 |  4096 | 11,098.62 ns |   687.978 ns |  37.710 ns |  1.00 |    0.00 |     - |     - |     - |         - |
+// |   SixLaborsCalculate | .NET Core 3.1 |  4096 |    168.11 ns |     3.633 ns |   0.199 ns |  0.02 |    0.00 |     - |     - |     - |         - |

tests/ImageSharp.Benchmarks/General/GetSetPixel.cs

@@ -5,24 +5,23 @@ using System.Drawing;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks
+namespace SixLabors.ImageSharp.Benchmarks;
+
+public class GetSetPixel
 {
-    public class GetSetPixel
+    [Benchmark(Baseline = true, Description = "System.Drawing GetSet pixel")]
+    public System.Drawing.Color GetSetSystemDrawing()
     {
-        [Benchmark(Baseline = true, Description = "System.Drawing GetSet pixel")]
+        using var source = new Bitmap(400, 400);
-        public System.Drawing.Color GetSetSystemDrawing()
+        source.SetPixel(200, 200, System.Drawing.Color.White);
-        {
+        return source.GetPixel(200, 200);
-            using var source = new Bitmap(400, 400);
+    }
-            source.SetPixel(200, 200, System.Drawing.Color.White);
-            return source.GetPixel(200, 200);
-        }
 
-        [Benchmark(Description = "ImageSharp GetSet pixel")]
+    [Benchmark(Description = "ImageSharp GetSet pixel")]
-        public Rgba32 GetSetImageSharp()
+    public Rgba32 GetSetImageSharp()
-        {
+    {
-            using var image = new Image<Rgba32>(400, 400);
+        using var image = new Image<Rgba32>(400, 400);
-            image[200, 200] = Color.White;
+        image[200, 200] = Color.White;
-            return image[200, 200];
+        return image[200, 200];
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/IO/BufferedReadStreamWrapper.cs

@@ -1,279 +1,276 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Buffers;
-using System.IO;
 using System.Runtime.CompilerServices;
 
-namespace SixLabors.ImageSharp.Benchmarks.IO
+namespace SixLabors.ImageSharp.Benchmarks.IO;
+
+/// <summary>
+/// A readonly stream wrapper that add a secondary level buffer in addition to native stream
+/// buffered reading to reduce the overhead of small incremental reads.
+/// </summary>
+internal sealed unsafe class BufferedReadStreamWrapper : IDisposable
 {
     /// <summary>
-    /// A readonly stream wrapper that add a secondary level buffer in addition to native stream
+    /// The length, in bytes, of the underlying buffer.
-    /// buffered reading to reduce the overhead of small incremental reads.
     /// </summary>
-    internal sealed unsafe class BufferedReadStreamWrapper : IDisposable
+    public const int BufferLength = 8192;
-    {
-        /// <summary>
-        /// The length, in bytes, of the underlying buffer.
-        /// </summary>
-        public const int BufferLength = 8192;
-
-        private const int MaxBufferIndex = BufferLength - 1;
-
-        private readonly Stream stream;
 
-        private readonly byte[] readBuffer;
+    private const int MaxBufferIndex = BufferLength - 1;
 
-        private MemoryHandle readBufferHandle;
+    private readonly Stream stream;
 
-        private readonly byte* pinnedReadBuffer;
+    private readonly byte[] readBuffer;
 
-        // Index within our buffer, not reader position.
+    private MemoryHandle readBufferHandle;
-        private int readBufferIndex;
 
-        // Matches what the stream position would be without buffering
+    private readonly byte* pinnedReadBuffer;
-        private long readerPosition;
 
-        private bool isDisposed;
+    // Index within our buffer, not reader position.
+    private int readBufferIndex;
 
-        /// <summary>
+    // Matches what the stream position would be without buffering
-        /// Initializes a new instance of the <see cref="BufferedReadStreamWrapper"/> class.
+    private long readerPosition;
-        /// </summary>
-        /// <param name="stream">The input stream.</param>
-        public BufferedReadStreamWrapper(Stream stream)
-        {
-            Guard.IsTrue(stream.CanRead, nameof(stream), "Stream must be readable.");
-            Guard.IsTrue(stream.CanSeek, nameof(stream), "Stream must be seekable.");
-
-            // Ensure all underlying buffers have been flushed before we attempt to read the stream.
-            // User streams may have opted to throw from Flush if CanWrite is false
-            // (although the abstract Stream does not do so).
-            if (stream.CanWrite)
-            {
-                stream.Flush();
-            }
 
-            this.stream = stream;
+    private bool isDisposed;
-            this.Position = (int)stream.Position;
-            this.Length = stream.Length;
 
-            this.readBuffer = ArrayPool<byte>.Shared.Rent(BufferLength);
+    /// <summary>
-            this.readBufferHandle = new Memory<byte>(this.readBuffer).Pin();
+    /// Initializes a new instance of the <see cref="BufferedReadStreamWrapper"/> class.
-            this.pinnedReadBuffer = (byte*)this.readBufferHandle.Pointer;
+    /// </summary>
+    /// <param name="stream">The input stream.</param>
+    public BufferedReadStreamWrapper(Stream stream)
+    {
+        Guard.IsTrue(stream.CanRead, nameof(stream), "Stream must be readable.");
+        Guard.IsTrue(stream.CanSeek, nameof(stream), "Stream must be seekable.");
 
-            // This triggers a full read on first attempt.
+        // Ensure all underlying buffers have been flushed before we attempt to read the stream.
-            this.readBufferIndex = BufferLength;
+        // User streams may have opted to throw from Flush if CanWrite is false
+        // (although the abstract Stream does not do so).
+        if (stream.CanWrite)
+        {
+            stream.Flush();
         }
 
-        /// <summary>
+        this.stream = stream;
-        /// Gets the length, in bytes, of the stream.
+        this.Position = (int)stream.Position;
-        /// </summary>
+        this.Length = stream.Length;
-        public long Length { get; }
 
-        /// <summary>
+        this.readBuffer = ArrayPool<byte>.Shared.Rent(BufferLength);
-        /// Gets or sets the current position within the stream.
+        this.readBufferHandle = new Memory<byte>(this.readBuffer).Pin();
-        /// </summary>
+        this.pinnedReadBuffer = (byte*)this.readBufferHandle.Pointer;
-        public long Position
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => this.readerPosition;
 
-            [MethodImpl(MethodImplOptions.NoInlining)]
+        // This triggers a full read on first attempt.
-            set
+        this.readBufferIndex = BufferLength;
-            {
+    }
-                // Only reset readBufferIndex if we are out of bounds of our working buffer
-                // otherwise we should simply move the value by the diff.
-                if (this.IsInReadBuffer(value, out long index))
-                {
-                    this.readBufferIndex = (int)index;
-                    this.readerPosition = value;
-                }
-                else
-                {
-                    // Base stream seek will throw for us if invalid.
-                    this.stream.Seek(value, SeekOrigin.Begin);
-                    this.readerPosition = value;
-                    this.readBufferIndex = BufferLength;
-                }
-            }
-        }
 
+    /// <summary>
+    /// Gets the length, in bytes, of the stream.
+    /// </summary>
+    public long Length { get; }
+
+    /// <summary>
+    /// Gets or sets the current position within the stream.
+    /// </summary>
+    public long Position
+    {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int ReadByte()
+        get => this.readerPosition;
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        set
         {
-            if (this.readerPosition >= this.Length)
+            // Only reset readBufferIndex if we are out of bounds of our working buffer
+            // otherwise we should simply move the value by the diff.
+            if (this.IsInReadBuffer(value, out long index))
             {
-                return -1;
+                this.readBufferIndex = (int)index;
+                this.readerPosition = value;
             }
-
+            else
-            // Our buffer has been read.
-            // We need to refill and start again.
-            if (this.readBufferIndex > MaxBufferIndex)
             {
-                this.FillReadBuffer();
+                // Base stream seek will throw for us if invalid.
+                this.stream.Seek(value, SeekOrigin.Begin);
+                this.readerPosition = value;
+                this.readBufferIndex = BufferLength;
             }
+        }
+    }
 
-            this.readerPosition++;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            return this.pinnedReadBuffer[this.readBufferIndex++];
+    public int ReadByte()
+    {
+        if (this.readerPosition >= this.Length)
+        {
+            return -1;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        // Our buffer has been read.
-        public int Read(byte[] buffer, int offset, int count)
+        // We need to refill and start again.
+        if (this.readBufferIndex > MaxBufferIndex)
         {
-            // Too big for our buffer. Read directly from the stream.
+            this.FillReadBuffer();
-            if (count > BufferLength)
+        }
-            {
-                return this.ReadToBufferDirectSlow(buffer, offset, count);
-            }
 
-            // Too big for remaining buffer but less than entire buffer length
+        this.readerPosition++;
-            // Copy to buffer then read from there.
+        return this.pinnedReadBuffer[this.readBufferIndex++];
-            if (count + this.readBufferIndex > BufferLength)
+    }
-            {
-                return this.ReadToBufferViaCopySlow(buffer, offset, count);
-            }
 
-            return this.ReadToBufferViaCopyFast(buffer, offset, count);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int Read(byte[] buffer, int offset, int count)
+    {
+        // Too big for our buffer. Read directly from the stream.
+        if (count > BufferLength)
+        {
+            return this.ReadToBufferDirectSlow(buffer, offset, count);
         }
 
-        public void Flush()
+        // Too big for remaining buffer but less than entire buffer length
+        // Copy to buffer then read from there.
+        if (count + this.readBufferIndex > BufferLength)
         {
-            // Reset the stream position to match reader position.
+            return this.ReadToBufferViaCopySlow(buffer, offset, count);
-            if (this.readerPosition != this.stream.Position)
-            {
-                this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
-                this.readerPosition = (int)this.stream.Position;
-            }
-
-            // Reset to trigger full read on next attempt.
-            this.readBufferIndex = BufferLength;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return this.ReadToBufferViaCopyFast(buffer, offset, count);
-        public long Seek(long offset, SeekOrigin origin)
+    }
+
+    public void Flush()
+    {
+        // Reset the stream position to match reader position.
+        if (this.readerPosition != this.stream.Position)
         {
-            switch (origin)
+            this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
-            {
+            this.readerPosition = (int)this.stream.Position;
-                case SeekOrigin.Begin:
+        }
-                    this.Position = offset;
-                    break;
 
-                case SeekOrigin.Current:
+        // Reset to trigger full read on next attempt.
-                    this.Position += offset;
+        this.readBufferIndex = BufferLength;
-                    break;
+    }
 
-                case SeekOrigin.End:
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    this.Position = this.Length - offset;
+    public long Seek(long offset, SeekOrigin origin)
-                    break;
+    {
-            }
+        switch (origin)
+        {
+            case SeekOrigin.Begin:
+                this.Position = offset;
+                break;
 
-            return this.readerPosition;
+            case SeekOrigin.Current:
+                this.Position += offset;
+                break;
+
+            case SeekOrigin.End:
+                this.Position = this.Length - offset;
+                break;
         }
 
-        /// <inheritdoc/>
+        return this.readerPosition;
-        public void Dispose()
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        if (!this.isDisposed)
         {
-            if (!this.isDisposed)
+            this.isDisposed = true;
-            {
+            this.readBufferHandle.Dispose();
-                this.isDisposed = true;
+            ArrayPool<byte>.Shared.Return(this.readBuffer);
-                this.readBufferHandle.Dispose();
+            this.Flush();
-                ArrayPool<byte>.Shared.Return(this.readBuffer);
-                this.Flush();
-            }
         }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private bool IsInReadBuffer(long newPosition, out long index)
+    private bool IsInReadBuffer(long newPosition, out long index)
+    {
+        index = newPosition - this.readerPosition + this.readBufferIndex;
+        return index > -1 && index < BufferLength;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void FillReadBuffer()
+    {
+        if (this.readerPosition != this.stream.Position)
         {
-            index = newPosition - this.readerPosition + this.readBufferIndex;
+            this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
-            return index > -1 && index < BufferLength;
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        this.stream.Read(this.readBuffer, 0, BufferLength);
-        private void FillReadBuffer()
+        this.readBufferIndex = 0;
-        {
+    }
-            if (this.readerPosition != this.stream.Position)
-            {
-                this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
-            }
 
-            this.stream.Read(this.readBuffer, 0, BufferLength);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            this.readBufferIndex = 0;
+    private int ReadToBufferViaCopyFast(byte[] buffer, int offset, int count)
-        }
+    {
+        int n = this.GetCopyCount(count);
+        this.CopyBytes(buffer, offset, n);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        this.readerPosition += n;
-        private int ReadToBufferViaCopyFast(byte[] buffer, int offset, int count)
+        this.readBufferIndex += n;
-        {
-            int n = this.GetCopyCount(count);
-            this.CopyBytes(buffer, offset, n);
 
-            this.readerPosition += n;
+        return n;
-            this.readBufferIndex += n;
+    }
 
-            return n;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        }
+    private int ReadToBufferViaCopySlow(byte[] buffer, int offset, int count)
+    {
+        // Refill our buffer then copy.
+        this.FillReadBuffer();
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return this.ReadToBufferViaCopyFast(buffer, offset, count);
-        private int ReadToBufferViaCopySlow(byte[] buffer, int offset, int count)
+    }
-        {
-            // Refill our buffer then copy.
-            this.FillReadBuffer();
 
-            return this.ReadToBufferViaCopyFast(buffer, offset, count);
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private int ReadToBufferDirectSlow(byte[] buffer, int offset, int count)
+    {
+        // Read to target but don't copy to our read buffer.
+        if (this.readerPosition != this.stream.Position)
+        {
+            this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        int n = this.stream.Read(buffer, offset, count);
-        private int ReadToBufferDirectSlow(byte[] buffer, int offset, int count)
+        this.Position += n;
-        {
-            // Read to target but don't copy to our read buffer.
-            if (this.readerPosition != this.stream.Position)
-            {
-                this.stream.Seek(this.readerPosition, SeekOrigin.Begin);
-            }
 
-            int n = this.stream.Read(buffer, offset, count);
+        return n;
-            this.Position += n;
+    }
 
-            return n;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private int GetCopyCount(int count)
+    {
+        long n = this.Length - this.readerPosition;
+        if (n > count)
+        {
+            return count;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        if (n < 0)
-        private int GetCopyCount(int count)
         {
-            long n = this.Length - this.readerPosition;
+            return 0;
-            if (n > count)
-            {
-                return count;
-            }
-
-            if (n < 0)
-            {
-                return 0;
-            }
-
-            return (int)n;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        return (int)n;
-        private void CopyBytes(byte[] buffer, int offset, int count)
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void CopyBytes(byte[] buffer, int offset, int count)
+    {
+        // Same as MemoryStream.
+        if (count < 9)
         {
-            // Same as MemoryStream.
+            int byteCount = count;
-            if (count < 9)
+            int read = this.readBufferIndex;
-            {
+            byte* pinned = this.pinnedReadBuffer;
-                int byteCount = count;
+
-                int read = this.readBufferIndex;
+            while (--byteCount > -1)
-                byte* pinned = this.pinnedReadBuffer;
-
-                while (--byteCount > -1)
-                {
-                    buffer[offset + byteCount] = pinned[read + byteCount];
-                }
-            }
-            else
             {
-                Buffer.BlockCopy(this.readBuffer, this.readBufferIndex, buffer, offset, count);
+                buffer[offset + byteCount] = pinned[read + byteCount];
             }
         }
+        else
+        {
+            Buffer.BlockCopy(this.readBuffer, this.readBufferIndex, buffer, offset, count);
+        }
     }
 }

tests/ImageSharp.Benchmarks/General/IO/BufferedStreams.cs

@@ -1,261 +1,258 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
-using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.IO;
 
-namespace SixLabors.ImageSharp.Benchmarks.IO
+namespace SixLabors.ImageSharp.Benchmarks.IO;
+
+[Config(typeof(Config.ShortMultiFramework))]
+public class BufferedStreams
 {
-    [Config(typeof(Config.ShortMultiFramework))]
+    private readonly byte[] buffer = CreateTestBytes();
-    public class BufferedStreams
+    private readonly byte[] chunk1 = new byte[2];
+    private readonly byte[] chunk2 = new byte[2];
+
+    private MemoryStream stream1;
+    private MemoryStream stream2;
+    private MemoryStream stream3;
+    private MemoryStream stream4;
+    private MemoryStream stream5;
+    private MemoryStream stream6;
+    private ChunkedMemoryStream chunkedMemoryStream1;
+    private ChunkedMemoryStream chunkedMemoryStream2;
+    private BufferedReadStream bufferedStream1;
+    private BufferedReadStream bufferedStream2;
+    private BufferedReadStream bufferedStream3;
+    private BufferedReadStream bufferedStream4;
+    private BufferedReadStreamWrapper bufferedStreamWrap1;
+    private BufferedReadStreamWrapper bufferedStreamWrap2;
+
+    [GlobalSetup]
+    public void CreateStreams()
     {
-        private readonly byte[] buffer = CreateTestBytes();
+        this.stream1 = new MemoryStream(this.buffer);
-        private readonly byte[] chunk1 = new byte[2];
+        this.stream2 = new MemoryStream(this.buffer);
-        private readonly byte[] chunk2 = new byte[2];
+        this.stream3 = new MemoryStream(this.buffer);
-
+        this.stream4 = new MemoryStream(this.buffer);
-        private MemoryStream stream1;
+        this.stream5 = new MemoryStream(this.buffer);
-        private MemoryStream stream2;
+        this.stream6 = new MemoryStream(this.buffer);
-        private MemoryStream stream3;
+        this.stream6 = new MemoryStream(this.buffer);
-        private MemoryStream stream4;
+
-        private MemoryStream stream5;
+        this.chunkedMemoryStream1 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
-        private MemoryStream stream6;
+        this.chunkedMemoryStream1.Write(this.buffer);
-        private ChunkedMemoryStream chunkedMemoryStream1;
+        this.chunkedMemoryStream1.Position = 0;
-        private ChunkedMemoryStream chunkedMemoryStream2;
+
-        private BufferedReadStream bufferedStream1;
+        this.chunkedMemoryStream2 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
-        private BufferedReadStream bufferedStream2;
+        this.chunkedMemoryStream2.Write(this.buffer);
-        private BufferedReadStream bufferedStream3;
+        this.chunkedMemoryStream2.Position = 0;
-        private BufferedReadStream bufferedStream4;
+
-        private BufferedReadStreamWrapper bufferedStreamWrap1;
+        this.bufferedStream1 = new BufferedReadStream(Configuration.Default, this.stream3);
-        private BufferedReadStreamWrapper bufferedStreamWrap2;
+        this.bufferedStream2 = new BufferedReadStream(Configuration.Default, this.stream4);
-
+        this.bufferedStream3 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream1);
-        [GlobalSetup]
+        this.bufferedStream4 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream2);
-        public void CreateStreams()
+        this.bufferedStreamWrap1 = new BufferedReadStreamWrapper(this.stream5);
-        {
+        this.bufferedStreamWrap2 = new BufferedReadStreamWrapper(this.stream6);
-            this.stream1 = new MemoryStream(this.buffer);
+    }
-            this.stream2 = new MemoryStream(this.buffer);
-            this.stream3 = new MemoryStream(this.buffer);
-            this.stream4 = new MemoryStream(this.buffer);
-            this.stream5 = new MemoryStream(this.buffer);
-            this.stream6 = new MemoryStream(this.buffer);
-            this.stream6 = new MemoryStream(this.buffer);
-
-            this.chunkedMemoryStream1 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
-            this.chunkedMemoryStream1.Write(this.buffer);
-            this.chunkedMemoryStream1.Position = 0;
-
-            this.chunkedMemoryStream2 = new ChunkedMemoryStream(Configuration.Default.MemoryAllocator);
-            this.chunkedMemoryStream2.Write(this.buffer);
-            this.chunkedMemoryStream2.Position = 0;
-
-            this.bufferedStream1 = new BufferedReadStream(Configuration.Default, this.stream3);
-            this.bufferedStream2 = new BufferedReadStream(Configuration.Default, this.stream4);
-            this.bufferedStream3 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream1);
-            this.bufferedStream4 = new BufferedReadStream(Configuration.Default, this.chunkedMemoryStream2);
-            this.bufferedStreamWrap1 = new BufferedReadStreamWrapper(this.stream5);
-            this.bufferedStreamWrap2 = new BufferedReadStreamWrapper(this.stream6);
-        }
-
-        [GlobalCleanup]
-        public void DestroyStreams()
-        {
-            this.bufferedStream1?.Dispose();
-            this.bufferedStream2?.Dispose();
-            this.bufferedStream3?.Dispose();
-            this.bufferedStream4?.Dispose();
-            this.bufferedStreamWrap1?.Dispose();
-            this.bufferedStreamWrap2?.Dispose();
-            this.chunkedMemoryStream1?.Dispose();
-            this.chunkedMemoryStream2?.Dispose();
-            this.stream1?.Dispose();
-            this.stream2?.Dispose();
-            this.stream3?.Dispose();
-            this.stream4?.Dispose();
-            this.stream5?.Dispose();
-            this.stream6?.Dispose();
-        }
-
-        [Benchmark]
-        public int StandardStreamRead()
-        {
-            int r = 0;
-            Stream stream = this.stream1;
-            byte[] b = this.chunk1;
 
-            for (int i = 0; i < stream.Length / 2; i++)
+    [GlobalCleanup]
-            {
+    public void DestroyStreams()
-                r += stream.Read(b, 0, 2);
+    {
-            }
+        this.bufferedStream1?.Dispose();
+        this.bufferedStream2?.Dispose();
+        this.bufferedStream3?.Dispose();
+        this.bufferedStream4?.Dispose();
+        this.bufferedStreamWrap1?.Dispose();
+        this.bufferedStreamWrap2?.Dispose();
+        this.chunkedMemoryStream1?.Dispose();
+        this.chunkedMemoryStream2?.Dispose();
+        this.stream1?.Dispose();
+        this.stream2?.Dispose();
+        this.stream3?.Dispose();
+        this.stream4?.Dispose();
+        this.stream5?.Dispose();
+        this.stream6?.Dispose();
+    }
 
-            return r;
+    [Benchmark]
-        }
+    public int StandardStreamRead()
+    {
+        int r = 0;
+        Stream stream = this.stream1;
+        byte[] b = this.chunk1;
 
-        [Benchmark]
+        for (int i = 0; i < stream.Length / 2; i++)
-        public int BufferedReadStreamRead()
         {
-            int r = 0;
+            r += stream.Read(b, 0, 2);
-            BufferedReadStream reader = this.bufferedStream1;
+        }
-            byte[] b = this.chunk2;
 
-            for (int i = 0; i < reader.Length / 2; i++)
+        return r;
-            {
+    }
-                r += reader.Read(b, 0, 2);
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamRead()
+    {
+        int r = 0;
+        BufferedReadStream reader = this.bufferedStream1;
+        byte[] b = this.chunk2;
 
-        [Benchmark]
+        for (int i = 0; i < reader.Length / 2; i++)
-        public int BufferedReadStreamChunkedRead()
         {
-            int r = 0;
+            r += reader.Read(b, 0, 2);
-            BufferedReadStream reader = this.bufferedStream3;
+        }
-            byte[] b = this.chunk2;
 
-            for (int i = 0; i < reader.Length / 2; i++)
+        return r;
-            {
+    }
-                r += reader.Read(b, 0, 2);
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamChunkedRead()
+    {
+        int r = 0;
+        BufferedReadStream reader = this.bufferedStream3;
+        byte[] b = this.chunk2;
 
-        [Benchmark]
+        for (int i = 0; i < reader.Length / 2; i++)
-        public int BufferedReadStreamWrapRead()
         {
-            int r = 0;
+            r += reader.Read(b, 0, 2);
-            BufferedReadStreamWrapper reader = this.bufferedStreamWrap1;
+        }
-            byte[] b = this.chunk2;
 
-            for (int i = 0; i < reader.Length / 2; i++)
+        return r;
-            {
+    }
-                r += reader.Read(b, 0, 2);
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamWrapRead()
+    {
+        int r = 0;
+        BufferedReadStreamWrapper reader = this.bufferedStreamWrap1;
+        byte[] b = this.chunk2;
 
-        [Benchmark(Baseline = true)]
+        for (int i = 0; i < reader.Length / 2; i++)
-        public int StandardStreamReadByte()
         {
-            int r = 0;
+            r += reader.Read(b, 0, 2);
-            Stream stream = this.stream2;
+        }
 
-            for (int i = 0; i < stream.Length; i++)
+        return r;
-            {
+    }
-                r += stream.ReadByte();
-            }
 
-            return r;
+    [Benchmark(Baseline = true)]
-        }
+    public int StandardStreamReadByte()
+    {
+        int r = 0;
+        Stream stream = this.stream2;
 
-        [Benchmark]
+        for (int i = 0; i < stream.Length; i++)
-        public int BufferedReadStreamReadByte()
         {
-            int r = 0;
+            r += stream.ReadByte();
-            BufferedReadStream reader = this.bufferedStream2;
+        }
 
-            for (int i = 0; i < reader.Length; i++)
+        return r;
-            {
+    }
-                r += reader.ReadByte();
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamReadByte()
+    {
+        int r = 0;
+        BufferedReadStream reader = this.bufferedStream2;
 
-        [Benchmark]
+        for (int i = 0; i < reader.Length; i++)
-        public int BufferedReadStreamChunkedReadByte()
         {
-            int r = 0;
+            r += reader.ReadByte();
-            BufferedReadStream reader = this.bufferedStream4;
+        }
 
-            for (int i = 0; i < reader.Length; i++)
+        return r;
-            {
+    }
-                r += reader.ReadByte();
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamChunkedReadByte()
+    {
+        int r = 0;
+        BufferedReadStream reader = this.bufferedStream4;
 
-        [Benchmark]
+        for (int i = 0; i < reader.Length; i++)
-        public int BufferedReadStreamWrapReadByte()
         {
-            int r = 0;
+            r += reader.ReadByte();
-            BufferedReadStreamWrapper reader = this.bufferedStreamWrap2;
+        }
 
-            for (int i = 0; i < reader.Length; i++)
+        return r;
-            {
+    }
-                r += reader.ReadByte();
-            }
 
-            return r;
+    [Benchmark]
-        }
+    public int BufferedReadStreamWrapReadByte()
+    {
+        int r = 0;
+        BufferedReadStreamWrapper reader = this.bufferedStreamWrap2;
 
-        [Benchmark]
+        for (int i = 0; i < reader.Length; i++)
-        public int ArrayReadByte()
         {
-            byte[] b = this.buffer;
+            r += reader.ReadByte();
-            int r = 0;
-            for (int i = 0; i < b.Length; i++)
-            {
-                r += b[i];
-            }
-
-            return r;
         }
 
-        private static byte[] CreateTestBytes()
+        return r;
-        {
+    }
-            var buffer = new byte[Configuration.Default.StreamProcessingBufferSize * 3];
-            var random = new Random();
-            random.NextBytes(buffer);
 
-            return buffer;
+    [Benchmark]
+    public int ArrayReadByte()
+    {
+        byte[] b = this.buffer;
+        int r = 0;
+        for (int i = 0; i < b.Length; i++)
+        {
+            r += b[i];
         }
+
+        return r;
     }
 
-    /*
+    private static byte[] CreateTestBytes()
-    BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.450 (2004/?/20H1)
+    {
-    Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+        var buffer = new byte[Configuration.Default.StreamProcessingBufferSize * 3];
-    .NET Core SDK=3.1.401
+        var random = new Random();
-      [Host]     : .NET Core 3.1.7 (CoreCLR 4.700.20.36602, CoreFX 4.700.20.37001), X64 RyuJIT
+        random.NextBytes(buffer);
-      Job-OKZLUV : .NET Framework 4.8 (4.8.4084.0), X64 RyuJIT
+
-      Job-CPYMXV : .NET Core 2.1.21 (CoreCLR 4.6.29130.01, CoreFX 4.6.29130.02), X64 RyuJIT
+        return buffer;
-      Job-BSGVGU : .NET Core 3.1.7 (CoreCLR 4.700.20.36602, CoreFX 4.700.20.37001), X64 RyuJIT
+    }
-
-    IterationCount=3  LaunchCount=1  WarmupCount=3
-
-    |                            Method |        Job |       Runtime |       Mean |     Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
-    |---------------------------------- |----------- |-------------- |-----------:|----------:|----------:|------:|--------:|------:|------:|------:|----------:|
-    |                StandardStreamRead | Job-OKZLUV |    .NET 4.7.2 |  66.785 us | 15.768 us | 0.8643 us |  0.83 |    0.01 |     - |     - |     - |         - |
-    |            BufferedReadStreamRead | Job-OKZLUV |    .NET 4.7.2 |  97.389 us | 17.658 us | 0.9679 us |  1.21 |    0.01 |     - |     - |     - |         - |
-    |     BufferedReadStreamChunkedRead | Job-OKZLUV |    .NET 4.7.2 |  96.006 us | 16.286 us | 0.8927 us |  1.20 |    0.02 |     - |     - |     - |         - |
-    |        BufferedReadStreamWrapRead | Job-OKZLUV |    .NET 4.7.2 |  37.064 us | 14.640 us | 0.8024 us |  0.46 |    0.02 |     - |     - |     - |         - |
-    |            StandardStreamReadByte | Job-OKZLUV |    .NET 4.7.2 |  80.315 us | 26.676 us | 1.4622 us |  1.00 |    0.00 |     - |     - |     - |         - |
-    |        BufferedReadStreamReadByte | Job-OKZLUV |    .NET 4.7.2 | 118.706 us | 38.013 us | 2.0836 us |  1.48 |    0.00 |     - |     - |     - |         - |
-    | BufferedReadStreamChunkedReadByte | Job-OKZLUV |    .NET 4.7.2 | 115.437 us | 33.352 us | 1.8282 us |  1.44 |    0.01 |     - |     - |     - |         - |
-    |    BufferedReadStreamWrapReadByte | Job-OKZLUV |    .NET 4.7.2 |  16.449 us | 11.400 us | 0.6249 us |  0.20 |    0.00 |     - |     - |     - |         - |
-    |                     ArrayReadByte | Job-OKZLUV |    .NET 4.7.2 |  10.416 us |  1.866 us | 0.1023 us |  0.13 |    0.00 |     - |     - |     - |         - |
-    |                                   |            |               |            |           |           |       |         |       |       |       |           |
-    |                StandardStreamRead | Job-CPYMXV | .NET Core 2.1 |  71.425 us | 50.441 us | 2.7648 us |  0.82 |    0.03 |     - |     - |     - |         - |
-    |            BufferedReadStreamRead | Job-CPYMXV | .NET Core 2.1 |  32.816 us |  6.655 us | 0.3648 us |  0.38 |    0.01 |     - |     - |     - |         - |
-    |     BufferedReadStreamChunkedRead | Job-CPYMXV | .NET Core 2.1 |  31.995 us |  7.751 us | 0.4249 us |  0.37 |    0.01 |     - |     - |     - |         - |
-    |        BufferedReadStreamWrapRead | Job-CPYMXV | .NET Core 2.1 |  31.970 us |  4.170 us | 0.2286 us |  0.37 |    0.01 |     - |     - |     - |         - |
-    |            StandardStreamReadByte | Job-CPYMXV | .NET Core 2.1 |  86.909 us | 18.565 us | 1.0176 us |  1.00 |    0.00 |     - |     - |     - |         - |
-    |        BufferedReadStreamReadByte | Job-CPYMXV | .NET Core 2.1 |  14.596 us | 10.889 us | 0.5969 us |  0.17 |    0.01 |     - |     - |     - |         - |
-    | BufferedReadStreamChunkedReadByte | Job-CPYMXV | .NET Core 2.1 |  13.629 us |  1.569 us | 0.0860 us |  0.16 |    0.00 |     - |     - |     - |         - |
-    |    BufferedReadStreamWrapReadByte | Job-CPYMXV | .NET Core 2.1 |  13.566 us |  1.743 us | 0.0956 us |  0.16 |    0.00 |     - |     - |     - |         - |
-    |                     ArrayReadByte | Job-CPYMXV | .NET Core 2.1 |   9.771 us |  6.658 us | 0.3650 us |  0.11 |    0.00 |     - |     - |     - |         - |
-    |                                   |            |               |            |           |           |       |         |       |       |       |           |
-    |                StandardStreamRead | Job-BSGVGU | .NET Core 3.1 |  53.265 us | 65.819 us | 3.6078 us |  0.81 |    0.05 |     - |     - |     - |         - |
-    |            BufferedReadStreamRead | Job-BSGVGU | .NET Core 3.1 |  33.163 us |  9.569 us | 0.5245 us |  0.51 |    0.01 |     - |     - |     - |         - |
-    |     BufferedReadStreamChunkedRead | Job-BSGVGU | .NET Core 3.1 |  33.001 us |  6.114 us | 0.3351 us |  0.50 |    0.01 |     - |     - |     - |         - |
-    |        BufferedReadStreamWrapRead | Job-BSGVGU | .NET Core 3.1 |  29.448 us |  7.120 us | 0.3902 us |  0.45 |    0.01 |     - |     - |     - |         - |
-    |            StandardStreamReadByte | Job-BSGVGU | .NET Core 3.1 |  65.619 us |  6.732 us | 0.3690 us |  1.00 |    0.00 |     - |     - |     - |         - |
-    |        BufferedReadStreamReadByte | Job-BSGVGU | .NET Core 3.1 |  13.989 us |  3.464 us | 0.1899 us |  0.21 |    0.00 |     - |     - |     - |         - |
-    | BufferedReadStreamChunkedReadByte | Job-BSGVGU | .NET Core 3.1 |  13.806 us |  1.710 us | 0.0938 us |  0.21 |    0.00 |     - |     - |     - |         - |
-    |    BufferedReadStreamWrapReadByte | Job-BSGVGU | .NET Core 3.1 |  13.690 us |  1.523 us | 0.0835 us |  0.21 |    0.00 |     - |     - |     - |         - |
-    |                     ArrayReadByte | Job-BSGVGU | .NET Core 3.1 |  10.792 us |  8.228 us | 0.4510 us |  0.16 |    0.01 |     - |     - |     - |         - |
-    */
 }
+
+/*
+BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19041.450 (2004/?/20H1)
+Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+.NET Core SDK=3.1.401
+  [Host]     : .NET Core 3.1.7 (CoreCLR 4.700.20.36602, CoreFX 4.700.20.37001), X64 RyuJIT
+  Job-OKZLUV : .NET Framework 4.8 (4.8.4084.0), X64 RyuJIT
+  Job-CPYMXV : .NET Core 2.1.21 (CoreCLR 4.6.29130.01, CoreFX 4.6.29130.02), X64 RyuJIT
+  Job-BSGVGU : .NET Core 3.1.7 (CoreCLR 4.700.20.36602, CoreFX 4.700.20.37001), X64 RyuJIT
+
+IterationCount=3  LaunchCount=1  WarmupCount=3
+
+|                            Method |        Job |       Runtime |       Mean |     Error |    StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
+|---------------------------------- |----------- |-------------- |-----------:|----------:|----------:|------:|--------:|------:|------:|------:|----------:|
+|                StandardStreamRead | Job-OKZLUV |    .NET 4.7.2 |  66.785 us | 15.768 us | 0.8643 us |  0.83 |    0.01 |     - |     - |     - |         - |
+|            BufferedReadStreamRead | Job-OKZLUV |    .NET 4.7.2 |  97.389 us | 17.658 us | 0.9679 us |  1.21 |    0.01 |     - |     - |     - |         - |
+|     BufferedReadStreamChunkedRead | Job-OKZLUV |    .NET 4.7.2 |  96.006 us | 16.286 us | 0.8927 us |  1.20 |    0.02 |     - |     - |     - |         - |
+|        BufferedReadStreamWrapRead | Job-OKZLUV |    .NET 4.7.2 |  37.064 us | 14.640 us | 0.8024 us |  0.46 |    0.02 |     - |     - |     - |         - |
+|            StandardStreamReadByte | Job-OKZLUV |    .NET 4.7.2 |  80.315 us | 26.676 us | 1.4622 us |  1.00 |    0.00 |     - |     - |     - |         - |
+|        BufferedReadStreamReadByte | Job-OKZLUV |    .NET 4.7.2 | 118.706 us | 38.013 us | 2.0836 us |  1.48 |    0.00 |     - |     - |     - |         - |
+| BufferedReadStreamChunkedReadByte | Job-OKZLUV |    .NET 4.7.2 | 115.437 us | 33.352 us | 1.8282 us |  1.44 |    0.01 |     - |     - |     - |         - |
+|    BufferedReadStreamWrapReadByte | Job-OKZLUV |    .NET 4.7.2 |  16.449 us | 11.400 us | 0.6249 us |  0.20 |    0.00 |     - |     - |     - |         - |
+|                     ArrayReadByte | Job-OKZLUV |    .NET 4.7.2 |  10.416 us |  1.866 us | 0.1023 us |  0.13 |    0.00 |     - |     - |     - |         - |
+|                                   |            |               |            |           |           |       |         |       |       |       |           |
+|                StandardStreamRead | Job-CPYMXV | .NET Core 2.1 |  71.425 us | 50.441 us | 2.7648 us |  0.82 |    0.03 |     - |     - |     - |         - |
+|            BufferedReadStreamRead | Job-CPYMXV | .NET Core 2.1 |  32.816 us |  6.655 us | 0.3648 us |  0.38 |    0.01 |     - |     - |     - |         - |
+|     BufferedReadStreamChunkedRead | Job-CPYMXV | .NET Core 2.1 |  31.995 us |  7.751 us | 0.4249 us |  0.37 |    0.01 |     - |     - |     - |         - |
+|        BufferedReadStreamWrapRead | Job-CPYMXV | .NET Core 2.1 |  31.970 us |  4.170 us | 0.2286 us |  0.37 |    0.01 |     - |     - |     - |         - |
+|            StandardStreamReadByte | Job-CPYMXV | .NET Core 2.1 |  86.909 us | 18.565 us | 1.0176 us |  1.00 |    0.00 |     - |     - |     - |         - |
+|        BufferedReadStreamReadByte | Job-CPYMXV | .NET Core 2.1 |  14.596 us | 10.889 us | 0.5969 us |  0.17 |    0.01 |     - |     - |     - |         - |
+| BufferedReadStreamChunkedReadByte | Job-CPYMXV | .NET Core 2.1 |  13.629 us |  1.569 us | 0.0860 us |  0.16 |    0.00 |     - |     - |     - |         - |
+|    BufferedReadStreamWrapReadByte | Job-CPYMXV | .NET Core 2.1 |  13.566 us |  1.743 us | 0.0956 us |  0.16 |    0.00 |     - |     - |     - |         - |
+|                     ArrayReadByte | Job-CPYMXV | .NET Core 2.1 |   9.771 us |  6.658 us | 0.3650 us |  0.11 |    0.00 |     - |     - |     - |         - |
+|                                   |            |               |            |           |           |       |         |       |       |       |           |
+|                StandardStreamRead | Job-BSGVGU | .NET Core 3.1 |  53.265 us | 65.819 us | 3.6078 us |  0.81 |    0.05 |     - |     - |     - |         - |
+|            BufferedReadStreamRead | Job-BSGVGU | .NET Core 3.1 |  33.163 us |  9.569 us | 0.5245 us |  0.51 |    0.01 |     - |     - |     - |         - |
+|     BufferedReadStreamChunkedRead | Job-BSGVGU | .NET Core 3.1 |  33.001 us |  6.114 us | 0.3351 us |  0.50 |    0.01 |     - |     - |     - |         - |
+|        BufferedReadStreamWrapRead | Job-BSGVGU | .NET Core 3.1 |  29.448 us |  7.120 us | 0.3902 us |  0.45 |    0.01 |     - |     - |     - |         - |
+|            StandardStreamReadByte | Job-BSGVGU | .NET Core 3.1 |  65.619 us |  6.732 us | 0.3690 us |  1.00 |    0.00 |     - |     - |     - |         - |
+|        BufferedReadStreamReadByte | Job-BSGVGU | .NET Core 3.1 |  13.989 us |  3.464 us | 0.1899 us |  0.21 |    0.00 |     - |     - |     - |         - |
+| BufferedReadStreamChunkedReadByte | Job-BSGVGU | .NET Core 3.1 |  13.806 us |  1.710 us | 0.0938 us |  0.21 |    0.00 |     - |     - |     - |         - |
+|    BufferedReadStreamWrapReadByte | Job-BSGVGU | .NET Core 3.1 |  13.690 us |  1.523 us | 0.0835 us |  0.21 |    0.00 |     - |     - |     - |         - |
+|                     ArrayReadByte | Job-BSGVGU | .NET Core 3.1 |  10.792 us |  8.228 us | 0.4510 us |  0.16 |    0.01 |     - |     - |     - |         - |
+*/

tests/ImageSharp.Benchmarks/General/PixelConversion/ITestPixel.cs

@@ -4,27 +4,26 @@
 using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public interface ITestPixel<T>
+    where T : struct, ITestPixel<T>
 {
-    public interface ITestPixel<T>
+    void FromRgba32(Rgba32 source);
-        where T : struct, ITestPixel<T>
-    {
-        void FromRgba32(Rgba32 source);
 
-        void FromRgba32(ref Rgba32 source);
+    void FromRgba32(ref Rgba32 source);
 
-        void FromBytes(byte r, byte g, byte b, byte a);
+    void FromBytes(byte r, byte g, byte b, byte a);
 
-        void FromVector4(Vector4 source);
+    void FromVector4(Vector4 source);
 
-        void FromVector4(ref Vector4 source);
+    void FromVector4(ref Vector4 source);
 
-        Rgba32 ToRgba32();
+    Rgba32 ToRgba32();
 
-        void CopyToRgba32(ref Rgba32 dest);
+    void CopyToRgba32(ref Rgba32 dest);
 
-        Vector4 ToVector4();
+    Vector4 ToVector4();
 
-        void CopyToVector4(ref Vector4 dest);
+    void CopyToVector4(ref Vector4 dest);
-    }
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromRgba32.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
@@ -10,184 +9,183 @@ using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.PixelFormats.Utils;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public abstract class PixelConversion_ConvertFromRgba32
 {
-    public abstract class PixelConversion_ConvertFromRgba32
+    internal struct ConversionRunner<T>
+        where T : struct, ITestPixel<T>
     {
-        internal struct ConversionRunner<T>
+        public readonly T[] Dest;
-            where T : struct, ITestPixel<T>
-        {
-            public readonly T[] Dest;
 
-            public readonly Rgba32[] Source;
+        public readonly Rgba32[] Source;
 
-            public ConversionRunner(int count)
+        public ConversionRunner(int count)
-            {
+        {
-                this.Dest = new T[count];
+            this.Dest = new T[count];
-                this.Source = new Rgba32[count];
+            this.Source = new Rgba32[count];
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunByRefConversion()
+        public void RunByRefConversion()
-            {
+        {
-                int count = this.Dest.Length;
+            int count = this.Dest.Length;
 
-                ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Dest[0];
-                ref Rgba32 sourceBaseRef = ref this.Source[0];
+            ref Rgba32 sourceBaseRef = ref this.Source[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref destBaseRef, i).FromRgba32(ref Unsafe.Add(ref sourceBaseRef, i));
+                Unsafe.Add(ref destBaseRef, i).FromRgba32(ref Unsafe.Add(ref sourceBaseRef, i));
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunByValConversion()
+        public void RunByValConversion()
-            {
+        {
-                int count = this.Dest.Length;
+            int count = this.Dest.Length;
 
-                ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Dest[0];
-                ref Rgba32 sourceBaseRef = ref this.Source[0];
+            ref Rgba32 sourceBaseRef = ref this.Source[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref destBaseRef, i).FromRgba32(Unsafe.Add(ref sourceBaseRef, i));
+                Unsafe.Add(ref destBaseRef, i).FromRgba32(Unsafe.Add(ref sourceBaseRef, i));
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunFromBytesConversion()
+        public void RunFromBytesConversion()
-            {
+        {
-                int count = this.Dest.Length;
+            int count = this.Dest.Length;
 
-                ref T destBaseRef = ref this.Dest[0];
+            ref T destBaseRef = ref this.Dest[0];
-                ref Rgba32 sourceBaseRef = ref this.Source[0];
+            ref Rgba32 sourceBaseRef = ref this.Source[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    ref Rgba32 s = ref Unsafe.Add(ref sourceBaseRef, i);
+                ref Rgba32 s = ref Unsafe.Add(ref sourceBaseRef, i);
-                    Unsafe.Add(ref destBaseRef, i).FromBytes(s.R, s.G, s.B, s.A);
+                Unsafe.Add(ref destBaseRef, i).FromBytes(s.R, s.G, s.B, s.A);
-                }
             }
         }
+    }
 
-        internal ConversionRunner<TestRgba> CompatibleMemLayoutRunner;
+    internal ConversionRunner<TestRgba> CompatibleMemLayoutRunner;
 
-        internal ConversionRunner<TestArgb> PermutedRunnerRgbaToArgb;
+    internal ConversionRunner<TestArgb> PermutedRunnerRgbaToArgb;
 
-        [Params(256, 2048)]
+    [Params(256, 2048)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.CompatibleMemLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
+        this.CompatibleMemLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
-            this.PermutedRunnerRgbaToArgb = new ConversionRunner<TestArgb>(this.Count);
+        this.PermutedRunnerRgbaToArgb = new ConversionRunner<TestArgb>(this.Count);
-        }
     }
+}
 
-    public class PixelConversion_ConvertFromRgba32_Compatible : PixelConversion_ConvertFromRgba32
+public class PixelConversion_ConvertFromRgba32_Compatible : PixelConversion_ConvertFromRgba32
+{
+    [Benchmark(Baseline = true)]
+    public void ByRef()
     {
-        [Benchmark(Baseline = true)]
+        this.CompatibleMemLayoutRunner.RunByRefConversion();
-        public void ByRef()
+    }
-        {
-            this.CompatibleMemLayoutRunner.RunByRefConversion();
-        }
-
-        [Benchmark]
-        public void ByVal()
-        {
-            this.CompatibleMemLayoutRunner.RunByValConversion();
-        }
-
-        [Benchmark]
-        public void FromBytes()
-        {
-            this.CompatibleMemLayoutRunner.RunFromBytesConversion();
-        }
-
-        [Benchmark]
-        public void Inline()
-        {
-            ref Rgba32 sBase = ref this.CompatibleMemLayoutRunner.Source[0];
-            ref Rgba32 dBase = ref Unsafe.As<TestRgba, Rgba32>(ref this.CompatibleMemLayoutRunner.Dest[0]);
 
-            for (int i = 0; i < this.Count; i++)
+    [Benchmark]
-            {
+    public void ByVal()
-                Unsafe.Add(ref dBase, i) = Unsafe.Add(ref sBase, i);
+    {
-            }
+        this.CompatibleMemLayoutRunner.RunByValConversion();
-        }
+    }
 
-        /*   Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
+    [Benchmark]
-         ---------- |------ |---------:|---------:|---------:|-------:|---------:|
+    public void FromBytes()
-              ByRef |   256 | 128.5 ns | 1.217 ns | 1.138 ns |   1.00 |     0.00 |
+    {
-              ByVal |   256 | 196.7 ns | 2.792 ns | 2.612 ns |   1.53 |     0.02 |
+        this.CompatibleMemLayoutRunner.RunFromBytesConversion();
-          FromBytes |   256 | 321.7 ns | 2.180 ns | 1.820 ns |   2.50 |     0.03 |
-             Inline |   256 | 129.9 ns | 2.759 ns | 2.581 ns |   1.01 |     0.02 | */
     }
 
-    public class PixelConversion_ConvertFromRgba32_Permuted_RgbaToArgb : PixelConversion_ConvertFromRgba32
+    [Benchmark]
+    public void Inline()
     {
-        [Benchmark(Baseline = true)]
+        ref Rgba32 sBase = ref this.CompatibleMemLayoutRunner.Source[0];
-        public void ByRef()
+        ref Rgba32 dBase = ref Unsafe.As<TestRgba, Rgba32>(ref this.CompatibleMemLayoutRunner.Dest[0]);
-        {
-            this.PermutedRunnerRgbaToArgb.RunByRefConversion();
-        }
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void ByVal()
         {
-            this.PermutedRunnerRgbaToArgb.RunByValConversion();
+            Unsafe.Add(ref dBase, i) = Unsafe.Add(ref sBase, i);
         }
+    }
 
-        [Benchmark]
+    /*   Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
-        public void FromBytes()
+     ---------- |------ |---------:|---------:|---------:|-------:|---------:|
-        {
+          ByRef |   256 | 128.5 ns | 1.217 ns | 1.138 ns |   1.00 |     0.00 |
-            this.PermutedRunnerRgbaToArgb.RunFromBytesConversion();
+          ByVal |   256 | 196.7 ns | 2.792 ns | 2.612 ns |   1.53 |     0.02 |
-        }
+      FromBytes |   256 | 321.7 ns | 2.180 ns | 1.820 ns |   2.50 |     0.03 |
+         Inline |   256 | 129.9 ns | 2.759 ns | 2.581 ns |   1.01 |     0.02 | */
+}
 
-        [Benchmark]
+public class PixelConversion_ConvertFromRgba32_Permuted_RgbaToArgb : PixelConversion_ConvertFromRgba32
-        public void InlineShuffle()
+{
-        {
+    [Benchmark(Baseline = true)]
-            ref Rgba32 sBase = ref this.PermutedRunnerRgbaToArgb.Source[0];
+    public void ByRef()
-            ref TestArgb dBase = ref this.PermutedRunnerRgbaToArgb.Dest[0];
+    {
+        this.PermutedRunnerRgbaToArgb.RunByRefConversion();
+    }
 
-            for (int i = 0; i < this.Count; i++)
+    [Benchmark]
-            {
+    public void ByVal()
-                Rgba32 s = Unsafe.Add(ref sBase, i);
+    {
-                ref TestArgb d = ref Unsafe.Add(ref dBase, i);
+        this.PermutedRunnerRgbaToArgb.RunByValConversion();
+    }
 
-                d.R = s.R;
+    [Benchmark]
-                d.G = s.G;
+    public void FromBytes()
-                d.B = s.B;
+    {
-                d.A = s.A;
+        this.PermutedRunnerRgbaToArgb.RunFromBytesConversion();
-            }
+    }
-        }
+
+    [Benchmark]
+    public void InlineShuffle()
+    {
+        ref Rgba32 sBase = ref this.PermutedRunnerRgbaToArgb.Source[0];
+        ref TestArgb dBase = ref this.PermutedRunnerRgbaToArgb.Dest[0];
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void PixelConverter_Rgba32_ToArgb32()
         {
-            Span<byte> source = MemoryMarshal.Cast<Rgba32, byte>(this.PermutedRunnerRgbaToArgb.Source);
+            Rgba32 s = Unsafe.Add(ref sBase, i);
-            Span<byte> dest = MemoryMarshal.Cast<TestArgb, byte>(this.PermutedRunnerRgbaToArgb.Dest);
+            ref TestArgb d = ref Unsafe.Add(ref dBase, i);
 
-            PixelConverter.FromRgba32.ToArgb32(source, dest);
+            d.R = s.R;
+            d.G = s.G;
+            d.B = s.B;
+            d.A = s.A;
         }
+    }
 
-        /*
+    [Benchmark]
-        RESULTS:
+    public void PixelConverter_Rgba32_ToArgb32()
-        |                         Method | Count |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD |
+    {
-        |------------------------------- |------ |------------:|----------:|----------:|------------:|------:|--------:|
+        Span<byte> source = MemoryMarshal.Cast<Rgba32, byte>(this.PermutedRunnerRgbaToArgb.Source);
-        |                          ByRef |   256 |   288.84 ns | 19.601 ns | 52.319 ns |   268.10 ns |  1.00 |    0.00 |
+        Span<byte> dest = MemoryMarshal.Cast<TestArgb, byte>(this.PermutedRunnerRgbaToArgb.Dest);
-        |                          ByVal |   256 |   267.97 ns |  1.831 ns |  1.713 ns |   267.85 ns |  0.77 |    0.18 |
+
-        |                      FromBytes |   256 |   266.81 ns |  2.427 ns |  2.270 ns |   266.47 ns |  0.76 |    0.18 |
+        PixelConverter.FromRgba32.ToArgb32(source, dest);
-        |                  InlineShuffle |   256 |   291.41 ns |  5.820 ns |  5.444 ns |   290.17 ns |  0.83 |    0.19 |
-        | PixelConverter_Rgba32_ToArgb32 |   256 |    38.62 ns |  0.431 ns |  0.403 ns |    38.68 ns |  0.11 |    0.03 |
-        |                                |       |             |           |           |             |       |         |
-        |                          ByRef |  2048 | 2,197.69 ns | 15.826 ns | 14.804 ns | 2,197.25 ns |  1.00 |    0.00 |
-        |                          ByVal |  2048 | 2,226.81 ns | 44.266 ns | 62.054 ns | 2,197.17 ns |  1.03 |    0.04 |
-        |                      FromBytes |  2048 | 2,181.35 ns | 18.033 ns | 16.868 ns | 2,185.97 ns |  0.99 |    0.01 |
-        |                  InlineShuffle |  2048 | 2,233.10 ns | 27.673 ns | 24.531 ns | 2,229.78 ns |  1.02 |    0.01 |
-        | PixelConverter_Rgba32_ToArgb32 |  2048 |   139.90 ns |  2.152 ns |  3.825 ns |   138.70 ns |  0.06 |    0.00 |
-        */
     }
+
+    /*
+    RESULTS:
+    |                         Method | Count |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD |
+    |------------------------------- |------ |------------:|----------:|----------:|------------:|------:|--------:|
+    |                          ByRef |   256 |   288.84 ns | 19.601 ns | 52.319 ns |   268.10 ns |  1.00 |    0.00 |
+    |                          ByVal |   256 |   267.97 ns |  1.831 ns |  1.713 ns |   267.85 ns |  0.77 |    0.18 |
+    |                      FromBytes |   256 |   266.81 ns |  2.427 ns |  2.270 ns |   266.47 ns |  0.76 |    0.18 |
+    |                  InlineShuffle |   256 |   291.41 ns |  5.820 ns |  5.444 ns |   290.17 ns |  0.83 |    0.19 |
+    | PixelConverter_Rgba32_ToArgb32 |   256 |    38.62 ns |  0.431 ns |  0.403 ns |    38.68 ns |  0.11 |    0.03 |
+    |                                |       |             |           |           |             |       |         |
+    |                          ByRef |  2048 | 2,197.69 ns | 15.826 ns | 14.804 ns | 2,197.25 ns |  1.00 |    0.00 |
+    |                          ByVal |  2048 | 2,226.81 ns | 44.266 ns | 62.054 ns | 2,197.17 ns |  1.03 |    0.04 |
+    |                      FromBytes |  2048 | 2,181.35 ns | 18.033 ns | 16.868 ns | 2,185.97 ns |  0.99 |    0.01 |
+    |                  InlineShuffle |  2048 | 2,233.10 ns | 27.673 ns | 24.531 ns | 2,229.78 ns |  1.02 |    0.01 |
+    | PixelConverter_Rgba32_ToArgb32 |  2048 |   139.90 ns |  2.152 ns |  3.825 ns |   138.70 ns |  0.06 |    0.00 |
+    */
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertFromVector4.cs

@@ -9,138 +9,137 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public class PixelConversion_ConvertFromVector4
 {
-    public class PixelConversion_ConvertFromVector4
+    [StructLayout(LayoutKind.Sequential)]
+    private struct TestRgbaVector : ITestPixel<TestRgbaVector>
     {
-        [StructLayout(LayoutKind.Sequential)]
+        private Vector4 v;
-        private struct TestRgbaVector : ITestPixel<TestRgbaVector>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FromVector4(Vector4 p)
         {
-            private Vector4 v;
+            this.v = p;
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void FromVector4(Vector4 p)
+        public void FromVector4(ref Vector4 p)
-            {
+        {
-                this.v = p;
+            this.v = p;
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void FromVector4(ref Vector4 p)
+        public Vector4 ToVector4() => this.v;
-            {
-                this.v = p;
-            }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Vector4 ToVector4() => this.v;
+        public void CopyToVector4(ref Vector4 dest)
+        {
+            dest = this.v;
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FromRgba32(Rgba32 source) => throw new System.NotImplementedException();
-            public void CopyToVector4(ref Vector4 dest)
+
-            {
+        public void FromRgba32(ref Rgba32 source) => throw new System.NotImplementedException();
-                dest = this.v;
+
-            }
+        public void FromBytes(byte r, byte g, byte b, byte a) => throw new System.NotImplementedException();
 
-            public void FromRgba32(Rgba32 source) => throw new System.NotImplementedException();
+        public Rgba32 ToRgba32() => throw new System.NotImplementedException();
 
-            public void FromRgba32(ref Rgba32 source) => throw new System.NotImplementedException();
+        public void CopyToRgba32(ref Rgba32 dest) => throw new System.NotImplementedException();
+    }
 
-            public void FromBytes(byte r, byte g, byte b, byte a) => throw new System.NotImplementedException();
+    private struct ConversionRunner<T>
+        where T : struct, ITestPixel<T>
+    {
+        private T[] dest;
 
-            public Rgba32 ToRgba32() => throw new System.NotImplementedException();
+        private Vector4[] source;
 
-            public void CopyToRgba32(ref Rgba32 dest) => throw new System.NotImplementedException();
+        public ConversionRunner(int count)
+        {
+            this.dest = new T[count];
+            this.source = new Vector4[count];
         }
 
-        private struct ConversionRunner<T>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            where T : struct, ITestPixel<T>
+        public void RunByRefConversion()
         {
-            private T[] dest;
+            int count = this.dest.Length;
 
-            private Vector4[] source;
+            ref T destBaseRef = ref this.dest[0];
+            ref Vector4 sourceBaseRef = ref this.source[0];
 
-            public ConversionRunner(int count)
+            for (int i = 0; i < count; i++)
             {
-                this.dest = new T[count];
+                Unsafe.Add(ref destBaseRef, i).FromVector4(ref Unsafe.Add(ref sourceBaseRef, i));
-                this.source = new Vector4[count];
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunByRefConversion()
+        public void RunByValConversion()
-            {
+        {
-                int count = this.dest.Length;
+            int count = this.dest.Length;
-
-                ref T destBaseRef = ref this.dest[0];
-                ref Vector4 sourceBaseRef = ref this.source[0];
 
-                for (int i = 0; i < count; i++)
+            ref T destBaseRef = ref this.dest[0];
-                {
+            ref Vector4 sourceBaseRef = ref this.source[0];
-                    Unsafe.Add(ref destBaseRef, i).FromVector4(ref Unsafe.Add(ref sourceBaseRef, i));
-                }
-            }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            for (int i = 0; i < count; i++)
-            public void RunByValConversion()
             {
-                int count = this.dest.Length;
+                Unsafe.Add(ref destBaseRef, i).FromVector4(Unsafe.Add(ref sourceBaseRef, i));
-
-                ref T destBaseRef = ref this.dest[0];
-                ref Vector4 sourceBaseRef = ref this.source[0];
-
-                for (int i = 0; i < count; i++)
-                {
-                    Unsafe.Add(ref destBaseRef, i).FromVector4(Unsafe.Add(ref sourceBaseRef, i));
-                }
             }
         }
+    }
 
-        private ConversionRunner<TestArgb> nonVectorRunner;
+    private ConversionRunner<TestArgb> nonVectorRunner;
-
-        private ConversionRunner<TestRgbaVector> vectorRunner;
 
-        [Params(32)]
+    private ConversionRunner<TestRgbaVector> vectorRunner;
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(32)]
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.nonVectorRunner = new ConversionRunner<TestArgb>(this.Count);
-            this.vectorRunner = new ConversionRunner<TestRgbaVector>(this.Count);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public void VectorByRef()
+    public void Setup()
-        {
+    {
-            this.vectorRunner.RunByRefConversion();
+        this.nonVectorRunner = new ConversionRunner<TestArgb>(this.Count);
-        }
+        this.vectorRunner = new ConversionRunner<TestRgbaVector>(this.Count);
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void VectorByVal()
+    public void VectorByRef()
-        {
+    {
-            this.vectorRunner.RunByValConversion();
+        this.vectorRunner.RunByRefConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void NonVectorByRef()
+    public void VectorByVal()
-        {
+    {
-            this.nonVectorRunner.RunByRefConversion();
+        this.vectorRunner.RunByValConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void NonVectorByVal()
+    public void NonVectorByRef()
-        {
+    {
-            this.nonVectorRunner.RunByValConversion();
+        this.nonVectorRunner.RunByRefConversion();
-        }
     }
 
-    /*
+    [Benchmark]
-     * Results:
+    public void NonVectorByVal()
-     *          Method | Count |       Mean |    StdDev | Scaled | Scaled-StdDev |
+    {
-     * --------------- |------ |----------- |---------- |------- |-------------- |
+        this.nonVectorRunner.RunByValConversion();
-     *     VectorByRef |    32 | 23.6678 ns | 0.1141 ns |   1.00 |          0.00 |
+    }
-     *     VectorByVal |    32 | 24.5347 ns | 0.0771 ns |   1.04 |          0.01 |
-     *  NonVectorByRef |    32 | 59.0187 ns | 0.2114 ns |   2.49 |          0.01 |
-     *  NonVectorByVal |    32 | 58.7529 ns | 0.2545 ns |   2.48 |          0.02 |
-     *
-     *  !!! Conclusion !!!
-     *  We do not need by-ref version of ConvertFromVector4() stuff
-     */
 }
+
+/*
+ * Results:
+ *          Method | Count |       Mean |    StdDev | Scaled | Scaled-StdDev |
+ * --------------- |------ |----------- |---------- |------- |-------------- |
+ *     VectorByRef |    32 | 23.6678 ns | 0.1141 ns |   1.00 |          0.00 |
+ *     VectorByVal |    32 | 24.5347 ns | 0.0771 ns |   1.04 |          0.01 |
+ *  NonVectorByRef |    32 | 59.0187 ns | 0.2114 ns |   2.49 |          0.01 |
+ *  NonVectorByVal |    32 | 58.7529 ns | 0.2545 ns |   2.48 |          0.02 |
+ *
+ *  !!! Conclusion !!!
+ *  We do not need by-ref version of ConvertFromVector4() stuff
+ */

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertToRgba32.cs

@@ -6,106 +6,105 @@ using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+/// <summary>
+/// When implementing TPixel --> Rgba32 style conversions on IPixel, should which API should we prefer?
+/// 1. Rgba32 ToRgba32();
+/// OR
+/// 2. void CopyToRgba32(ref Rgba32 dest);
+/// ?
+/// </summary>
+public class PixelConversion_ConvertToRgba32
 {
-    /// <summary>
+    private struct ConversionRunner<T>
-    /// When implementing TPixel --> Rgba32 style conversions on IPixel, should which API should we prefer?
+        where T : struct, ITestPixel<T>
-    /// 1. Rgba32 ToRgba32();
-    /// OR
-    /// 2. void CopyToRgba32(ref Rgba32 dest);
-    /// ?
-    /// </summary>
-    public class PixelConversion_ConvertToRgba32
     {
-        private struct ConversionRunner<T>
+        private T[] source;
-            where T : struct, ITestPixel<T>
-        {
-            private T[] source;
 
-            private Rgba32[] dest;
+        private Rgba32[] dest;
 
-            public ConversionRunner(int count)
+        public ConversionRunner(int count)
-            {
+        {
-                this.source = new T[count];
+            this.source = new T[count];
-                this.dest = new Rgba32[count];
+            this.dest = new Rgba32[count];
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunRetvalConversion()
+        public void RunRetvalConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Rgba32 destBaseRef = ref this.dest[0];
+            ref Rgba32 destBaseRef = ref this.dest[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref destBaseRef, i) = Unsafe.Add(ref sourceBaseRef, i).ToRgba32();
+                Unsafe.Add(ref destBaseRef, i) = Unsafe.Add(ref sourceBaseRef, i).ToRgba32();
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunCopyToConversion()
+        public void RunCopyToConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Rgba32 destBaseRef = ref this.dest[0];
+            ref Rgba32 destBaseRef = ref this.dest[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref sourceBaseRef, i).CopyToRgba32(ref Unsafe.Add(ref destBaseRef, i));
+                Unsafe.Add(ref sourceBaseRef, i).CopyToRgba32(ref Unsafe.Add(ref destBaseRef, i));
-                }
             }
         }
+    }
 
-        private ConversionRunner<TestRgba> compatibleMemoryLayoutRunner;
+    private ConversionRunner<TestRgba> compatibleMemoryLayoutRunner;
-
-        private ConversionRunner<TestArgb> permutedRunner;
 
-        [Params(32)]
+    private ConversionRunner<TestArgb> permutedRunner;
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(32)]
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.compatibleMemoryLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
-            this.permutedRunner = new ConversionRunner<TestArgb>(this.Count);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public void CompatibleRetval()
+    public void Setup()
-        {
+    {
-            this.compatibleMemoryLayoutRunner.RunRetvalConversion();
+        this.compatibleMemoryLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
-        }
+        this.permutedRunner = new ConversionRunner<TestArgb>(this.Count);
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void CompatibleCopyTo()
+    public void CompatibleRetval()
-        {
+    {
-            this.compatibleMemoryLayoutRunner.RunCopyToConversion();
+        this.compatibleMemoryLayoutRunner.RunRetvalConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void PermutedRetval()
+    public void CompatibleCopyTo()
-        {
+    {
-            this.permutedRunner.RunRetvalConversion();
+        this.compatibleMemoryLayoutRunner.RunCopyToConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void PermutedCopyTo()
+    public void PermutedRetval()
-        {
+    {
-            this.permutedRunner.RunCopyToConversion();
+        this.permutedRunner.RunRetvalConversion();
-        }
     }
 
-    /*
+    [Benchmark]
-     * Results:
+    public void PermutedCopyTo()
-     *
+    {
-     *            Method | Count |        Mean |    StdDev | Scaled | Scaled-StdDev |
+        this.permutedRunner.RunCopyToConversion();
-     *   --------------- |------ |------------ |---------- |------- |-------------- |
+    }
-     *  CompatibleRetval |   128 |  89.7358 ns | 2.2389 ns |   1.00 |          0.00 |
-     *  CompatibleCopyTo |   128 |  89.4112 ns | 2.2901 ns |   1.00 |          0.03 |
-     *    PermutedRetval |   128 | 845.4038 ns | 5.6154 ns |   9.43 |          0.23 |
-     *    PermutedCopyTo |   128 | 155.6004 ns | 3.8870 ns |   1.73 |          0.06 |
-     */
 }
+
+/*
+ * Results:
+ *
+ *            Method | Count |        Mean |    StdDev | Scaled | Scaled-StdDev |
+ *   --------------- |------ |------------ |---------- |------- |-------------- |
+ *  CompatibleRetval |   128 |  89.7358 ns | 2.2389 ns |   1.00 |          0.00 |
+ *  CompatibleCopyTo |   128 |  89.4112 ns | 2.2901 ns |   1.00 |          0.03 |
+ *    PermutedRetval |   128 | 845.4038 ns | 5.6154 ns |   9.43 |          0.23 |
+ *    PermutedCopyTo |   128 | 155.6004 ns | 3.8870 ns |   1.73 |          0.06 |
+ */

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertToRgba32_AsPartOfCompositeOperation.cs

@@ -6,110 +6,109 @@ using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public class PixelConversion_ConvertToRgba32_AsPartOfCompositeOperation
 {
-    public class PixelConversion_ConvertToRgba32_AsPartOfCompositeOperation
+    private struct ConversionRunner<T>
+        where T : struct, ITestPixel<T>
     {
-        private struct ConversionRunner<T>
+        private T[] source;
-            where T : struct, ITestPixel<T>
-        {
-            private T[] source;
 
-            private Rgba32[] dest;
+        private Rgba32[] dest;
 
-            public ConversionRunner(int count)
+        public ConversionRunner(int count)
-            {
+        {
-                this.source = new T[count];
+            this.source = new T[count];
-                this.dest = new Rgba32[count];
+            this.dest = new Rgba32[count];
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunRetvalConversion()
+        public void RunRetvalConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Rgba32 destBaseRef = ref this.dest[0];
+            ref Rgba32 destBaseRef = ref this.dest[0];
 
-                Rgba32 temp;
+            Rgba32 temp;
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    temp = Unsafe.Add(ref sourceBaseRef, i).ToRgba32();
+                temp = Unsafe.Add(ref sourceBaseRef, i).ToRgba32();
 
-                    // manipulate pixel before saving to dest buffer:
+                // manipulate pixel before saving to dest buffer:
-                    temp.A = 0;
+                temp.A = 0;
 
-                    Unsafe.Add(ref destBaseRef, i) = temp;
+                Unsafe.Add(ref destBaseRef, i) = temp;
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunCopyToConversion()
+        public void RunCopyToConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Rgba32 destBaseRef = ref this.dest[0];
+            ref Rgba32 destBaseRef = ref this.dest[0];
 
-                Rgba32 temp = default;
+            Rgba32 temp = default;
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref sourceBaseRef, i).CopyToRgba32(ref temp);
+                Unsafe.Add(ref sourceBaseRef, i).CopyToRgba32(ref temp);
 
-                    // manipulate pixel before saving to dest buffer:
+                // manipulate pixel before saving to dest buffer:
-                    temp.A = 0;
+                temp.A = 0;
 
-                    Unsafe.Add(ref destBaseRef, i) = temp;
+                Unsafe.Add(ref destBaseRef, i) = temp;
-                }
             }
         }
+    }
 
-        private ConversionRunner<TestRgba> compatibleMemoryLayoutRunner;
+    private ConversionRunner<TestRgba> compatibleMemoryLayoutRunner;
-
-        private ConversionRunner<TestArgb> permutedRunner;
 
-        [Params(32)]
+    private ConversionRunner<TestArgb> permutedRunner;
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(32)]
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.compatibleMemoryLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
-            this.permutedRunner = new ConversionRunner<TestArgb>(this.Count);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public void CompatibleRetval()
+    public void Setup()
-        {
+    {
-            this.compatibleMemoryLayoutRunner.RunRetvalConversion();
+        this.compatibleMemoryLayoutRunner = new ConversionRunner<TestRgba>(this.Count);
-        }
+        this.permutedRunner = new ConversionRunner<TestArgb>(this.Count);
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void CompatibleCopyTo()
+    public void CompatibleRetval()
-        {
+    {
-            this.compatibleMemoryLayoutRunner.RunCopyToConversion();
+        this.compatibleMemoryLayoutRunner.RunRetvalConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void PermutedRetval()
+    public void CompatibleCopyTo()
-        {
+    {
-            this.permutedRunner.RunRetvalConversion();
+        this.compatibleMemoryLayoutRunner.RunCopyToConversion();
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void PermutedCopyTo()
+    public void PermutedRetval()
-        {
+    {
-            this.permutedRunner.RunCopyToConversion();
+        this.permutedRunner.RunRetvalConversion();
-        }
     }
 
-    // RESULTS:
+    [Benchmark]
-    //            Method | Count |      Mean |     Error |    StdDev | Scaled | ScaledSD |
+    public void PermutedCopyTo()
-    // ----------------- |------ |----------:|----------:|----------:|-------:|---------:|
+    {
-    //  CompatibleRetval |    32 |  53.05 ns | 0.1865 ns | 0.1557 ns |   1.00 |     0.00 |
+        this.permutedRunner.RunCopyToConversion();
-    //  CompatibleCopyTo |    32 |  36.12 ns | 0.3596 ns | 0.3003 ns |   0.68 |     0.01 |
+    }
-    //    PermutedRetval |    32 | 303.61 ns | 5.1697 ns | 4.8358 ns |   5.72 |     0.09 |
-    //    PermutedCopyTo |    32 |  38.05 ns | 0.8053 ns | 1.2297 ns |   0.72 |     0.02 |
 }
+
+// RESULTS:
+//            Method | Count |      Mean |     Error |    StdDev | Scaled | ScaledSD |
+// ----------------- |------ |----------:|----------:|----------:|-------:|---------:|
+//  CompatibleRetval |    32 |  53.05 ns | 0.1865 ns | 0.1557 ns |   1.00 |     0.00 |
+//  CompatibleCopyTo |    32 |  36.12 ns | 0.3596 ns | 0.3003 ns |   0.68 |     0.01 |
+//    PermutedRetval |    32 | 303.61 ns | 5.1697 ns | 4.8358 ns |   5.72 |     0.09 |
+//    PermutedCopyTo |    32 |  38.05 ns | 0.8053 ns | 1.2297 ns |   0.72 |     0.02 |

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertToVector4.cs

@@ -5,79 +5,78 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public class PixelConversion_ConvertToVector4
 {
-    public class PixelConversion_ConvertToVector4
+    private struct ConversionRunner<T>
+        where T : struct, ITestPixel<T>
     {
-        private struct ConversionRunner<T>
+        private T[] source;
-            where T : struct, ITestPixel<T>
-        {
-            private T[] source;
 
-            private Vector4[] dest;
+        private Vector4[] dest;
 
-            public ConversionRunner(int count)
+        public ConversionRunner(int count)
-            {
+        {
-                this.source = new T[count];
+            this.source = new T[count];
-                this.dest = new Vector4[count];
+            this.dest = new Vector4[count];
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunRetvalConversion()
+        public void RunRetvalConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Vector4 destBaseRef = ref this.dest[0];
+            ref Vector4 destBaseRef = ref this.dest[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref destBaseRef, i) = Unsafe.Add(ref sourceBaseRef, i).ToVector4();
+                Unsafe.Add(ref destBaseRef, i) = Unsafe.Add(ref sourceBaseRef, i).ToVector4();
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunCopyToConversion()
+        public void RunCopyToConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Vector4 destBaseRef = ref this.dest[0];
+            ref Vector4 destBaseRef = ref this.dest[0];
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref sourceBaseRef, i).CopyToVector4(ref Unsafe.Add(ref destBaseRef, i));
+                Unsafe.Add(ref sourceBaseRef, i).CopyToVector4(ref Unsafe.Add(ref destBaseRef, i));
-                }
             }
         }
+    }
 
-        private ConversionRunner<TestRgba> runner;
+    private ConversionRunner<TestRgba> runner;
-
-        [Params(32)]
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(32)]
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.runner = new ConversionRunner<TestRgba>(this.Count);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public void UseRetval()
+    public void Setup()
-        {
+    {
-            this.runner.RunRetvalConversion();
+        this.runner = new ConversionRunner<TestRgba>(this.Count);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void UseCopyTo()
+    public void UseRetval()
-        {
+    {
-            this.runner.RunCopyToConversion();
+        this.runner.RunRetvalConversion();
-        }
+    }
 
-        // RESULTS:
+    [Benchmark]
-        //     Method | Count |     Mean |    Error |   StdDev | Scaled |
+    public void UseCopyTo()
-        // ---------- |------ |---------:|---------:|---------:|-------:|
+    {
-        //  UseRetval |    32 | 109.0 ns | 1.202 ns | 1.125 ns |   1.00 |
+        this.runner.RunCopyToConversion();
-        //  UseCopyTo |    32 | 108.6 ns | 1.151 ns | 1.020 ns |   1.00 |
     }
+
+    // RESULTS:
+    //     Method | Count |     Mean |    Error |   StdDev | Scaled |
+    // ---------- |------ |---------:|---------:|---------:|-------:|
+    //  UseRetval |    32 | 109.0 ns | 1.202 ns | 1.125 ns |   1.00 |
+    //  UseCopyTo |    32 | 108.6 ns | 1.151 ns | 1.020 ns |   1.00 |
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_ConvertToVector4_AsPartOfCompositeOperation.cs

@@ -5,93 +5,92 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public class PixelConversion_ConvertToVector4_AsPartOfCompositeOperation
 {
-    public class PixelConversion_ConvertToVector4_AsPartOfCompositeOperation
+    private struct ConversionRunner<T>
+        where T : struct, ITestPixel<T>
     {
-        private struct ConversionRunner<T>
+        private T[] source;
-            where T : struct, ITestPixel<T>
-        {
-            private T[] source;
 
-            private Vector4[] dest;
+        private Vector4[] dest;
 
-            public ConversionRunner(int count)
+        public ConversionRunner(int count)
-            {
+        {
-                this.source = new T[count];
+            this.source = new T[count];
-                this.dest = new Vector4[count];
+            this.dest = new Vector4[count];
-            }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunRetvalConversion()
+        public void RunRetvalConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Vector4 destBaseRef = ref this.dest[0];
+            ref Vector4 destBaseRef = ref this.dest[0];
 
-                Vector4 temp;
+            Vector4 temp;
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    temp = Unsafe.Add(ref sourceBaseRef, i).ToVector4();
+                temp = Unsafe.Add(ref sourceBaseRef, i).ToVector4();
 
-                    // manipulate pixel before saving to dest buffer:
+                // manipulate pixel before saving to dest buffer:
-                    temp.W = 0;
+                temp.W = 0;
 
-                    Unsafe.Add(ref destBaseRef, i) = temp;
+                Unsafe.Add(ref destBaseRef, i) = temp;
-                }
             }
+        }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void RunCopyToConversion()
+        public void RunCopyToConversion()
-            {
+        {
-                int count = this.source.Length;
+            int count = this.source.Length;
 
-                ref T sourceBaseRef = ref this.source[0];
+            ref T sourceBaseRef = ref this.source[0];
-                ref Vector4 destBaseRef = ref this.dest[0];
+            ref Vector4 destBaseRef = ref this.dest[0];
 
-                Vector4 temp = default;
+            Vector4 temp = default;
 
-                for (int i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
-                {
+            {
-                    Unsafe.Add(ref sourceBaseRef, i).CopyToVector4(ref temp);
+                Unsafe.Add(ref sourceBaseRef, i).CopyToVector4(ref temp);
 
-                    // manipulate pixel before saving to dest buffer:
+                // manipulate pixel before saving to dest buffer:
-                    temp.W = 0;
+                temp.W = 0;
 
-                    Unsafe.Add(ref destBaseRef, i) = temp;
+                Unsafe.Add(ref destBaseRef, i) = temp;
-                }
             }
         }
+    }
 
-        private ConversionRunner<TestRgba> runner;
+    private ConversionRunner<TestRgba> runner;
-
-        [Params(32)]
-        public int Count { get; set; }
 
-        [GlobalSetup]
+    [Params(32)]
-        public void Setup()
+    public int Count { get; set; }
-        {
-            this.runner = new ConversionRunner<TestRgba>(this.Count);
-        }
 
-        [Benchmark(Baseline = true)]
+    [GlobalSetup]
-        public void UseRetval()
+    public void Setup()
-        {
+    {
-            this.runner.RunRetvalConversion();
+        this.runner = new ConversionRunner<TestRgba>(this.Count);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark(Baseline = true)]
-        public void UseCopyTo()
+    public void UseRetval()
-        {
+    {
-            this.runner.RunCopyToConversion();
+        this.runner.RunRetvalConversion();
-        }
+    }
 
-        // RESULTS:
+    [Benchmark]
-        //     Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
+    public void UseCopyTo()
-        // ---------- |------ |---------:|---------:|---------:|-------:|---------:|
+    {
-        //  UseRetval |    32 | 120.2 ns | 1.560 ns | 1.383 ns |   1.00 |     0.00 |
+        this.runner.RunCopyToConversion();
-        //  UseCopyTo |    32 | 121.7 ns | 2.439 ns | 2.281 ns |   1.01 |     0.02 |
     }
+
+    // RESULTS:
+    //     Method | Count |     Mean |    Error |   StdDev | Scaled | ScaledSD |
+    // ---------- |------ |---------:|---------:|---------:|-------:|---------:|
+    //  UseRetval |    32 | 120.2 ns | 1.560 ns | 1.383 ns |   1.00 |     0.00 |
+    //  UseCopyTo |    32 | 121.7 ns | 2.439 ns | 2.281 ns |   1.01 |     0.02 |
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_PackFromRgbPlanes.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -9,280 +8,279 @@ using System.Runtime.Intrinsics.X86;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public unsafe class PixelConversion_PackFromRgbPlanes
 {
-    public unsafe class PixelConversion_PackFromRgbPlanes
+    private byte[] rBuf;
-    {
+    private byte[] gBuf;
-        private byte[] rBuf;
+    private byte[] bBuf;
-        private byte[] gBuf;
+    private Rgb24[] rgbBuf;
-        private byte[] bBuf;
+    private Rgba32[] rgbaBuf;
-        private Rgb24[] rgbBuf;
-        private Rgba32[] rgbaBuf;
 
-        private float[] rFloat;
+    private float[] rFloat;
-        private float[] gFloat;
+    private float[] gFloat;
-        private float[] bFloat;
+    private float[] bFloat;
 
-        private float[] rgbaFloat;
+    private float[] rgbaFloat;
 
-        [Params(1024)]
+    [Params(1024)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.rBuf = new byte[this.Count];
+        this.rBuf = new byte[this.Count];
-            this.gBuf = new byte[this.Count];
+        this.gBuf = new byte[this.Count];
-            this.bBuf = new byte[this.Count];
+        this.bBuf = new byte[this.Count];
-            this.rgbBuf = new Rgb24[this.Count + 3]; // padded
+        this.rgbBuf = new Rgb24[this.Count + 3]; // padded
-            this.rgbaBuf = new Rgba32[this.Count];
+        this.rgbaBuf = new Rgba32[this.Count];
 
-            this.rFloat = new float[this.Count];
+        this.rFloat = new float[this.Count];
-            this.gFloat = new float[this.Count];
+        this.gFloat = new float[this.Count];
-            this.bFloat = new float[this.Count];
+        this.bFloat = new float[this.Count];
 
-            this.rgbaFloat = new float[this.Count * 4];
+        this.rgbaFloat = new float[this.Count * 4];
-        }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void Rgb24_Scalar_PerElement_Pinned()
+    public void Rgb24_Scalar_PerElement_Pinned()
+    {
+        fixed (byte* r = &this.rBuf[0])
         {
-            fixed (byte* r = &this.rBuf[0])
+            fixed (byte* g = &this.gBuf[0])
             {
-                fixed (byte* g = &this.gBuf[0])
+                fixed (byte* b = &this.bBuf[0])
                 {
-                    fixed (byte* b = &this.bBuf[0])
+                    fixed (Rgb24* rgb = &this.rgbBuf[0])
                     {
-                        fixed (Rgb24* rgb = &this.rgbBuf[0])
+                        for (int i = 0; i < this.Count; i++)
                         {
-                            for (int i = 0; i < this.Count; i++)
+                            Rgb24* d = rgb + i;
-                            {
+                            d->R = r[i];
-                                Rgb24* d = rgb + i;
+                            d->G = g[i];
-                                d->R = r[i];
+                            d->B = b[i];
-                                d->G = g[i];
-                                d->B = b[i];
-                            }
                         }
                     }
                 }
             }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgb24_Scalar_PerElement_Span()
+    public void Rgb24_Scalar_PerElement_Span()
-        {
+    {
-            Span<byte> r = this.rBuf;
+        Span<byte> r = this.rBuf;
-            Span<byte> g = this.rBuf;
+        Span<byte> g = this.rBuf;
-            Span<byte> b = this.rBuf;
+        Span<byte> b = this.rBuf;
-            Span<Rgb24> rgb = this.rgbBuf;
+        Span<Rgb24> rgb = this.rgbBuf;
 
-            for (int i = 0; i < r.Length; i++)
+        for (int i = 0; i < r.Length; i++)
-            {
+        {
-                ref Rgb24 d = ref rgb[i];
+            ref Rgb24 d = ref rgb[i];
-                d.R = r[i];
+            d.R = r[i];
-                d.G = g[i];
+            d.G = g[i];
-                d.B = b[i];
+            d.B = b[i];
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgb24_Scalar_PerElement_Unsafe()
+    public void Rgb24_Scalar_PerElement_Unsafe()
-        {
+    {
-            ref byte r = ref this.rBuf[0];
+        ref byte r = ref this.rBuf[0];
-            ref byte g = ref this.rBuf[0];
+        ref byte g = ref this.rBuf[0];
-            ref byte b = ref this.rBuf[0];
+        ref byte b = ref this.rBuf[0];
-            ref Rgb24 rgb = ref this.rgbBuf[0];
+        ref Rgb24 rgb = ref this.rgbBuf[0];
 
-            for (int i = 0; i < this.Count; i++)
+        for (int i = 0; i < this.Count; i++)
-            {
+        {
-                ref Rgb24 d = ref Unsafe.Add(ref rgb, i);
+            ref Rgb24 d = ref Unsafe.Add(ref rgb, i);
-                d.R = Unsafe.Add(ref r, i);
+            d.R = Unsafe.Add(ref r, i);
-                d.G = Unsafe.Add(ref g, i);
+            d.G = Unsafe.Add(ref g, i);
-                d.B = Unsafe.Add(ref b, i);
+            d.B = Unsafe.Add(ref b, i);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgb24_Scalar_PerElement_Batched8()
+    public void Rgb24_Scalar_PerElement_Batched8()
-        {
+    {
-            ref Byte8 r = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
+        ref Byte8 r = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
-            ref Byte8 g = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
+        ref Byte8 g = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
-            ref Byte8 b = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
+        ref Byte8 b = ref Unsafe.As<byte, Byte8>(ref this.rBuf[0]);
-            ref Rgb24 rgb = ref this.rgbBuf[0];
+        ref Rgb24 rgb = ref this.rgbBuf[0];
 
-            int count = this.Count / 8;
+        int count = this.Count / 8;
-            for (int i = 0; i < count; i++)
+        for (int i = 0; i < count; i++)
-            {
+        {
-                ref Rgb24 d0 = ref Unsafe.Add(ref rgb, i * 8);
+            ref Rgb24 d0 = ref Unsafe.Add(ref rgb, i * 8);
-                ref Rgb24 d1 = ref Unsafe.Add(ref d0, 1);
+            ref Rgb24 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Rgb24 d2 = ref Unsafe.Add(ref d0, 2);
+            ref Rgb24 d2 = ref Unsafe.Add(ref d0, 2);
-                ref Rgb24 d3 = ref Unsafe.Add(ref d0, 3);
+            ref Rgb24 d3 = ref Unsafe.Add(ref d0, 3);
-                ref Rgb24 d4 = ref Unsafe.Add(ref d0, 4);
+            ref Rgb24 d4 = ref Unsafe.Add(ref d0, 4);
-                ref Rgb24 d5 = ref Unsafe.Add(ref d0, 5);
+            ref Rgb24 d5 = ref Unsafe.Add(ref d0, 5);
-                ref Rgb24 d6 = ref Unsafe.Add(ref d0, 6);
+            ref Rgb24 d6 = ref Unsafe.Add(ref d0, 6);
-                ref Rgb24 d7 = ref Unsafe.Add(ref d0, 7);
+            ref Rgb24 d7 = ref Unsafe.Add(ref d0, 7);
-
+
-                ref Byte8 rr = ref Unsafe.Add(ref r, i);
+            ref Byte8 rr = ref Unsafe.Add(ref r, i);
-                ref Byte8 gg = ref Unsafe.Add(ref g, i);
+            ref Byte8 gg = ref Unsafe.Add(ref g, i);
-                ref Byte8 bb = ref Unsafe.Add(ref b, i);
+            ref Byte8 bb = ref Unsafe.Add(ref b, i);
-
+
-                d0.R = rr.V0;
+            d0.R = rr.V0;
-                d0.G = gg.V0;
+            d0.G = gg.V0;
-                d0.B = bb.V0;
+            d0.B = bb.V0;
-
+
-                d1.R = rr.V1;
+            d1.R = rr.V1;
-                d1.G = gg.V1;
+            d1.G = gg.V1;
-                d1.B = bb.V1;
+            d1.B = bb.V1;
-
+
-                d2.R = rr.V2;
+            d2.R = rr.V2;
-                d2.G = gg.V2;
+            d2.G = gg.V2;
-                d2.B = bb.V2;
+            d2.B = bb.V2;
-
+
-                d3.R = rr.V3;
+            d3.R = rr.V3;
-                d3.G = gg.V3;
+            d3.G = gg.V3;
-                d3.B = bb.V3;
+            d3.B = bb.V3;
-
+
-                d4.R = rr.V4;
+            d4.R = rr.V4;
-                d4.G = gg.V4;
+            d4.G = gg.V4;
-                d4.B = bb.V4;
+            d4.B = bb.V4;
-
+
-                d5.R = rr.V5;
+            d5.R = rr.V5;
-                d5.G = gg.V5;
+            d5.G = gg.V5;
-                d5.B = bb.V5;
+            d5.B = bb.V5;
-
+
-                d6.R = rr.V6;
+            d6.R = rr.V6;
-                d6.G = gg.V6;
+            d6.G = gg.V6;
-                d6.B = bb.V6;
+            d6.B = bb.V6;
-
+
-                d7.R = rr.V7;
+            d7.R = rr.V7;
-                d7.G = gg.V7;
+            d7.G = gg.V7;
-                d7.B = bb.V7;
+            d7.B = bb.V7;
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgb24_Scalar_PerElement_Batched4()
+    public void Rgb24_Scalar_PerElement_Batched4()
-        {
+    {
-            ref Byte4 r = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
+        ref Byte4 r = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
-            ref Byte4 g = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
+        ref Byte4 g = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
-            ref Byte4 b = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
+        ref Byte4 b = ref Unsafe.As<byte, Byte4>(ref this.rBuf[0]);
-            ref Rgb24 rgb = ref this.rgbBuf[0];
+        ref Rgb24 rgb = ref this.rgbBuf[0];
 
-            int count = this.Count / 4;
+        int count = this.Count / 4;
-            for (int i = 0; i < count; i++)
+        for (int i = 0; i < count; i++)
-            {
+        {
-                ref Rgb24 d0 = ref Unsafe.Add(ref rgb, i * 4);
+            ref Rgb24 d0 = ref Unsafe.Add(ref rgb, i * 4);
-                ref Rgb24 d1 = ref Unsafe.Add(ref d0, 1);
+            ref Rgb24 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Rgb24 d2 = ref Unsafe.Add(ref d0, 2);
+            ref Rgb24 d2 = ref Unsafe.Add(ref d0, 2);
-                ref Rgb24 d3 = ref Unsafe.Add(ref d0, 3);
+            ref Rgb24 d3 = ref Unsafe.Add(ref d0, 3);
-
+
-                ref Byte4 rr = ref Unsafe.Add(ref r, i);
+            ref Byte4 rr = ref Unsafe.Add(ref r, i);
-                ref Byte4 gg = ref Unsafe.Add(ref g, i);
+            ref Byte4 gg = ref Unsafe.Add(ref g, i);
-                ref Byte4 bb = ref Unsafe.Add(ref b, i);
+            ref Byte4 bb = ref Unsafe.Add(ref b, i);
-
+
-                d0.R = rr.V0;
+            d0.R = rr.V0;
-                d0.G = gg.V0;
+            d0.G = gg.V0;
-                d0.B = bb.V0;
+            d0.B = bb.V0;
-
+
-                d1.R = rr.V1;
+            d1.R = rr.V1;
-                d1.G = gg.V1;
+            d1.G = gg.V1;
-                d1.B = bb.V1;
+            d1.B = bb.V1;
-
+
-                d2.R = rr.V2;
+            d2.R = rr.V2;
-                d2.G = gg.V2;
+            d2.G = gg.V2;
-                d2.B = bb.V2;
+            d2.B = bb.V2;
-
+
-                d3.R = rr.V3;
+            d3.R = rr.V3;
-                d3.G = gg.V3;
+            d3.G = gg.V3;
-                d3.B = bb.V3;
+            d3.B = bb.V3;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Rgba32_Avx2_Float()
+    public void Rgba32_Avx2_Float()
-        {
+    {
-            ref Vector256<float> rBase = ref Unsafe.As<float, Vector256<float>>(ref this.rFloat[0]);
+        ref Vector256<float> rBase = ref Unsafe.As<float, Vector256<float>>(ref this.rFloat[0]);
-            ref Vector256<float> gBase = ref Unsafe.As<float, Vector256<float>>(ref this.gFloat[0]);
+        ref Vector256<float> gBase = ref Unsafe.As<float, Vector256<float>>(ref this.gFloat[0]);
-            ref Vector256<float> bBase = ref Unsafe.As<float, Vector256<float>>(ref this.bFloat[0]);
+        ref Vector256<float> bBase = ref Unsafe.As<float, Vector256<float>>(ref this.bFloat[0]);
-            ref Vector256<float> resultBase = ref Unsafe.As<float, Vector256<float>>(ref this.rgbaFloat[0]);
+        ref Vector256<float> resultBase = ref Unsafe.As<float, Vector256<float>>(ref this.rgbaFloat[0]);
 
-            int count = this.Count / Vector256<float>.Count;
+        int count = this.Count / Vector256<float>.Count;
 
-            ref byte control = ref MemoryMarshal.GetReference(SimdUtils.HwIntrinsics.PermuteMaskEvenOdd8x32);
+        ref byte control = ref MemoryMarshal.GetReference(SimdUtils.HwIntrinsics.PermuteMaskEvenOdd8x32);
-            Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
+        Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
 
-            var va = Vector256.Create(1F);
+        var va = Vector256.Create(1F);
 
-            for (int i = 0; i < count; i++)
+        for (int i = 0; i < count; i++)
-            {
+        {
-                Vector256<float> r = Unsafe.Add(ref rBase, i);
+            Vector256<float> r = Unsafe.Add(ref rBase, i);
-                Vector256<float> g = Unsafe.Add(ref gBase, i);
+            Vector256<float> g = Unsafe.Add(ref gBase, i);
-                Vector256<float> b = Unsafe.Add(ref bBase, i);
+            Vector256<float> b = Unsafe.Add(ref bBase, i);
 
-                r = Avx2.PermuteVar8x32(r, vcontrol);
+            r = Avx2.PermuteVar8x32(r, vcontrol);
-                g = Avx2.PermuteVar8x32(g, vcontrol);
+            g = Avx2.PermuteVar8x32(g, vcontrol);
-                b = Avx2.PermuteVar8x32(b, vcontrol);
+            b = Avx2.PermuteVar8x32(b, vcontrol);
 
-                Vector256<float> vte = Avx.UnpackLow(r, b);
+            Vector256<float> vte = Avx.UnpackLow(r, b);
-                Vector256<float> vto = Avx.UnpackLow(g, va);
+            Vector256<float> vto = Avx.UnpackLow(g, va);
 
-                ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
+            ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
 
-                destination = Avx.UnpackLow(vte, vto);
+            destination = Avx.UnpackLow(vte, vto);
-                Unsafe.Add(ref destination, 1) = Avx.UnpackHigh(vte, vto);
+            Unsafe.Add(ref destination, 1) = Avx.UnpackHigh(vte, vto);
 
-                vte = Avx.UnpackHigh(r, b);
+            vte = Avx.UnpackHigh(r, b);
-                vto = Avx.UnpackHigh(g, va);
+            vto = Avx.UnpackHigh(g, va);
 
-                Unsafe.Add(ref destination, 2) = Avx.UnpackLow(vte, vto);
+            Unsafe.Add(ref destination, 2) = Avx.UnpackLow(vte, vto);
-                Unsafe.Add(ref destination, 3) = Avx.UnpackHigh(vte, vto);
+            Unsafe.Add(ref destination, 3) = Avx.UnpackHigh(vte, vto);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgb24_Avx2_Bytes()
+    public void Rgb24_Avx2_Bytes()
-        {
+    {
-            ReadOnlySpan<byte> r = this.rBuf;
+        ReadOnlySpan<byte> r = this.rBuf;
-            ReadOnlySpan<byte> g = this.rBuf;
+        ReadOnlySpan<byte> g = this.rBuf;
-            ReadOnlySpan<byte> b = this.rBuf;
+        ReadOnlySpan<byte> b = this.rBuf;
-            Span<Rgb24> rgb = this.rgbBuf;
+        Span<Rgb24> rgb = this.rgbBuf;
-            SimdUtils.HwIntrinsics.PackFromRgbPlanesAvx2Reduce(ref r, ref g, ref b, ref rgb);
+        SimdUtils.HwIntrinsics.PackFromRgbPlanesAvx2Reduce(ref r, ref g, ref b, ref rgb);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Rgba32_Avx2_Bytes()
+    public void Rgba32_Avx2_Bytes()
-        {
+    {
-            ReadOnlySpan<byte> r = this.rBuf;
+        ReadOnlySpan<byte> r = this.rBuf;
-            ReadOnlySpan<byte> g = this.rBuf;
+        ReadOnlySpan<byte> g = this.rBuf;
-            ReadOnlySpan<byte> b = this.rBuf;
+        ReadOnlySpan<byte> b = this.rBuf;
-            Span<Rgba32> rgb = this.rgbaBuf;
+        Span<Rgba32> rgb = this.rgbaBuf;
-            SimdUtils.HwIntrinsics.PackFromRgbPlanesAvx2Reduce(ref r, ref g, ref b, ref rgb);
+        SimdUtils.HwIntrinsics.PackFromRgbPlanesAvx2Reduce(ref r, ref g, ref b, ref rgb);
-        }
+    }
 
 #pragma warning disable SA1132
-        private struct Byte8
+    private struct Byte8
-        {
+    {
-            public byte V0, V1, V2, V3, V4, V5, V6, V7;
+        public byte V0, V1, V2, V3, V4, V5, V6, V7;
-        }
+    }
 
-        private struct Byte4
+    private struct Byte4
-        {
+    {
-            public byte V0, V1, V2, V3;
+        public byte V0, V1, V2, V3;
-        }
+    }
 #pragma warning restore
 
-        // Results @ Anton's PC, 2020 Dec 05
+    // Results @ Anton's PC, 2020 Dec 05
-        // .NET Core 3.1.1
+    // .NET Core 3.1.1
-        // Intel Core i7-7700HQ CPU 2.80GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
+    // Intel Core i7-7700HQ CPU 2.80GHz (Kaby Lake), 1 CPU, 8 logical and 4 physical cores
-        //
+    //
-        // |                           Method | Count |       Mean |    Error |   StdDev | Ratio | RatioSD |
+    // |                           Method | Count |       Mean |    Error |   StdDev | Ratio | RatioSD |
-        // |--------------------------------- |------ |-----------:|---------:|---------:|------:|--------:|
+    // |--------------------------------- |------ |-----------:|---------:|---------:|------:|--------:|
-        // |     Rgb24_Scalar_PerElement_Span |  1024 | 1,634.6 ns | 26.56 ns | 24.84 ns |  3.12 |    0.05 |
+    // |     Rgb24_Scalar_PerElement_Span |  1024 | 1,634.6 ns | 26.56 ns | 24.84 ns |  3.12 |    0.05 |
-        // |   Rgb24_Scalar_PerElement_Unsafe |  1024 | 1,284.7 ns |  4.70 ns |  4.16 ns |  2.46 |    0.01 |
+    // |   Rgb24_Scalar_PerElement_Unsafe |  1024 | 1,284.7 ns |  4.70 ns |  4.16 ns |  2.46 |    0.01 |
-        // | Rgb24_Scalar_PerElement_Batched8 |  1024 | 1,182.3 ns |  5.12 ns |  4.27 ns |  2.26 |    0.01 |
+    // | Rgb24_Scalar_PerElement_Batched8 |  1024 | 1,182.3 ns |  5.12 ns |  4.27 ns |  2.26 |    0.01 |
-        // | Rgb24_Scalar_PerElement_Batched4 |  1024 | 1,146.2 ns | 16.38 ns | 14.52 ns |  2.19 |    0.02 |
+    // | Rgb24_Scalar_PerElement_Batched4 |  1024 | 1,146.2 ns | 16.38 ns | 14.52 ns |  2.19 |    0.02 |
-        // |                Rgba32_Avx2_Float |  1024 |   522.7 ns |  1.78 ns |  1.39 ns |  1.00 |    0.00 |
+    // |                Rgba32_Avx2_Float |  1024 |   522.7 ns |  1.78 ns |  1.39 ns |  1.00 |    0.00 |
-        // |                Rgb24_Avx2_Bytes |  1024 |   243.3 ns |  1.56 ns |  1.30 ns |  0.47 |    0.00 |
+    // |                Rgb24_Avx2_Bytes |  1024 |   243.3 ns |  1.56 ns |  1.30 ns |  0.47 |    0.00 |
-        // |                Rgba32_Avx2_Bytes |  1024 |   146.0 ns |  2.48 ns |  2.32 ns |  0.28 |    0.01 |
+    // |                Rgba32_Avx2_Bytes |  1024 |   146.0 ns |  2.48 ns |  2.32 ns |  0.28 |    0.01 |
-    }
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Argb32.cs

@@ -1,179 +1,177 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
 
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+public class PixelConversion_Rgba32_To_Argb32
 {
-    public class PixelConversion_Rgba32_To_Argb32
+    private Rgba32[] source;
-    {
-        private Rgba32[] source;
 
-        private Argb32[] dest;
+    private Argb32[] dest;
 
-        [Params(64)]
+    [Params(64)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.source = new Rgba32[this.Count];
+        this.source = new Rgba32[this.Count];
-            this.dest = new Argb32[this.Count];
+        this.dest = new Argb32[this.Count];
-        }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Default()
+    public void Default()
-        {
+    {
-            ref Rgba32 sBase = ref this.source[0];
+        ref Rgba32 sBase = ref this.source[0];
-            ref Argb32 dBase = ref this.dest[0];
+        ref Argb32 dBase = ref this.dest[0];
-
-            for (int i = 0; i < this.Count; i++)
-            {
-                Rgba32 s = Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i).FromRgba32(s);
-            }
-        }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        for (int i = 0; i < this.Count; i++)
-        private static void Default_GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+            Rgba32 s = Unsafe.Add(ref sBase, i);
-            ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
+            Unsafe.Add(ref dBase, i).FromRgba32(s);
-
-            for (int i = 0; i < source.Length; i++)
-            {
-                Rgba32 s = Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i).FromRgba32(s);
-            }
         }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void Default_GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
 
-        [Benchmark]
+        for (int i = 0; i < source.Length; i++)
-        public void Default_Generic()
         {
-            Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+            Rgba32 s = Unsafe.Add(ref sBase, i);
+            Unsafe.Add(ref dBase, i).FromRgba32(s);
         }
+    }
+
+    [Benchmark]
+    public void Default_Generic()
+    {
+        Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+    }
+
+    [Benchmark]
+    public void Default_Group2()
+    {
+        ref Rgba32 sBase = ref this.source[0];
+        ref Argb32 dBase = ref this.dest[0];
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i += 2)
-        public void Default_Group2()
         {
-            ref Rgba32 sBase = ref this.source[0];
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-            ref Argb32 dBase = ref this.dest[0];
+            Rgba32 s1 = Unsafe.Add(ref s0, 1);
-
+
-            for (int i = 0; i < this.Count; i += 2)
+            ref Argb32 d0 = ref Unsafe.Add(ref dBase, i);
-            {
+            d0.FromRgba32(s0);
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            Unsafe.Add(ref d0, 1).FromRgba32(s1);
-                Rgba32 s1 = Unsafe.Add(ref s0, 1);
-
-                ref Argb32 d0 = ref Unsafe.Add(ref dBase, i);
-                d0.FromRgba32(s0);
-                Unsafe.Add(ref d0, 1).FromRgba32(s1);
-            }
         }
+    }
+
+    [Benchmark]
+    public void Default_Group4()
+    {
+        ref Rgba32 sBase = ref this.source[0];
+        ref Argb32 dBase = ref this.dest[0];
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i += 4)
-        public void Default_Group4()
         {
-            ref Rgba32 sBase = ref this.source[0];
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-            ref Argb32 dBase = ref this.dest[0];
+            ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
-
+            ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
-            for (int i = 0; i < this.Count; i += 4)
+            Rgba32 s3 = Unsafe.Add(ref s2, 1);
-            {
+
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            ref Argb32 d0 = ref Unsafe.Add(ref dBase, i);
-                ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
+            ref Argb32 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
+            ref Argb32 d2 = ref Unsafe.Add(ref d1, 1);
-                Rgba32 s3 = Unsafe.Add(ref s2, 1);
+
-
+            d0.FromRgba32(s0);
-                ref Argb32 d0 = ref Unsafe.Add(ref dBase, i);
+            d1.FromRgba32(s1);
-                ref Argb32 d1 = ref Unsafe.Add(ref d0, 1);
+            d2.FromRgba32(s2);
-                ref Argb32 d2 = ref Unsafe.Add(ref d1, 1);
+            Unsafe.Add(ref d2, 1).FromRgba32(s3);
-
-                d0.FromRgba32(s0);
-                d1.FromRgba32(s1);
-                d2.FromRgba32(s2);
-                Unsafe.Add(ref d2, 1).FromRgba32(s3);
-            }
         }
+    }
+
+    [Benchmark]
+    public void BitOps()
+    {
+        ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+        ref uint dBase = ref Unsafe.As<Argb32, uint>(ref this.dest[0]);
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void BitOps()
         {
-            ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+            uint s = Unsafe.Add(ref sBase, i);
-            ref uint dBase = ref Unsafe.As<Argb32, uint>(ref this.dest[0]);
+            Unsafe.Add(ref dBase, i) = FromRgba32.ToArgb32(s);
-
-            for (int i = 0; i < this.Count; i++)
-            {
-                uint s = Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i) = FromRgba32.ToArgb32(s);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void BitOps_GroupAsULong()
+    public void BitOps_GroupAsULong()
-        {
+    {
-            ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
+        ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
-            ref ulong dBase = ref Unsafe.As<Argb32, ulong>(ref this.dest[0]);
+        ref ulong dBase = ref Unsafe.As<Argb32, ulong>(ref this.dest[0]);
 
-            for (int i = 0; i < this.Count / 2; i++)
+        for (int i = 0; i < this.Count / 2; i++)
-            {
+        {
-                ulong s = Unsafe.Add(ref sBase, i);
+            ulong s = Unsafe.Add(ref sBase, i);
-                uint lo = (uint)s;
+            uint lo = (uint)s;
-                uint hi = (uint)(s >> 32);
+            uint hi = (uint)(s >> 32);
-                lo = FromRgba32.ToArgb32(lo);
+            lo = FromRgba32.ToArgb32(lo);
-                hi = FromRgba32.ToArgb32(hi);
+            hi = FromRgba32.ToArgb32(hi);
 
-                s = (ulong)(hi << 32) | lo;
+            s = (ulong)(hi << 32) | lo;
 
-                Unsafe.Add(ref dBase, i) = s;
+            Unsafe.Add(ref dBase, i) = s;
-            }
         }
+    }
 
-        public static class FromRgba32
+    public static class FromRgba32
+    {
+        /// <summary>
+        /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
+        /// </summary>
+        /// <returns>The argb value.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static uint ToArgb32(uint packedRgba)
         {
-            /// <summary>
+            // packedRgba          = [aa bb gg rr]
-            /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
+            // ROL(8, packedRgba)  = [bb gg rr aa]
-            /// </summary>
+            return (packedRgba << 8) | (packedRgba >> 24);
-            /// <returns>The argb value.</returns>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            public static uint ToArgb32(uint packedRgba)
-            {
-                // packedRgba          = [aa bb gg rr]
-                // ROL(8, packedRgba)  = [bb gg rr aa]
-                return (packedRgba << 8) | (packedRgba >> 24);
-            }
-
-            /// <summary>
-            /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-            /// </summary>
-            /// <returns>The bgra value.</returns>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            public static uint ToBgra32(uint packedRgba)
-            {
-                // packedRgba          = [aa bb gg rr]
-                // tmp1                = [aa 00 gg 00]
-                // tmp2                = [00 bb 00 rr]
-                // tmp3=ROL(16, tmp2)  = [00 rr 00 bb]
-                // tmp1 + tmp3         = [aa rr gg bb]
-                uint tmp1 = packedRgba & 0xFF00FF00;
-                uint tmp2 = packedRgba & 0x00FF00FF;
-                uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
-                return tmp1 + tmp3;
-            }
         }
 
-        // RESULTS:
+        /// <summary>
-        //               Method | Count |      Mean |     Error |    StdDev | Scaled |
+        /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-        // -------------------- |------ |----------:|----------:|----------:|-------:|
+        /// </summary>
-        //              Default |    64 | 107.33 ns | 1.0633 ns | 0.9426 ns |   1.00 |
+        /// <returns>The bgra value.</returns>
-        //      Default_Generic |    64 | 111.15 ns | 0.3789 ns | 0.3544 ns |   1.04 |
+        [MethodImpl(InliningOptions.ShortMethod)]
-        //       Default_Group2 |    64 |  90.36 ns | 0.7779 ns | 0.6896 ns |   0.84 |
+        public static uint ToBgra32(uint packedRgba)
-        //       Default_Group4 |    64 |  82.39 ns | 0.2726 ns | 0.2550 ns |   0.77 |
+        {
-        //               BitOps |    64 |  39.25 ns | 0.3266 ns | 0.2895 ns |   0.37 |
+            // packedRgba          = [aa bb gg rr]
-        //  BitOps_GroupAsULong |    64 |  41.80 ns | 0.2227 ns | 0.2083 ns |   0.39 |
+            // tmp1                = [aa 00 gg 00]
+            // tmp2                = [00 bb 00 rr]
+            // tmp3=ROL(16, tmp2)  = [00 rr 00 bb]
+            // tmp1 + tmp3         = [aa rr gg bb]
+            uint tmp1 = packedRgba & 0xFF00FF00;
+            uint tmp2 = packedRgba & 0x00FF00FF;
+            uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
+            return tmp1 + tmp3;
+        }
     }
+
+    // RESULTS:
+    //               Method | Count |      Mean |     Error |    StdDev | Scaled |
+    // -------------------- |------ |----------:|----------:|----------:|-------:|
+    //              Default |    64 | 107.33 ns | 1.0633 ns | 0.9426 ns |   1.00 |
+    //      Default_Generic |    64 | 111.15 ns | 0.3789 ns | 0.3544 ns |   1.04 |
+    //       Default_Group2 |    64 |  90.36 ns | 0.7779 ns | 0.6896 ns |   0.84 |
+    //       Default_Group4 |    64 |  82.39 ns | 0.2726 ns | 0.2550 ns |   0.77 |
+    //               BitOps |    64 |  39.25 ns | 0.3266 ns | 0.2895 ns |   0.37 |
+    //  BitOps_GroupAsULong |    64 |  41.80 ns | 0.2227 ns | 0.2083 ns |   0.39 |
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/PixelConversion_Rgba32_To_Bgra32.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -10,389 +9,388 @@ using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tuples;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+// [MonoJob]
+// [RyuJitX64Job]
+public class PixelConversion_Rgba32_To_Bgra32
 {
-    // [MonoJob]
+    private Rgba32[] source;
-    // [RyuJitX64Job]
-    public class PixelConversion_Rgba32_To_Bgra32
-    {
-        private Rgba32[] source;
 
-        private Bgra32[] dest;
+    private Bgra32[] dest;
 
-        [StructLayout(LayoutKind.Sequential)]
+    [StructLayout(LayoutKind.Sequential)]
-        private struct Tuple4OfUInt32
+    private struct Tuple4OfUInt32
+    {
+        private uint v0;
+        private uint v1;
+        private uint v2;
+        private uint v3;
+
+        public void ConvertMe()
         {
-            private uint v0;
+            this.v0 = FromRgba32.ToBgra32(this.v0);
-            private uint v1;
+            this.v1 = FromRgba32.ToBgra32(this.v1);
-            private uint v2;
+            this.v2 = FromRgba32.ToBgra32(this.v2);
-            private uint v3;
+            this.v3 = FromRgba32.ToBgra32(this.v3);
-
-            public void ConvertMe()
-            {
-                this.v0 = FromRgba32.ToBgra32(this.v0);
-                this.v1 = FromRgba32.ToBgra32(this.v1);
-                this.v2 = FromRgba32.ToBgra32(this.v2);
-                this.v3 = FromRgba32.ToBgra32(this.v3);
-            }
         }
+    }
 
-        [Params(64)]
+    [Params(64)]
-        public int Count { get; set; }
+    public int Count { get; set; }
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
-        {
+    {
-            this.source = new Rgba32[this.Count];
+        this.source = new Rgba32[this.Count];
-            this.dest = new Bgra32[this.Count];
+        this.dest = new Bgra32[this.Count];
-        }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Default()
+    public void Default()
-        {
+    {
-            ref Rgba32 sBase = ref this.source[0];
+        ref Rgba32 sBase = ref this.source[0];
-            ref Bgra32 dBase = ref this.dest[0];
+        ref Bgra32 dBase = ref this.dest[0];
-
-            for (int i = 0; i < this.Count; i++)
-            {
-                ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i).FromRgba32(s);
-            }
-        }
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        for (int i = 0; i < this.Count; i++)
-        private static void Default_GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-            ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
+            Unsafe.Add(ref dBase, i).FromRgba32(s);
-
-            for (int i = 0; i < source.Length; i++)
-            {
-                ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i).FromRgba32(s);
-            }
         }
+    }
 
-        [Benchmark]
+    [MethodImpl(MethodImplOptions.NoInlining)]
-        public void Default_Generic()
+    private static void Default_GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
-        {
+        where TPixel : unmanaged, IPixel<TPixel>
-            Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+    {
-        }
+        ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
 
-        [Benchmark]
+        for (int i = 0; i < source.Length; i++)
-        public void Default_Group2()
         {
-            ref Rgba32 sBase = ref this.source[0];
+            ref Rgba32 s = ref Unsafe.Add(ref sBase, i);
-            ref Bgra32 dBase = ref this.dest[0];
+            Unsafe.Add(ref dBase, i).FromRgba32(s);
-
-            for (int i = 0; i < this.Count; i += 2)
-            {
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-                Rgba32 s1 = Unsafe.Add(ref s0, 1);
-
-                ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-                d0.FromRgba32(s0);
-                Unsafe.Add(ref d0, 1).FromRgba32(s1);
-            }
         }
+    }
+
+    [Benchmark]
+    public void Default_Generic()
+    {
+        Default_GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Default_Group4()
+    public void Default_Group2()
+    {
+        ref Rgba32 sBase = ref this.source[0];
+        ref Bgra32 dBase = ref this.dest[0];
+
+        for (int i = 0; i < this.Count; i += 2)
         {
-            ref Rgba32 sBase = ref this.source[0];
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-            ref Bgra32 dBase = ref this.dest[0];
+            Rgba32 s1 = Unsafe.Add(ref s0, 1);
-
+
-            for (int i = 0; i < this.Count; i += 4)
+            ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-            {
+            d0.FromRgba32(s0);
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            Unsafe.Add(ref d0, 1).FromRgba32(s1);
-                ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
-                ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
-                Rgba32 s3 = Unsafe.Add(ref s2, 1);
-
-                ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-                ref Bgra32 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Bgra32 d2 = ref Unsafe.Add(ref d1, 1);
-
-                d0.FromRgba32(s0);
-                d1.FromRgba32(s1);
-                d2.FromRgba32(s2);
-                Unsafe.Add(ref d2, 1).FromRgba32(s3);
-            }
         }
+    }
+
+    [Benchmark]
+    public void Default_Group4()
+    {
+        ref Rgba32 sBase = ref this.source[0];
+        ref Bgra32 dBase = ref this.dest[0];
 
-        [MethodImpl(MethodImplOptions.NoInlining)]
+        for (int i = 0; i < this.Count; i += 4)
-        private static void Group4GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-            ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
+            ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
-
+            ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
-            for (int i = 0; i < source.Length; i += 4)
+            Rgba32 s3 = Unsafe.Add(ref s2, 1);
-            {
+
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-                ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
+            ref Bgra32 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
+            ref Bgra32 d2 = ref Unsafe.Add(ref d1, 1);
-                Rgba32 s3 = Unsafe.Add(ref s2, 1);
+
-
+            d0.FromRgba32(s0);
-                ref TPixel d0 = ref Unsafe.Add(ref dBase, i);
+            d1.FromRgba32(s1);
-                ref TPixel d1 = ref Unsafe.Add(ref d0, 1);
+            d2.FromRgba32(s2);
-                ref TPixel d2 = ref Unsafe.Add(ref d1, 1);
+            Unsafe.Add(ref d2, 1).FromRgba32(s3);
-
-                d0.FromRgba32(s0);
-                d1.FromRgba32(s1);
-                d2.FromRgba32(s2);
-                Unsafe.Add(ref d2, 1).FromRgba32(s3);
-            }
         }
+    }
 
-        // [Benchmark]
+    [MethodImpl(MethodImplOptions.NoInlining)]
-        public void Default_Group4_Generic()
+    private static void Group4GenericImpl<TPixel>(ReadOnlySpan<Rgba32> source, Span<TPixel> dest)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        ref Rgba32 sBase = ref MemoryMarshal.GetReference(source);
+        ref TPixel dBase = ref MemoryMarshal.GetReference(dest);
+
+        for (int i = 0; i < source.Length; i += 4)
         {
-            Group4GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
+            ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
+            Rgba32 s3 = Unsafe.Add(ref s2, 1);
+
+            ref TPixel d0 = ref Unsafe.Add(ref dBase, i);
+            ref TPixel d1 = ref Unsafe.Add(ref d0, 1);
+            ref TPixel d2 = ref Unsafe.Add(ref d1, 1);
+
+            d0.FromRgba32(s0);
+            d1.FromRgba32(s1);
+            d2.FromRgba32(s2);
+            Unsafe.Add(ref d2, 1).FromRgba32(s3);
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void Default_Group8()
+    public void Default_Group4_Generic()
+    {
+        Group4GenericImpl(this.source.AsSpan(), this.dest.AsSpan());
+    }
+
+    // [Benchmark]
+    public void Default_Group8()
+    {
+        ref Rgba32 sBase = ref this.source[0];
+        ref Bgra32 dBase = ref this.dest[0];
+
+        for (int i = 0; i < this.Count / 4; i += 4)
         {
-            ref Rgba32 sBase = ref this.source[0];
+            ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
-            ref Bgra32 dBase = ref this.dest[0];
+            ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
-
+            ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
-            for (int i = 0; i < this.Count / 4; i += 4)
+            ref Rgba32 s3 = ref Unsafe.Add(ref s1, 1);
-            {
+
-                ref Rgba32 s0 = ref Unsafe.Add(ref sBase, i);
+            ref Rgba32 s4 = ref Unsafe.Add(ref s3, 1);
-                ref Rgba32 s1 = ref Unsafe.Add(ref s0, 1);
+            ref Rgba32 s5 = ref Unsafe.Add(ref s4, 1);
-                ref Rgba32 s2 = ref Unsafe.Add(ref s1, 1);
+            ref Rgba32 s6 = ref Unsafe.Add(ref s5, 1);
-                ref Rgba32 s3 = ref Unsafe.Add(ref s1, 1);
+            Rgba32 s7 = Unsafe.Add(ref s6, 1);
-
+
-                ref Rgba32 s4 = ref Unsafe.Add(ref s3, 1);
+            ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
-                ref Rgba32 s5 = ref Unsafe.Add(ref s4, 1);
+            ref Bgra32 d1 = ref Unsafe.Add(ref d0, 1);
-                ref Rgba32 s6 = ref Unsafe.Add(ref s5, 1);
+            ref Bgra32 d2 = ref Unsafe.Add(ref d1, 1);
-                Rgba32 s7 = Unsafe.Add(ref s6, 1);
+            ref Bgra32 d3 = ref Unsafe.Add(ref d2, 1);
-
+            ref Bgra32 d4 = ref Unsafe.Add(ref d3, 1);
-                ref Bgra32 d0 = ref Unsafe.Add(ref dBase, i);
+
-                ref Bgra32 d1 = ref Unsafe.Add(ref d0, 1);
+            ref Bgra32 d5 = ref Unsafe.Add(ref d4, 1);
-                ref Bgra32 d2 = ref Unsafe.Add(ref d1, 1);
+            ref Bgra32 d6 = ref Unsafe.Add(ref d5, 1);
-                ref Bgra32 d3 = ref Unsafe.Add(ref d2, 1);
+
-                ref Bgra32 d4 = ref Unsafe.Add(ref d3, 1);
+            d0.FromRgba32(s0);
-
+            d1.FromRgba32(s1);
-                ref Bgra32 d5 = ref Unsafe.Add(ref d4, 1);
+            d2.FromRgba32(s2);
-                ref Bgra32 d6 = ref Unsafe.Add(ref d5, 1);
+            d3.FromRgba32(s3);
-
+
-                d0.FromRgba32(s0);
+            d4.FromRgba32(s4);
-                d1.FromRgba32(s1);
+            d5.FromRgba32(s5);
-                d2.FromRgba32(s2);
+            d6.FromRgba32(s6);
-                d3.FromRgba32(s3);
+            Unsafe.Add(ref d6, 1).FromRgba32(s7);
-
-                d4.FromRgba32(s4);
-                d5.FromRgba32(s5);
-                d6.FromRgba32(s6);
-                Unsafe.Add(ref d6, 1).FromRgba32(s7);
-            }
         }
+    }
+
+    [Benchmark]
+    public void BitOps()
+    {
+        ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+        ref uint dBase = ref Unsafe.As<Bgra32, uint>(ref this.dest[0]);
 
-        [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void BitOps()
         {
-            ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+            uint s = Unsafe.Add(ref sBase, i);
-            ref uint dBase = ref Unsafe.As<Bgra32, uint>(ref this.dest[0]);
+            Unsafe.Add(ref dBase, i) = FromRgba32.ToBgra32(s);
-
-            for (int i = 0; i < this.Count; i++)
-            {
-                uint s = Unsafe.Add(ref sBase, i);
-                Unsafe.Add(ref dBase, i) = FromRgba32.ToBgra32(s);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Bitops_Tuple()
+    public void Bitops_Tuple()
+    {
+        ref Tuple4OfUInt32 sBase = ref Unsafe.As<Rgba32, Tuple4OfUInt32>(ref this.source[0]);
+        ref Tuple4OfUInt32 dBase = ref Unsafe.As<Bgra32, Tuple4OfUInt32>(ref this.dest[0]);
+
+        for (int i = 0; i < this.Count / 4; i++)
         {
-            ref Tuple4OfUInt32 sBase = ref Unsafe.As<Rgba32, Tuple4OfUInt32>(ref this.source[0]);
+            ref Tuple4OfUInt32 d = ref Unsafe.Add(ref dBase, i);
-            ref Tuple4OfUInt32 dBase = ref Unsafe.As<Bgra32, Tuple4OfUInt32>(ref this.dest[0]);
+            d = Unsafe.Add(ref sBase, i);
-
+            d.ConvertMe();
-            for (int i = 0; i < this.Count / 4; i++)
-            {
-                ref Tuple4OfUInt32 d = ref Unsafe.Add(ref dBase, i);
-                d = Unsafe.Add(ref sBase, i);
-                d.ConvertMe();
-            }
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void Bitops_SingleTuple()
+    public void Bitops_SingleTuple()
-        {
+    {
-            ref Tuple4OfUInt32 sBase = ref Unsafe.As<Rgba32, Tuple4OfUInt32>(ref this.source[0]);
+        ref Tuple4OfUInt32 sBase = ref Unsafe.As<Rgba32, Tuple4OfUInt32>(ref this.source[0]);
 
-            for (int i = 0; i < this.Count / 4; i++)
+        for (int i = 0; i < this.Count / 4; i++)
-            {
+        {
-                Unsafe.Add(ref sBase, i).ConvertMe();
+            Unsafe.Add(ref sBase, i).ConvertMe();
-            }
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void Bitops_Simd()
+    public void Bitops_Simd()
-        {
+    {
-            ref Octet<uint> sBase = ref Unsafe.As<Rgba32, Octet<uint>>(ref this.source[0]);
+        ref Octet<uint> sBase = ref Unsafe.As<Rgba32, Octet<uint>>(ref this.source[0]);
-            ref Octet<uint> dBase = ref Unsafe.As<Bgra32, Octet<uint>>(ref this.dest[0]);
+        ref Octet<uint> dBase = ref Unsafe.As<Bgra32, Octet<uint>>(ref this.dest[0]);
 
-            for (int i = 0; i < this.Count / 8; i++)
+        for (int i = 0; i < this.Count / 8; i++)
-            {
+        {
-                BitopsSimdImpl(ref Unsafe.Add(ref sBase, i), ref Unsafe.Add(ref dBase, i));
+            BitopsSimdImpl(ref Unsafe.Add(ref sBase, i), ref Unsafe.Add(ref dBase, i));
-            }
         }
+    }
 
 #pragma warning disable SA1132 // Do not combine fields
-        [StructLayout(LayoutKind.Sequential)]
+    [StructLayout(LayoutKind.Sequential)]
-        private struct B
+    private struct B
-        {
+    {
-            public uint Tmp2, Tmp5, Tmp8, Tmp11, Tmp14, Tmp17, Tmp20, Tmp23;
+        public uint Tmp2, Tmp5, Tmp8, Tmp11, Tmp14, Tmp17, Tmp20, Tmp23;
-        }
+    }
 
-        [StructLayout(LayoutKind.Sequential)]
+    [StructLayout(LayoutKind.Sequential)]
-        private struct C
+    private struct C
-        {
+    {
-            public uint Tmp3, Tmp6, Tmp9, Tmp12, Tmp15, Tmp18, Tmp21, Tmp24;
+        public uint Tmp3, Tmp6, Tmp9, Tmp12, Tmp15, Tmp18, Tmp21, Tmp24;
-        }
+    }
 #pragma warning restore SA1132 // Do not combine fields
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void BitopsSimdImpl(ref Octet<uint> s, ref Octet<uint> d)
+    private static void BitopsSimdImpl(ref Octet<uint> s, ref Octet<uint> d)
-        {
+    {
-            Vector<uint> sVec = Unsafe.As<Octet<uint>, Vector<uint>>(ref s);
+        Vector<uint> sVec = Unsafe.As<Octet<uint>, Vector<uint>>(ref s);
-            var aMask = new Vector<uint>(0xFF00FF00);
+        var aMask = new Vector<uint>(0xFF00FF00);
-            var bMask = new Vector<uint>(0x00FF00FF);
+        var bMask = new Vector<uint>(0x00FF00FF);
 
-            Vector<uint> aa = sVec & aMask;
+        Vector<uint> aa = sVec & aMask;
-            Vector<uint> bb = sVec & bMask;
+        Vector<uint> bb = sVec & bMask;
 
-            B b = Unsafe.As<Vector<uint>, B>(ref bb);
+        B b = Unsafe.As<Vector<uint>, B>(ref bb);
 
-            C c = default;
+        C c = default;
 
-            c.Tmp3 = (b.Tmp2 << 16) | (b.Tmp2 >> 16);
+        c.Tmp3 = (b.Tmp2 << 16) | (b.Tmp2 >> 16);
-            c.Tmp6 = (b.Tmp5 << 16) | (b.Tmp5 >> 16);
+        c.Tmp6 = (b.Tmp5 << 16) | (b.Tmp5 >> 16);
-            c.Tmp9 = (b.Tmp8 << 16) | (b.Tmp8 >> 16);
+        c.Tmp9 = (b.Tmp8 << 16) | (b.Tmp8 >> 16);
-            c.Tmp12 = (b.Tmp11 << 16) | (b.Tmp11 >> 16);
+        c.Tmp12 = (b.Tmp11 << 16) | (b.Tmp11 >> 16);
-            c.Tmp15 = (b.Tmp14 << 16) | (b.Tmp14 >> 16);
+        c.Tmp15 = (b.Tmp14 << 16) | (b.Tmp14 >> 16);
-            c.Tmp18 = (b.Tmp17 << 16) | (b.Tmp17 >> 16);
+        c.Tmp18 = (b.Tmp17 << 16) | (b.Tmp17 >> 16);
-            c.Tmp21 = (b.Tmp20 << 16) | (b.Tmp20 >> 16);
+        c.Tmp21 = (b.Tmp20 << 16) | (b.Tmp20 >> 16);
-            c.Tmp24 = (b.Tmp23 << 16) | (b.Tmp23 >> 16);
+        c.Tmp24 = (b.Tmp23 << 16) | (b.Tmp23 >> 16);
 
-            Vector<uint> cc = Unsafe.As<C, Vector<uint>>(ref c);
+        Vector<uint> cc = Unsafe.As<C, Vector<uint>>(ref c);
-            Vector<uint> dd = aa + cc;
+        Vector<uint> dd = aa + cc;
 
-            d = Unsafe.As<Vector<uint>, Octet<uint>>(ref dd);
+        d = Unsafe.As<Vector<uint>, Octet<uint>>(ref dd);
-        }
+    }
+
+    // [Benchmark]
+    public void BitOps_Group2()
+    {
+        ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+        ref uint dBase = ref Unsafe.As<Bgra32, uint>(ref this.dest[0]);
 
-        // [Benchmark]
+        for (int i = 0; i < this.Count; i++)
-        public void BitOps_Group2()
         {
-            ref uint sBase = ref Unsafe.As<Rgba32, uint>(ref this.source[0]);
+            ref uint s0 = ref Unsafe.Add(ref sBase, i);
-            ref uint dBase = ref Unsafe.As<Bgra32, uint>(ref this.dest[0]);
+            uint s1 = Unsafe.Add(ref s0, 1);
-
+
-            for (int i = 0; i < this.Count; i++)
+            ref uint d0 = ref Unsafe.Add(ref dBase, i);
-            {
+            d0 = FromRgba32.ToBgra32(s0);
-                ref uint s0 = ref Unsafe.Add(ref sBase, i);
+            Unsafe.Add(ref d0, 1) = FromRgba32.ToBgra32(s1);
-                uint s1 = Unsafe.Add(ref s0, 1);
-
-                ref uint d0 = ref Unsafe.Add(ref dBase, i);
-                d0 = FromRgba32.ToBgra32(s0);
-                Unsafe.Add(ref d0, 1) = FromRgba32.ToBgra32(s1);
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void BitOps_GroupAsULong()
+    public void BitOps_GroupAsULong()
-        {
+    {
-            ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
+        ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
-            ref ulong dBase = ref Unsafe.As<Bgra32, ulong>(ref this.dest[0]);
+        ref ulong dBase = ref Unsafe.As<Bgra32, ulong>(ref this.dest[0]);
 
-            for (int i = 0; i < this.Count / 2; i++)
+        for (int i = 0; i < this.Count / 2; i++)
-            {
+        {
-                ulong s = Unsafe.Add(ref sBase, i);
+            ulong s = Unsafe.Add(ref sBase, i);
-                uint lo = (uint)s;
+            uint lo = (uint)s;
-                uint hi = (uint)(s >> 32);
+            uint hi = (uint)(s >> 32);
-                lo = FromRgba32.ToBgra32(lo);
+            lo = FromRgba32.ToBgra32(lo);
-                hi = FromRgba32.ToBgra32(hi);
+            hi = FromRgba32.ToBgra32(hi);
 
-                s = (ulong)(hi << 32) | lo;
+            s = (ulong)(hi << 32) | lo;
 
-                Unsafe.Add(ref dBase, i) = s;
+            Unsafe.Add(ref dBase, i) = s;
-            }
         }
+    }
 
-        // [Benchmark]
+    // [Benchmark]
-        public void BitOps_GroupAsULong_V2()
+    public void BitOps_GroupAsULong_V2()
-        {
+    {
-            ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
+        ref ulong sBase = ref Unsafe.As<Rgba32, ulong>(ref this.source[0]);
-            ref ulong dBase = ref Unsafe.As<Bgra32, ulong>(ref this.dest[0]);
+        ref ulong dBase = ref Unsafe.As<Bgra32, ulong>(ref this.dest[0]);
 
-            for (int i = 0; i < this.Count / 2; i++)
+        for (int i = 0; i < this.Count / 2; i++)
-            {
+        {
-                ulong s = Unsafe.Add(ref sBase, i);
+            ulong s = Unsafe.Add(ref sBase, i);
-                uint lo = (uint)s;
+            uint lo = (uint)s;
-                uint hi = (uint)(s >> 32);
+            uint hi = (uint)(s >> 32);
 
-                uint tmp1 = lo & 0xFF00FF00;
+            uint tmp1 = lo & 0xFF00FF00;
-                uint tmp4 = hi & 0xFF00FF00;
+            uint tmp4 = hi & 0xFF00FF00;
 
-                uint tmp2 = lo & 0x00FF00FF;
+            uint tmp2 = lo & 0x00FF00FF;
-                uint tmp5 = hi & 0x00FF00FF;
+            uint tmp5 = hi & 0x00FF00FF;
 
-                uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
+            uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
-                uint tmp6 = (tmp5 << 16) | (tmp5 >> 16);
+            uint tmp6 = (tmp5 << 16) | (tmp5 >> 16);
 
-                lo = tmp1 + tmp3;
+            lo = tmp1 + tmp3;
-                hi = tmp4 + tmp6;
+            hi = tmp4 + tmp6;
 
-                s = (ulong)(hi << 32) | lo;
+            s = (ulong)(hi << 32) | lo;
 
-                Unsafe.Add(ref dBase, i) = s;
+            Unsafe.Add(ref dBase, i) = s;
-            }
         }
+    }
 
-        public static class FromRgba32
+    public static class FromRgba32
+    {
+        /// <summary>
+        /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
+        /// </summary>
+        /// <returns>The argb value.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static uint ToArgb32(uint packedRgba)
         {
-            /// <summary>
+            // packedRgba          = [aa bb gg rr]
-            /// Converts a packed <see cref="Rgba32"/> to <see cref="Argb32"/>.
+            // ROL(8, packedRgba)  = [bb gg rr aa]
-            /// </summary>
+            return (packedRgba << 8) | (packedRgba >> 24);
-            /// <returns>The argb value.</returns>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            public static uint ToArgb32(uint packedRgba)
-            {
-                // packedRgba          = [aa bb gg rr]
-                // ROL(8, packedRgba)  = [bb gg rr aa]
-                return (packedRgba << 8) | (packedRgba >> 24);
-            }
-
-            /// <summary>
-            /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-            /// </summary>
-            /// <returns>The bgra value.</returns>
-            [MethodImpl(InliningOptions.ShortMethod)]
-            public static uint ToBgra32(uint packedRgba)
-            {
-                // packedRgba          = [aa bb gg rr]
-                // tmp1                = [aa 00 gg 00]
-                // tmp2                = [00 bb 00 rr]
-                // tmp3=ROL(16, tmp2)  = [00 rr 00 bb]
-                // tmp1 + tmp3         = [aa rr gg bb]
-                uint tmp1 = packedRgba & 0xFF00FF00;
-                uint tmp2 = packedRgba & 0x00FF00FF;
-                uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
-                return tmp1 + tmp3;
-            }
         }
 
-        // RESULTS:
+        /// <summary>
-        //               Method | Count |     Mean |     Error |    StdDev | Scaled | ScaledSD |
+        /// Converts a packed <see cref="Rgba32"/> to <see cref="Bgra32"/>.
-        // -------------------- |------ |---------:|----------:|----------:|-------:|---------:|
+        /// </summary>
-        //              Default |    64 | 82.67 ns | 0.6737 ns | 0.5625 ns |   1.00 |     0.00 |
+        /// <returns>The bgra value.</returns>
-        //      Default_Generic |    64 | 88.73 ns | 1.7959 ns | 1.7638 ns |   1.07 |     0.02 |
+        [MethodImpl(InliningOptions.ShortMethod)]
-        //       Default_Group2 |    64 | 91.03 ns | 1.5237 ns | 1.3508 ns |   1.10 |     0.02 |
+        public static uint ToBgra32(uint packedRgba)
-        //       Default_Group4 |    64 | 86.62 ns | 1.5737 ns | 1.4720 ns |   1.05 |     0.02 |
+        {
-        //               BitOps |    64 | 57.45 ns | 0.6067 ns | 0.5066 ns |   0.69 |     0.01 |
+            // packedRgba          = [aa bb gg rr]
-        //         Bitops_Tuple |    64 | 75.47 ns | 1.1824 ns | 1.1060 ns |   0.91 |     0.01 |
+            // tmp1                = [aa 00 gg 00]
-        //  BitOps_GroupAsULong |    64 | 65.42 ns | 0.7157 ns | 0.6695 ns |   0.79 |     0.01 |
+            // tmp2                = [00 bb 00 rr]
+            // tmp3=ROL(16, tmp2)  = [00 rr 00 bb]
+            // tmp1 + tmp3         = [aa rr gg bb]
+            uint tmp1 = packedRgba & 0xFF00FF00;
+            uint tmp2 = packedRgba & 0x00FF00FF;
+            uint tmp3 = (tmp2 << 16) | (tmp2 >> 16);
+            return tmp1 + tmp3;
+        }
     }
+
+    // RESULTS:
+    //               Method | Count |     Mean |     Error |    StdDev | Scaled | ScaledSD |
+    // -------------------- |------ |---------:|----------:|----------:|-------:|---------:|
+    //              Default |    64 | 82.67 ns | 0.6737 ns | 0.5625 ns |   1.00 |     0.00 |
+    //      Default_Generic |    64 | 88.73 ns | 1.7959 ns | 1.7638 ns |   1.07 |     0.02 |
+    //       Default_Group2 |    64 | 91.03 ns | 1.5237 ns | 1.3508 ns |   1.10 |     0.02 |
+    //       Default_Group4 |    64 | 86.62 ns | 1.5737 ns | 1.4720 ns |   1.05 |     0.02 |
+    //               BitOps |    64 | 57.45 ns | 0.6067 ns | 0.5066 ns |   0.69 |     0.01 |
+    //         Bitops_Tuple |    64 | 75.47 ns | 1.1824 ns | 1.1060 ns |   0.91 |     0.01 |
+    //  BitOps_GroupAsULong |    64 | 65.42 ns | 0.7157 ns | 0.6695 ns |   0.79 |     0.01 |
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/TestArgb.cs

@@ -6,89 +6,88 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct TestArgb : ITestPixel<TestArgb>
 {
-    [StructLayout(LayoutKind.Sequential)]
+    public byte A;
-    public struct TestArgb : ITestPixel<TestArgb>
+    public byte R;
-    {
+    public byte G;
-        public byte A;
+    public byte B;
-        public byte R;
-        public byte G;
-        public byte B;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromRgba32(Rgba32 p)
+    public void FromRgba32(Rgba32 p)
-        {
+    {
-            this.R = p.R;
+        this.R = p.R;
-            this.G = p.G;
+        this.G = p.G;
-            this.B = p.B;
+        this.B = p.B;
-            this.A = p.A;
+        this.A = p.A;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromRgba32(ref Rgba32 p)
+    public void FromRgba32(ref Rgba32 p)
-        {
+    {
-            this.R = p.R;
+        this.R = p.R;
-            this.G = p.G;
+        this.G = p.G;
-            this.B = p.B;
+        this.B = p.B;
-            this.A = p.A;
+        this.A = p.A;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromBytes(byte r, byte g, byte b, byte a)
+    public void FromBytes(byte r, byte g, byte b, byte a)
-        {
+    {
-            this.R = r;
+        this.R = r;
-            this.G = g;
+        this.G = g;
-            this.B = b;
+        this.B = b;
-            this.A = a;
+        this.A = a;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromVector4(Vector4 p)
+    public void FromVector4(Vector4 p)
-        {
+    {
-            this.R = (byte)p.X;
+        this.R = (byte)p.X;
-            this.G = (byte)p.Y;
+        this.G = (byte)p.Y;
-            this.B = (byte)p.Z;
+        this.B = (byte)p.Z;
-            this.A = (byte)p.W;
+        this.A = (byte)p.W;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromVector4(ref Vector4 p)
+    public void FromVector4(ref Vector4 p)
-        {
+    {
-            this.R = (byte)p.X;
+        this.R = (byte)p.X;
-            this.G = (byte)p.Y;
+        this.G = (byte)p.Y;
-            this.B = (byte)p.Z;
+        this.B = (byte)p.Z;
-            this.A = (byte)p.W;
+        this.A = (byte)p.W;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Rgba32 ToRgba32()
+    public Rgba32 ToRgba32()
-        {
+    {
-            return new Rgba32(this.R, this.G, this.B, this.A);
+        return new Rgba32(this.R, this.G, this.B, this.A);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyToRgba32(ref Rgba32 dest)
+    public void CopyToRgba32(ref Rgba32 dest)
-        {
+    {
-            dest.R = this.R;
+        dest.R = this.R;
-            dest.G = this.G;
+        dest.G = this.G;
-            dest.B = this.B;
+        dest.B = this.B;
-            dest.A = this.A;
+        dest.A = this.A;
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector4 ToVector4()
+    public Vector4 ToVector4()
-        {
+    {
-            return new Vector4(this.R, this.G, this.B, this.A);
+        return new Vector4(this.R, this.G, this.B, this.A);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyToVector4(ref Vector4 dest)
+    public void CopyToVector4(ref Vector4 dest)
-        {
+    {
-            dest.X = this.R;
+        dest.X = this.R;
-            dest.Y = this.G;
+        dest.Y = this.G;
-            dest.Z = this.B;
+        dest.Z = this.B;
-            dest.W = this.A;
+        dest.W = this.A;
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/PixelConversion/TestRgba.cs

@@ -6,71 +6,70 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.PixelFormats;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion
+namespace SixLabors.ImageSharp.Benchmarks.General.PixelConversion;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct TestRgba : ITestPixel<TestRgba>
 {
-    [StructLayout(LayoutKind.Sequential)]
+    public byte R;
-    public struct TestRgba : ITestPixel<TestRgba>
+    public byte G;
-    {
+    public byte B;
-        public byte R;
+    public byte A;
-        public byte G;
-        public byte B;
-        public byte A;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromRgba32(Rgba32 source)
+    public void FromRgba32(Rgba32 source)
-        {
+    {
-            this = Unsafe.As<Rgba32, TestRgba>(ref source);
+        this = Unsafe.As<Rgba32, TestRgba>(ref source);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromRgba32(ref Rgba32 source)
+    public void FromRgba32(ref Rgba32 source)
-        {
+    {
-            this = Unsafe.As<Rgba32, TestRgba>(ref source);
+        this = Unsafe.As<Rgba32, TestRgba>(ref source);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void FromBytes(byte r, byte g, byte b, byte a)
+    public void FromBytes(byte r, byte g, byte b, byte a)
-        {
+    {
-            this.R = r;
+        this.R = r;
-            this.G = g;
+        this.G = g;
-            this.B = b;
+        this.B = b;
-            this.A = a;
+        this.A = a;
-        }
+    }
 
-        public void FromVector4(Vector4 source)
+    public void FromVector4(Vector4 source)
-        {
+    {
-            throw new System.NotImplementedException();
+        throw new System.NotImplementedException();
-        }
+    }
 
-        public void FromVector4(ref Vector4 source)
+    public void FromVector4(ref Vector4 source)
-        {
+    {
-            throw new System.NotImplementedException();
+        throw new System.NotImplementedException();
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Rgba32 ToRgba32()
+    public Rgba32 ToRgba32()
-        {
+    {
-            return Unsafe.As<TestRgba, Rgba32>(ref this);
+        return Unsafe.As<TestRgba, Rgba32>(ref this);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyToRgba32(ref Rgba32 dest)
+    public void CopyToRgba32(ref Rgba32 dest)
-        {
+    {
-            dest = Unsafe.As<TestRgba, Rgba32>(ref this);
+        dest = Unsafe.As<TestRgba, Rgba32>(ref this);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Vector4 ToVector4()
+    public Vector4 ToVector4()
-        {
+    {
-            return new Vector4(this.R, this.G, this.B, this.A) * new Vector4(1f / 255f);
+        return new Vector4(this.R, this.G, this.B, this.A) * new Vector4(1f / 255f);
-        }
+    }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyToVector4(ref Vector4 dest)
+    public void CopyToVector4(ref Vector4 dest)
-        {
+    {
-            var tmp = new Vector4(this.R, this.G, this.B, this.A);
+        var tmp = new Vector4(this.R, this.G, this.B, this.A);
-            tmp *= new Vector4(1f / 255f);
+        tmp *= new Vector4(1f / 255f);
-            dest = tmp;
+        dest = tmp;
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/StructCasting.cs

@@ -4,28 +4,27 @@
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
+
+public class StructCasting
 {
-    public class StructCasting
+    [Benchmark(Baseline = true)]
+    public short ExplicitCast()
     {
-        [Benchmark(Baseline = true)]
+        int x = 5 * 2;
-        public short ExplicitCast()
+        return (short)x;
-        {
+    }
-            int x = 5 * 2;
-            return (short)x;
-        }
 
-        [Benchmark]
+    [Benchmark]
-        public short UnsafeCast()
+    public short UnsafeCast()
-        {
+    {
-            int x = 5 * 2;
+        int x = 5 * 2;
-            return Unsafe.As<int, short>(ref x);
+        return Unsafe.As<int, short>(ref x);
-        }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public short UnsafeCastRef()
+    public short UnsafeCastRef()
-        {
+    {
-            return Unsafe.As<int, short>(ref Unsafe.AsRef(5 * 2));
+        return Unsafe.As<int, short>(ref Unsafe.AsRef(5 * 2));
-        }
     }
 }

tests/ImageSharp.Benchmarks/General/Vector4Constants.cs

@@ -1,62 +1,60 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System;
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General
+namespace SixLabors.ImageSharp.Benchmarks.General;
+
+/// <summary>
+/// Has it any effect on performance to store SIMD constants as static readonly fields? Is it OK to always inline them?
+/// Spoiler: the difference seems to be statistically insignificant!
+/// </summary>
+public class Vector4Constants
 {
-    /// <summary>
+    private static readonly Vector4 A = new Vector4(1.2f);
-    /// Has it any effect on performance to store SIMD constants as static readonly fields? Is it OK to always inline them?
+    private static readonly Vector4 B = new Vector4(3.4f);
-    /// Spoiler: the difference seems to be statistically insignificant!
+    private static readonly Vector4 C = new Vector4(5.6f);
-    /// </summary>
+    private static readonly Vector4 D = new Vector4(7.8f);
-    public class Vector4Constants
+
+    private Random random;
+
+    private Vector4 parameter;
+
+    [GlobalSetup]
+    public void Setup()
     {
-        private static readonly Vector4 A = new Vector4(1.2f);
+        this.random = new Random(42);
-        private static readonly Vector4 B = new Vector4(3.4f);
+        this.parameter = new Vector4(
-        private static readonly Vector4 C = new Vector4(5.6f);
+            this.GetRandomFloat(),
-        private static readonly Vector4 D = new Vector4(7.8f);
+            this.GetRandomFloat(),
-
+            this.GetRandomFloat(),
-        private Random random;
+            this.GetRandomFloat());
-
-        private Vector4 parameter;
-
-        [GlobalSetup]
-        public void Setup()
-        {
-            this.random = new Random(42);
-            this.parameter = new Vector4(
-                this.GetRandomFloat(),
-                this.GetRandomFloat(),
-                this.GetRandomFloat(),
-                this.GetRandomFloat());
-        }
-
-        [Benchmark(Baseline = true)]
-        public Vector4 Static()
-        {
-            Vector4 p = this.parameter;
-
-            Vector4 x = (p * A / B) + (p * C / D);
-            Vector4 y = (p / A * B) + (p / C * D);
-            var z = Vector4.Min(p, A);
-            var w = Vector4.Max(p, B);
-            return x + y + z + w;
-        }
-
-        [Benchmark]
-        public Vector4 Inlined()
-        {
-            Vector4 p = this.parameter;
-
-            Vector4 x = (p * new Vector4(1.2f) / new Vector4(2.3f)) + (p * new Vector4(4.5f) / new Vector4(6.7f));
-            Vector4 y = (p / new Vector4(1.2f) * new Vector4(2.3f)) + (p / new Vector4(4.5f) * new Vector4(6.7f));
-            var z = Vector4.Min(p, new Vector4(1.2f));
-            var w = Vector4.Max(p, new Vector4(2.3f));
-            return x + y + z + w;
-        }
-
-        private float GetRandomFloat() => (float)this.random.NextDouble();
     }
+
+    [Benchmark(Baseline = true)]
+    public Vector4 Static()
+    {
+        Vector4 p = this.parameter;
+
+        Vector4 x = (p * A / B) + (p * C / D);
+        Vector4 y = (p / A * B) + (p / C * D);
+        var z = Vector4.Min(p, A);
+        var w = Vector4.Max(p, B);
+        return x + y + z + w;
+    }
+
+    [Benchmark]
+    public Vector4 Inlined()
+    {
+        Vector4 p = this.parameter;
+
+        Vector4 x = (p * new Vector4(1.2f) / new Vector4(2.3f)) + (p * new Vector4(4.5f) / new Vector4(6.7f));
+        Vector4 y = (p / new Vector4(1.2f) * new Vector4(2.3f)) + (p / new Vector4(4.5f) * new Vector4(6.7f));
+        var z = Vector4.Min(p, new Vector4(1.2f));
+        var w = Vector4.Max(p, new Vector4(2.3f));
+        return x + y + z + w;
+    }
+
+    private float GetRandomFloat() => (float)this.random.NextDouble();
 }

tests/ImageSharp.Benchmarks/General/Vectorization/BitwiseOrUint32.cs

@@ -4,53 +4,52 @@
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization
+namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization;
+
+public class BitwiseOrUInt32
 {
-    public class BitwiseOrUInt32
+    private uint[] input;
-    {
-        private uint[] input;
 
-        private uint[] result;
+    private uint[] result;
 
-        [Params(32)]
+    [Params(32)]
-        public int InputSize { get; set; }
+    public int InputSize { get; set; }
 
-        private uint testValue;
+    private uint testValue;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        this.input = new uint[this.InputSize];
+        this.result = new uint[this.InputSize];
+        this.testValue = 42;
+
+        for (int i = 0; i < this.InputSize; i++)
         {
-            this.input = new uint[this.InputSize];
+            this.input[i] = (uint)i;
-            this.result = new uint[this.InputSize];
-            this.testValue = 42;
-
-            for (int i = 0; i < this.InputSize; i++)
-            {
-                this.input[i] = (uint)i;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Standard()
+    public void Standard()
+    {
+        uint v = this.testValue;
+        for (int i = 0; i < this.input.Length; i++)
         {
-            uint v = this.testValue;
+            this.result[i] = this.input[i] | v;
-            for (int i = 0; i < this.input.Length; i++)
-            {
-                this.result[i] = this.input[i] | v;
-            }
         }
+    }
+
+    [Benchmark]
+    public void Simd()
+    {
+        var v = new Vector<uint>(this.testValue);
 
-        [Benchmark]
+        for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
-        public void Simd()
         {
-            var v = new Vector<uint>(this.testValue);
+            var a = new Vector<uint>(this.input, i);
-
+            a = Vector.BitwiseOr(a, v);
-            for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
+            a.CopyTo(this.result, i);
-            {
-                var a = new Vector<uint>(this.input, i);
-                a = Vector.BitwiseOr(a, v);
-                a.CopyTo(this.result, i);
-            }
         }
     }
 }

tests/ImageSharp.Benchmarks/General/Vectorization/DivFloat.cs

@@ -4,53 +4,52 @@
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization
+namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization;
+
+public class DivFloat
 {
-    public class DivFloat
+    private float[] input;
-    {
-        private float[] input;
 
-        private float[] result;
+    private float[] result;
 
-        [Params(32)]
+    [Params(32)]
-        public int InputSize { get; set; }
+    public int InputSize { get; set; }
 
-        private float testValue;
+    private float testValue;
 
-        [GlobalSetup]
+    [GlobalSetup]
-        public void Setup()
+    public void Setup()
+    {
+        this.input = new float[this.InputSize];
+        this.result = new float[this.InputSize];
+        this.testValue = 42;
+
+        for (int i = 0; i < this.InputSize; i++)
         {
-            this.input = new float[this.InputSize];
+            this.input[i] = (uint)i;
-            this.result = new float[this.InputSize];
-            this.testValue = 42;
-
-            for (int i = 0; i < this.InputSize; i++)
-            {
-                this.input[i] = (uint)i;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Standard()
+    public void Standard()
+    {
+        float v = this.testValue;
+        for (int i = 0; i < this.input.Length; i++)
         {
-            float v = this.testValue;
+            this.result[i] = this.input[i] / v;
-            for (int i = 0; i < this.input.Length; i++)
-            {
-                this.result[i] = this.input[i] / v;
-            }
         }
+    }
+
+    [Benchmark]
+    public void Simd()
+    {
+        var v = new Vector<float>(this.testValue);
 
-        [Benchmark]
+        for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
-        public void Simd()
         {
-            var v = new Vector<float>(this.testValue);
+            var a = new Vector<float>(this.input, i);
-
+            a = a / v;
-            for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
+            a.CopyTo(this.result, i);
-            {
-                var a = new Vector<float>(this.input, i);
-                a = a / v;
-                a.CopyTo(this.result, i);
-            }
         }
     }
 }

tests/ImageSharp.Benchmarks/General/Vectorization/DivUInt32.cs

@@ -4,55 +4,54 @@
 using System.Numerics;
 using BenchmarkDotNet.Attributes;
 
-namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization
+namespace SixLabors.ImageSharp.Benchmarks.General.Vectorization;
+
+public class DivUInt32
 {
-    public class DivUInt32
+    private uint[] input;
-    {
+
-        private uint[] input;
+    private uint[] result;
 
-        private uint[] result;
+    [Params(32)]
+    public int InputSize { get; set; }
 
-        [Params(32)]
+    private uint testValue;
-        public int InputSize { get; set; }
 
-        private uint testValue;
+    [GlobalSetup]
+    public void Setup()
+    {
+        this.input = new uint[this.InputSize];
+        this.result = new uint[this.InputSize];
+        this.testValue = 42;
 
-        [GlobalSetup]
+        for (int i = 0; i < this.InputSize; i++)
-        public void Setup()
         {
-            this.input = new uint[this.InputSize];
+            this.input[i] = (uint)i;
-            this.result = new uint[this.InputSize];
-            this.testValue = 42;
-
-            for (int i = 0; i < this.InputSize; i++)
-            {
-                this.input[i] = (uint)i;
-            }
         }
+    }
 
-        [Benchmark(Baseline = true)]
+    [Benchmark(Baseline = true)]
-        public void Standard()
+    public void Standard()
-        {
+    {
-            uint v = this.testValue;
+        uint v = this.testValue;
 
-            for (int i = 0; i < this.input.Length; i++)
+        for (int i = 0; i < this.input.Length; i++)
-            {
+        {
-                this.result[i] = this.input[i] / v;
+            this.result[i] = this.input[i] / v;
-            }
         }
+    }
 
-        [Benchmark]
+    [Benchmark]
-        public void Simd()
+    public void Simd()
-        {
+    {
-            var v = new Vector<uint>(this.testValue);
+        var v = new Vector<uint>(this.testValue);
 
-            for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
+        for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
-            {
+        {
-                var a = new Vector<uint>(this.input, i);
+            var a = new Vector<uint>(this.input, i);
 
-                a = a / v;
+            a = a / v;
-                a.CopyTo(this.result, i);
+            a.CopyTo(this.result, i);
-            }
         }
     }
 }