Add AVX2 implementation

src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs

@@ -14,7 +14,7 @@ namespace SixLabors.ImageSharp
     {
         public static class HwIntrinsics
         {
-            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 static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 };
 
             /// <summary>
             /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs

@@ -4,7 +4,12 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+#endif
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Tuples;
 
@@ -190,45 +195,90 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// </summary>
             public void Pack(ref Vector4Pair r, ref Vector4Pair g, ref Vector4Pair b)
             {
-                this.V0.X = r.A.X;
+#if SUPPORTS_RUNTIME_INTRINSICS
-                this.V0.Y = g.A.X;
+                if (Avx2.IsSupported)
-                this.V0.Z = b.A.X;
+                {
-                this.V0.W = 1f;
+                    Vector4 vo = Vector4.One;
-
+                    Vector128<float> valpha = Unsafe.As<Vector4, Vector128<float>>(ref vo);
-                this.V1.X = r.A.Y;
+
-                this.V1.Y = g.A.Y;
+                    ref byte control = ref MemoryMarshal.GetReference(SimdUtils.HwIntrinsics.PermuteMaskDeinterleave8x32);
-                this.V1.Z = b.A.Y;
+                    Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-                this.V1.W = 1f;
+
-
+                    Vector256<float> r0 = Avx.InsertVector128(
-                this.V2.X = r.A.Z;
+                       Unsafe.As<Vector4, Vector128<float>>(ref r.A).ToVector256(),
-                this.V2.Y = g.A.Z;
+                       Unsafe.As<Vector4, Vector128<float>>(ref g.A),
-                this.V2.Z = b.A.Z;
+                       1);
-                this.V2.W = 1f;
+
-
+                    Vector256<float> r1 = Avx.InsertVector128(
-                this.V3.X = r.A.W;
+                       Unsafe.As<Vector4, Vector128<float>>(ref b.A).ToVector256(),
-                this.V3.Y = g.A.W;
+                       valpha,
-                this.V3.Z = b.A.W;
+                       1);
-                this.V3.W = 1f;
+
-
+                    Vector256<float> r2 = Avx.InsertVector128(
-                this.V4.X = r.B.X;
+                       Unsafe.As<Vector4, Vector128<float>>(ref r.B).ToVector256(),
-                this.V4.Y = g.B.X;
+                       Unsafe.As<Vector4, Vector128<float>>(ref g.B),
-                this.V4.Z = b.B.X;
+                       1);
-                this.V4.W = 1f;
+
-
+                    Vector256<float> r3 = Avx.InsertVector128(
-                this.V5.X = r.B.Y;
+                       Unsafe.As<Vector4, Vector128<float>>(ref b.B).ToVector256(),
-                this.V5.Y = g.B.Y;
+                       valpha,
-                this.V5.Z = b.B.Y;
+                       1);
-                this.V5.W = 1f;
+
-
+                    Vector256<float> t0 = Avx.UnpackLow(r0, r1);
-                this.V6.X = r.B.Z;
+                    Vector256<float> t2 = Avx.UnpackHigh(r0, r1);
-                this.V6.Y = g.B.Z;
+
-                this.V6.Z = b.B.Z;
+                    Unsafe.As<Vector4, Vector256<float>>(ref this.V0) = Avx2.PermuteVar8x32(t0, vcontrol);
-                this.V6.W = 1f;
+                    Unsafe.As<Vector4, Vector256<float>>(ref this.V2) = Avx2.PermuteVar8x32(t2, vcontrol);
-
+
-                this.V7.X = r.B.W;
+                    Vector256<float> t4 = Avx.UnpackLow(r2, r3);
-                this.V7.Y = g.B.W;
+                    Vector256<float> t6 = Avx.UnpackHigh(r2, r3);
-                this.V7.Z = b.B.W;
+
-                this.V7.W = 1f;
+                    Unsafe.As<Vector4, Vector256<float>>(ref this.V4) = Avx2.PermuteVar8x32(t4, vcontrol);
+                    Unsafe.As<Vector4, Vector256<float>>(ref this.V6) = Avx2.PermuteVar8x32(t6, vcontrol);
+                }
+                else
+#endif
+                {
+                    this.V0.X = r.A.X;
+                    this.V0.Y = g.A.X;
+                    this.V0.Z = b.A.X;
+                    this.V0.W = 1f;
+
+                    this.V1.X = r.A.Y;
+                    this.V1.Y = g.A.Y;
+                    this.V1.Z = b.A.Y;
+                    this.V1.W = 1f;
+
+                    this.V2.X = r.A.Z;
+                    this.V2.Y = g.A.Z;
+                    this.V2.Z = b.A.Z;
+                    this.V2.W = 1f;
+
+                    this.V3.X = r.A.W;
+                    this.V3.Y = g.A.W;
+                    this.V3.Z = b.A.W;
+                    this.V3.W = 1f;
+
+                    this.V4.X = r.B.X;
+                    this.V4.Y = g.B.X;
+                    this.V4.Z = b.B.X;
+                    this.V4.W = 1f;
+
+                    this.V5.X = r.B.Y;
+                    this.V5.Y = g.B.Y;
+                    this.V5.Z = b.B.Y;
+                    this.V5.W = 1f;
+
+                    this.V6.X = r.B.Z;
+                    this.V6.Y = g.B.Z;
+                    this.V6.Z = b.B.Z;
+                    this.V6.W = 1f;
+
+                    this.V7.X = r.B.W;
+                    this.V7.Y = g.B.W;
+                    this.V7.Z = b.B.W;
+                    this.V7.W = 1f;
+                }
             }
         }
     }

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

@@ -0,0 +1,40 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.Tuples;
+using static SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters.JpegColorConverter;
+
+namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
+{
+    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    public class Vector4OctetPack
+    {
+        private static Vector4Pair r = new Vector4Pair
+        {
+            A = new Vector4(1, 2, 3, 4),
+            B = new Vector4(5, 6, 7, 8)
+        };
+
+        private static Vector4Pair g = new Vector4Pair
+        {
+            A = new Vector4(9, 10, 11, 12),
+            B = new Vector4(13, 14, 15, 16)
+        };
+
+        private static Vector4Pair b = new Vector4Pair
+        {
+            A = new Vector4(17, 18, 19, 20),
+            B = new Vector4(21, 22, 23, 24)
+        };
+
+        [Benchmark]
+        public void Pack()
+        {
+            Vector4Octet v = default;
+
+            v.Pack(ref r, ref g, ref b);
+        }
+    }
+}

tests/ImageSharp.Benchmarks/Config.HwIntrinsics.cs

@@ -73,7 +73,9 @@ namespace SixLabors.ImageSharp.Benchmarks
                 }
 #endif
                 this.AddJob(Job.Default.WithRuntime(CoreRuntime.Core31)
-                    .WithEnvironmentVariables(new EnvironmentVariable(EnableHWIntrinsic, Off))
+                    .WithEnvironmentVariables(
+                        new EnvironmentVariable(EnableHWIntrinsic, Off),
+                        new EnvironmentVariable(FeatureSIMD, Off))
                     .WithId("No HwIntrinsics"));
             }
         }