Merge pull request #1864 from br3aker/dp/jpeg-decoder-color-converters

Automatic SSE color converters based on Vector API

Author: JimBobSquarePants

src/ImageSharp/Common/Helpers/SimdUtils.cs

@@ -33,18 +33,6 @@ internal static partial class SimdUtils
         public static bool HasVector4 { get; } =
             Vector.IsHardwareAccelerated && Vector<float>.Count == 4;
 
-        public static bool HasAvx2
-        {
-            get
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                return Avx2.IsSupported;
-#else
-                return false;
-#endif
-            }
-        }
-
         /// <summary>
         /// Transform all scalars in 'v' in a way that converting them to <see cref="int"/> would have rounding semantics.
         /// </summary>

src/ImageSharp/Common/Tuples/Vector4Pair.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromCmykAvx : JpegColorConverterAvx
+        {
+            public FromCmykAvx(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            public override void ConvertToRgbInplace(in ComponentValues values)
+            {
+                ref Vector256<float> c0Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector256<float> c1Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector256<float> c2Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector256<float> c3Base =
+                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                // Used for the color conversion
+                var scale = Vector256.Create(1 / (this.MaximumValue * this.MaximumValue));
+
+                nint n = values.Component0.Length / Vector256<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    ref Vector256<float> c = ref Unsafe.Add(ref c0Base, i);
+                    ref Vector256<float> m = ref Unsafe.Add(ref c1Base, i);
+                    ref Vector256<float> y = ref Unsafe.Add(ref c2Base, i);
+                    Vector256<float> k = Unsafe.Add(ref c3Base, i);
+
+                    k = Avx.Multiply(k, scale);
+                    c = Avx.Multiply(c, k);
+                    m = Avx.Multiply(m, k);
+                    y = Avx.Multiply(y, k);
+                }
+            }
+        }
+    }
+}
+#endif

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

@@ -1,16 +1,15 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Numerics;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 {
-    internal abstract partial class JpegColorConverter
+    internal abstract partial class JpegColorConverterBase
     {
-        internal sealed class FromCmykBasic : BasicJpegColorConverter
+        internal sealed class FromCmykScalar : JpegColorConverterScalar
         {
-            public FromCmykBasic(int precision)
+            public FromCmykScalar(int precision)
                 : base(JpegColorSpace.Cmyk, precision)
             {
             }
@@ -25,17 +24,18 @@ internal static void ConvertCoreInplace(in ComponentValues values, float maxValu
                 Span<float> c2 = values.Component2;
                 Span<float> c3 = values.Component3;
 
-                float scale = 1 / maxValue;
+                float scale = 1 / (maxValue * maxValue);
                 for (int i = 0; i < c0.Length; i++)
                 {
                     float c = c0[i];
                     float m = c1[i];
                     float y = c2[i];
-                    float k = c3[i] / maxValue;
+                    float k = c3[i];
 
-                    c0[i] = c * k * scale;
-                    c1[i] = m * k * scale;
-                    c2[i] = y * k * scale;
+                    k *= scale;
+                    c0[i] = c * k;
+                    c1[i] = m * k;
+                    c2[i] = y * k;
                 }
             }
         }

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

@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+{
+    internal abstract partial class JpegColorConverterBase
+    {
+        internal sealed class FromCmykVector : JpegColorConverterVector
+        {
+            public FromCmykVector(int precision)
+                : base(JpegColorSpace.Cmyk, precision)
+            {
+            }
+
+            protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
+            {
+                ref Vector<float> cBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
+                ref Vector<float> mBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
+                ref Vector<float> yBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
+                ref Vector<float> kBase =
+                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
+
+                var scale = new Vector<float>(1 / (this.MaximumValue * this.MaximumValue));
+
+                nint n = values.Component0.Length / Vector<float>.Count;
+                for (nint i = 0; i < n; i++)
+                {
+                    ref Vector<float> c = ref Unsafe.Add(ref cBase, i);
+                    ref Vector<float> m = ref Unsafe.Add(ref mBase, i);
+                    ref Vector<float> y = ref Unsafe.Add(ref yBase, i);
+                    Vector<float> k = Unsafe.Add(ref kBase, i);
+
+                    k *= scale;
+                    c *= k;
+                    m *= k;
+                    y *= k;
+                }
+            }
+
+            protected override void ConvertCoreInplace(in ComponentValues values) =>
+                FromCmykScalar.ConvertCoreInplace(values, this.MaximumValue);
+        }
+    }
+}