Faster Linear Transforms (#1591)

* Attempt to use same weight generation algorithm as resize.

* tests pass

* Identical output

* Update LinearTransformKernelFactory{TResampler}.cs

* Use new low allocation iterator

* Migrate projective transforms.

* Optimizations

* Smaller kernel

* Fix sampling accuracy

* Finalize and update refs

* Revert unnecessary changes

* Remove enumerator

* Actually save output for debugging.

* Use custom test png encoder for reduced memory environments

* Convolution should use scaled vectors

* Update TestEnvironmentTests.cs

* Try using doubles

* Moar double precision

* Fix radius calculation

* Test if issue is SIMD related.

* Detect runtime to determine pipeline.

* Fix stack overflow

* fix condition

* Try simplified scalar run

* Simplify unpremultiply scalar

* Update Numerics.cs

* Fix runtime environment

* Update ImageSharp.csproj

* Duplicate the caller with scalar versions

* Update method name, exclude from coverage.

* Don't save output during coverage tests for perf.

* Update src/ImageSharp/Common/Helpers/RuntimeEnvironment.cs

Co-authored-by: Anton Firszov <antonfir@gmail.com>

Co-authored-by: Anton Firszov <antonfir@gmail.com>

Author: JimBobSquarePants

.gitattributes

@@ -86,7 +86,6 @@
 *.dll               binary
 *.eot               binary
 *.exe               binary
-*.ktx               binary
 *.otf               binary
 *.pbm               binary
 *.pdf               binary
@@ -125,3 +124,5 @@
 *.tga               filter=lfs diff=lfs merge=lfs -text
 *.webp              filter=lfs diff=lfs merge=lfs -text
 *.dds               filter=lfs diff=lfs merge=lfs -text
+*.ktx               filter=lfs diff=lfs merge=lfs -text
+*.ktx2              filter=lfs diff=lfs merge=lfs -text

src/ImageSharp/Common/Helpers/RuntimeEnvironment.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp
+{
+    /// <summary>
+    /// Provides information about the .NET runtime installation.
+    /// Many methods defer to <see cref="RuntimeInformation"/> when available.
+    /// </summary>
+    internal static class RuntimeEnvironment
+    {
+        private static readonly Lazy<bool> IsNetCoreLazy = new Lazy<bool>(() => FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase));
+
+        /// <summary>
+        /// Gets a value indicating whether the .NET installation is .NET Core 3.1 or lower.
+        /// </summary>
+        public static bool IsNetCore => IsNetCoreLazy.Value;
+
+        /// <summary>
+        /// Gets the name of the .NET installation on which an app is running.
+        /// </summary>
+        public static string FrameworkDescription => RuntimeInformation.FrameworkDescription;
+
+        /// <summary>
+        /// Indicates whether the current application is running on the specified platform.
+        /// </summary>
+        public static bool IsOSPlatform(OSPlatform osPlatform) => RuntimeInformation.IsOSPlatform(osPlatform);
+    }
+}

src/ImageSharp/Processing/Processors/Transforms/Linear/AffineTransformProcessor{TPixel}.cs

@@ -2,6 +2,8 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -80,32 +82,14 @@ public void ApplyTransform<TResampler>(in TResampler sampler)
                 return;
             }
 
-            int yRadius = LinearTransformUtils.GetSamplingRadius(in sampler, source.Height, destination.Height);
-            int xRadius = LinearTransformUtils.GetSamplingRadius(in sampler, source.Width, destination.Width);
-            var radialExtents = new Vector2(xRadius, yRadius);
-            int yLength = (yRadius * 2) + 1;
-            int xLength = (xRadius * 2) + 1;
-
-            // We use 2D buffers so that we can access the weight spans per row in parallel.
-            using Buffer2D<float> yKernelBuffer = configuration.MemoryAllocator.Allocate2D<float>(yLength, destination.Height);
-            using Buffer2D<float> xKernelBuffer = configuration.MemoryAllocator.Allocate2D<float>(xLength, destination.Height);
-
-            int maxX = source.Width - 1;
-            int maxY = source.Height - 1;
-            var maxSourceExtents = new Vector4(maxX, maxY, maxX, maxY);
-
             var operation = new AffineOperation<TResampler>(
                 configuration,
                 source,
                 destination,
-                yKernelBuffer,
-                xKernelBuffer,
                 in sampler,
-                matrix,
-                radialExtents,
-                maxSourceExtents);
+                matrix);
 
-            ParallelRowIterator.IterateRows<AffineOperation<TResampler>, Vector4>(
+            ParallelRowIterator.IterateRowIntervals<AffineOperation<TResampler>, Vector4>(
                 configuration,
                 destination.Bounds(),
                 in operation);
@@ -117,7 +101,6 @@ public void ApplyTransform<TResampler>(in TResampler sampler)
             private readonly ImageFrame<TPixel> destination;
             private readonly Rectangle bounds;
             private readonly Matrix3x2 matrix;
-            private readonly int maxX;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public NNAffineOperation(
@@ -129,100 +112,197 @@ public NNAffineOperation(
                 this.destination = destination;
                 this.bounds = source.Bounds();
                 this.matrix = matrix;
-                this.maxX = destination.Width;
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public void Invoke(int y)
             {
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
                 Span<TPixel> destRow = this.destination.GetPixelRowSpan(y);
 
-                for (int x = 0; x < this.maxX; x++)
+                for (int x = 0; x < destRow.Length; x++)
                 {
                     var point = Vector2.Transform(new Vector2(x, y), this.matrix);
                     int px = (int)MathF.Round(point.X);
                     int py = (int)MathF.Round(point.Y);
 
                     if (this.bounds.Contains(px, py))
                     {
-                        destRow[x] = this.source[px, py];
+                        destRow[x] = sourceBuffer.GetElementUnsafe(px, py);
                     }
                 }
             }
         }
 
-        private readonly struct AffineOperation<TResampler> : IRowOperation<Vector4>
+        private readonly struct AffineOperation<TResampler> : IRowIntervalOperation<Vector4>
             where TResampler : struct, IResampler
         {
             private readonly Configuration configuration;
             private readonly ImageFrame<TPixel> source;
             private readonly ImageFrame<TPixel> destination;
-            private readonly Buffer2D<float> yKernelBuffer;
-            private readonly Buffer2D<float> xKernelBuffer;
             private readonly TResampler sampler;
             private readonly Matrix3x2 matrix;
-            private readonly Vector2 radialExtents;
-            private readonly Vector4 maxSourceExtents;
-            private readonly int maxX;
+            private readonly float yRadius;
+            private readonly float xRadius;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public AffineOperation(
                 Configuration configuration,
                 ImageFrame<TPixel> source,
                 ImageFrame<TPixel> destination,
-                Buffer2D<float> yKernelBuffer,
-                Buffer2D<float> xKernelBuffer,
                 in TResampler sampler,
-                Matrix3x2 matrix,
-                Vector2 radialExtents,
-                Vector4 maxSourceExtents)
+                Matrix3x2 matrix)
             {
                 this.configuration = configuration;
                 this.source = source;
                 this.destination = destination;
-                this.yKernelBuffer = yKernelBuffer;
-                this.xKernelBuffer = xKernelBuffer;
                 this.sampler = sampler;
                 this.matrix = matrix;
-                this.radialExtents = radialExtents;
-                this.maxSourceExtents = maxSourceExtents;
-                this.maxX = destination.Width;
+
+                this.yRadius = LinearTransformUtility.GetSamplingRadius(in sampler, source.Height, destination.Height);
+                this.xRadius = LinearTransformUtility.GetSamplingRadius(in sampler, source.Width, destination.Width);
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]
-            public void Invoke(int y, Span<Vector4> span)
+            public void Invoke(in RowInterval rows, Span<Vector4> span)
             {
-                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
+                if (RuntimeEnvironment.IsOSPlatform(OSPlatform.OSX)
+                    && RuntimeEnvironment.IsNetCore)
+                {
+                    // There's something wrong with the JIT in .NET Core 3.1 on certain
+                    // MacOSX machines so we have to use different pipelines.
+                    // It's:
+                    // - Not reproducable locally
+                    // - Doesn't seem to be triggered by the bulk Numerics.UnPremultiply method but by caller.
+                    // https://github.com/SixLabors/ImageSharp/pull/1591
+                    this.InvokeMacOSX(in rows, span);
+                    return;
+                }
 
-                PixelOperations<TPixel>.Instance.ToVector4(
-                    this.configuration,
-                    this.destination.GetPixelRowSpan(y),
-                    span);
+                Matrix3x2 matrix = this.matrix;
+                TResampler sampler = this.sampler;
+                float yRadius = this.yRadius;
+                float xRadius = this.xRadius;
+                int maxY = this.source.Height - 1;
+                int maxX = this.source.Width - 1;
 
-                ref float yKernelSpanRef = ref MemoryMarshal.GetReference(this.yKernelBuffer.GetRowSpan(y));
-                ref float xKernelSpanRef = ref MemoryMarshal.GetReference(this.xKernelBuffer.GetRowSpan(y));
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
 
-                for (int x = 0; x < this.maxX; x++)
+                for (int y = rows.Min; y < rows.Max; y++)
                 {
-                    // Use the single precision position to calculate correct bounding pixels
-                    // otherwise we get rogue pixels outside of the bounds.
-                    var point = Vector2.Transform(new Vector2(x, y), this.matrix);
-                    LinearTransformUtils.Convolve(
-                        in this.sampler,
-                        point,
-                        sourceBuffer,
+                    Span<TPixel> rowSpan = this.destination.GetPixelRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(
+                        this.configuration,
+                        rowSpan,
+                        span,
+                        PixelConversionModifiers.Scale);
+
+                    for (int x = 0; x < span.Length; x++)
+                    {
+                        var point = Vector2.Transform(new Vector2(x, y), matrix);
+                        float pY = point.Y;
+                        float pX = point.X;
+
+                        int top = LinearTransformUtility.GetRangeStart(yRadius, pY, maxY);
+                        int bottom = LinearTransformUtility.GetRangeEnd(yRadius, pY, maxY);
+                        int left = LinearTransformUtility.GetRangeStart(xRadius, pX, maxX);
+                        int right = LinearTransformUtility.GetRangeEnd(xRadius, pX, maxX);
+
+                        if (bottom == top || right == left)
+                        {
+                            continue;
+                        }
+
+                        Vector4 sum = Vector4.Zero;
+                        for (int yK = top; yK <= bottom; yK++)
+                        {
+                            float yWeight = sampler.GetValue(yK - pY);
+
+                            for (int xK = left; xK <= right; xK++)
+                            {
+                                float xWeight = sampler.GetValue(xK - pX);
+
+                                Vector4 current = sourceBuffer.GetElementUnsafe(xK, yK).ToScaledVector4();
+                                Numerics.Premultiply(ref current);
+                                sum += current * xWeight * yWeight;
+                            }
+                        }
+
+                        span[x] = sum;
+                    }
+
+                    Numerics.UnPremultiply(span);
+                    PixelOperations<TPixel>.Instance.FromVector4Destructive(
+                        this.configuration,
                         span,
-                        x,
-                        ref yKernelSpanRef,
-                        ref xKernelSpanRef,
-                        this.radialExtents,
-                        this.maxSourceExtents);
+                        rowSpan,
+                        PixelConversionModifiers.Scale);
                 }
+            }
+
+            [ExcludeFromCodeCoverage]
+            [MethodImpl(InliningOptions.ShortMethod)]
+            private void InvokeMacOSX(in RowInterval rows, Span<Vector4> span)
+            {
+                Matrix3x2 matrix = this.matrix;
+                TResampler sampler = this.sampler;
+                float yRadius = this.yRadius;
+                float xRadius = this.xRadius;
+                int maxY = this.source.Height - 1;
+                int maxX = this.source.Width - 1;
 
-                PixelOperations<TPixel>.Instance.FromVector4Destructive(
-                    this.configuration,
-                    span,
-                    this.destination.GetPixelRowSpan(y));
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
+
+                for (int y = rows.Min; y < rows.Max; y++)
+                {
+                    Span<TPixel> rowSpan = this.destination.GetPixelRowSpan(y);
+                    PixelOperations<TPixel>.Instance.ToVector4(
+                        this.configuration,
+                        rowSpan,
+                        span,
+                        PixelConversionModifiers.Scale);
+
+                    for (int x = 0; x < span.Length; x++)
+                    {
+                        var point = Vector2.Transform(new Vector2(x, y), matrix);
+                        float pY = point.Y;
+                        float pX = point.X;
+
+                        int top = LinearTransformUtility.GetRangeStart(yRadius, pY, maxY);
+                        int bottom = LinearTransformUtility.GetRangeEnd(yRadius, pY, maxY);
+                        int left = LinearTransformUtility.GetRangeStart(xRadius, pX, maxX);
+                        int right = LinearTransformUtility.GetRangeEnd(xRadius, pX, maxX);
+
+                        if (bottom == top || right == left)
+                        {
+                            continue;
+                        }
+
+                        Vector4 sum = Vector4.Zero;
+                        for (int yK = top; yK <= bottom; yK++)
+                        {
+                            float yWeight = sampler.GetValue(yK - pY);
+
+                            for (int xK = left; xK <= right; xK++)
+                            {
+                                float xWeight = sampler.GetValue(xK - pX);
+
+                                Vector4 current = sourceBuffer.GetElementUnsafe(xK, yK).ToScaledVector4();
+                                Numerics.Premultiply(ref current);
+                                sum += current * xWeight * yWeight;
+                            }
+                        }
+
+                        Numerics.UnPremultiply(ref sum);
+                        span[x] = sum;
+                    }
+
+                    PixelOperations<TPixel>.Instance.FromVector4Destructive(
+                        this.configuration,
+                        span,
+                        rowSpan,
+                        PixelConversionModifiers.Scale);
+                }
             }
         }
     }