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>

.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 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 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,
+                matrix);
-                radialExtents,
-                maxSourceExtents);
 
-            ParallelRowIterator.IterateRows<AffineOperation<TResampler>, Vector4>(
+            ParallelRowIterator.IterateRowIntervals<AffineOperation<TResampler>, Vector4>(
                 configuration,
                 destination.Bounds(),
                 in operation);
@@ -117,7 +101,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
             private readonly ImageFrame<TPixel> destination;
             private readonly Rectangle bounds;
             private readonly Matrix3x2 matrix;
-            private readonly int maxX;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public NNAffineOperation(
@@ -129,15 +112,15 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 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);
@@ -145,84 +128,181 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
 
                     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 float yRadius;
-            private readonly Vector4 maxSourceExtents;
+            private readonly float xRadius;
-            private readonly int maxX;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public AffineOperation(
                 Configuration configuration,
                 ImageFrame<TPixel> source,
                 ImageFrame<TPixel> destination,
-                Buffer2D<float> yKernelBuffer,
-                Buffer2D<float> xKernelBuffer,
                 in TResampler sampler,
-                Matrix3x2 matrix,
+                Matrix3x2 matrix)
-                Vector2 radialExtents,
-                Vector4 maxSourceExtents)
             {
                 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.yRadius = LinearTransformUtility.GetSamplingRadius(in sampler, source.Height, destination.Height);
-                this.maxX = destination.Width;
+                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(
+                Matrix3x2 matrix = this.matrix;
-                    this.configuration,
+                TResampler sampler = this.sampler;
-                    this.destination.GetPixelRowSpan(y),
+                float yRadius = this.yRadius;
-                    span);
+                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));
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
-                ref float xKernelSpanRef = ref MemoryMarshal.GetReference(this.xKernelBuffer.GetRowSpan(y));
 
-                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
+                    Span<TPixel> rowSpan = this.destination.GetPixelRowSpan(y);
-                    // otherwise we get rogue pixels outside of the bounds.
+                    PixelOperations<TPixel>.Instance.ToVector4(
-                    var point = Vector2.Transform(new Vector2(x, y), this.matrix);
+                        this.configuration,
-                    LinearTransformUtils.Convolve(
+                        rowSpan,
-                        in this.sampler,
+                        span,
-                        point,
+                        PixelConversionModifiers.Scale);
-                        sourceBuffer,
+
+                    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,
+                        rowSpan,
-                        ref yKernelSpanRef,
+                        PixelConversionModifiers.Scale);
-                        ref xKernelSpanRef,
-                        this.radialExtents,
-                        this.maxSourceExtents);
                 }
+            }
+
+            [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(
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
-                    this.configuration,
+
-                    span,
+                for (int y = rows.Min; y < rows.Max; y++)
-                    this.destination.GetPixelRowSpan(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);
+                }
             }
         }
     }

src/ImageSharp/Processing/Processors/Transforms/Linear/LinearTransformUtility.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Transforms
+{
+    /// <summary>
+    /// Utility methods for linear transforms.
+    /// </summary>
+    internal static class LinearTransformUtility
+    {
+        /// <summary>
+        /// Returns the sampling radius for the given sampler and dimensions.
+        /// </summary>
+        /// <typeparam name="TResampler">The type of resampler.</typeparam>
+        /// <param name="sampler">The resampler sampler.</param>
+        /// <param name="sourceSize">The source size.</param>
+        /// <param name="destinationSize">The destination size.</param>
+        /// <returns>The <see cref="float"/>.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static float GetSamplingRadius<TResampler>(in TResampler sampler, int sourceSize, int destinationSize)
+             where TResampler : struct, IResampler
+        {
+            float scale = (float)sourceSize / destinationSize;
+
+            if (scale < 1F)
+            {
+                scale = 1F;
+            }
+
+            return MathF.Ceiling(sampler.Radius * scale);
+        }
+
+        /// <summary>
+        /// Gets the start position (inclusive) for a sampling range given
+        /// the radius, center position and max constraint.
+        /// </summary>
+        /// <param name="radius">The radius.</param>
+        /// <param name="center">The center position.</param>
+        /// <param name="max">The max allowed amouunt.</param>
+        /// <returns>The <see cref="int"/>.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static int GetRangeStart(float radius, float center, int max)
+            => Numerics.Clamp((int)MathF.Ceiling(center - radius), 0, max);
+
+        /// <summary>
+        /// Gets the end position (inclusive) for a sampling range given
+        /// the radius, center position and max constraint.
+        /// </summary>
+        /// <param name="radius">The radius.</param>
+        /// <param name="center">The center position.</param>
+        /// <param name="max">The max allowed amouunt.</param>
+        /// <returns>The <see cref="int"/>.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static int GetRangeEnd(float radius, float center, int max)
+            => Numerics.Clamp((int)MathF.Floor(center + radius), 0, max);
+    }
+}

src/ImageSharp/Processing/Processors/Transforms/Linear/LinearTransformUtils.cs

@@ -1,104 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Transforms
-{
-    /// <summary>
-    /// Utility methods for affine and projective transforms.
-    /// </summary>
-    internal static class LinearTransformUtils
-    {
-        [MethodImpl(InliningOptions.ShortMethod)]
-        internal static int GetSamplingRadius<TResampler>(in TResampler sampler, int sourceSize, int destinationSize)
-            where TResampler : struct, IResampler
-        {
-            double scale = sourceSize / destinationSize;
-            if (scale < 1)
-            {
-                scale = 1;
-            }
-
-            return (int)Math.Ceiling(scale * sampler.Radius);
-        }
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        internal static void Convolve<TResampler, TPixel>(
-            in TResampler sampler,
-            Vector2 transformedPoint,
-            Buffer2D<TPixel> sourcePixels,
-            Span<Vector4> targetRow,
-            int column,
-            ref float yKernelSpanRef,
-            ref float xKernelSpanRef,
-            Vector2 radialExtents,
-            Vector4 maxSourceExtents)
-            where TResampler : struct, IResampler
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            // Clamp sampling pixel radial extents to the source image edges
-            Vector2 minXY = transformedPoint - radialExtents;
-            Vector2 maxXY = transformedPoint + radialExtents;
-
-            // left, top, right, bottom
-            var sourceExtents = new Vector4(
-                MathF.Ceiling(minXY.X),
-                MathF.Ceiling(minXY.Y),
-                MathF.Floor(maxXY.X),
-                MathF.Floor(maxXY.Y));
-
-            sourceExtents = Numerics.Clamp(sourceExtents, Vector4.Zero, maxSourceExtents);
-
-            int left = (int)sourceExtents.X;
-            int top = (int)sourceExtents.Y;
-            int right = (int)sourceExtents.Z;
-            int bottom = (int)sourceExtents.W;
-
-            if (left == right || top == bottom)
-            {
-                return;
-            }
-
-            CalculateWeights(in sampler, top, bottom, transformedPoint.Y, ref yKernelSpanRef);
-            CalculateWeights(in sampler, left, right, transformedPoint.X, ref xKernelSpanRef);
-
-            Vector4 sum = Vector4.Zero;
-            for (int kernelY = 0, y = top; y <= bottom; y++, kernelY++)
-            {
-                float yWeight = Unsafe.Add(ref yKernelSpanRef, kernelY);
-
-                for (int kernelX = 0, x = left; x <= right; x++, kernelX++)
-                {
-                    float xWeight = Unsafe.Add(ref xKernelSpanRef, kernelX);
-
-                    // Values are first premultiplied to prevent darkening of edge pixels.
-                    var current = sourcePixels[x, y].ToVector4();
-                    Numerics.Premultiply(ref current);
-                    sum += current * xWeight * yWeight;
-                }
-            }
-
-            // Reverse the premultiplication
-            Numerics.UnPremultiply(ref sum);
-            targetRow[column] = sum;
-        }
-
-        [MethodImpl(InliningOptions.ShortMethod)]
-        private static void CalculateWeights<TResampler>(in TResampler sampler, int min, int max, float point, ref float weightsRef)
-            where TResampler : struct, IResampler
-        {
-            float sum = 0;
-            for (int x = 0, i = min; i <= max; i++, x++)
-            {
-                float weight = sampler.GetValue(i - point);
-                sum += weight;
-                Unsafe.Add(ref weightsRef, x) = weight;
-            }
-        }
-    }
-}

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

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -80,32 +81,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 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 ProjectiveOperation<TResampler>(
                 configuration,
                 source,
                 destination,
-                yKernelBuffer,
-                xKernelBuffer,
                 in sampler,
-                matrix,
+                matrix);
-                radialExtents,
-                maxSourceExtents);
 
-            ParallelRowIterator.IterateRows<ProjectiveOperation<TResampler>, Vector4>(
+            ParallelRowIterator.IterateRowIntervals<ProjectiveOperation<TResampler>, Vector4>(
                 configuration,
                 destination.Bounds(),
                 in operation);
@@ -117,7 +100,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
             private readonly ImageFrame<TPixel> destination;
             private readonly Rectangle bounds;
             private readonly Matrix4x4 matrix;
-            private readonly int maxX;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public NNProjectiveOperation(
@@ -129,15 +111,15 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 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++)
                 {
                     Vector2 point = TransformUtils.ProjectiveTransform2D(x, y, this.matrix);
                     int px = (int)MathF.Round(point.X);
@@ -145,84 +127,181 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
 
                     if (this.bounds.Contains(px, py))
                     {
-                        destRow[x] = this.source[px, py];
+                        destRow[x] = sourceBuffer.GetElementUnsafe(px, py);
                     }
                 }
             }
         }
 
-        private readonly struct ProjectiveOperation<TResampler> : IRowOperation<Vector4>
+        private readonly struct ProjectiveOperation<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 Matrix4x4 matrix;
-            private readonly Vector2 radialExtents;
+            private readonly float yRadius;
-            private readonly Vector4 maxSourceExtents;
+            private readonly float xRadius;
-            private readonly int maxX;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public ProjectiveOperation(
                 Configuration configuration,
                 ImageFrame<TPixel> source,
                 ImageFrame<TPixel> destination,
-                Buffer2D<float> yKernelBuffer,
-                Buffer2D<float> xKernelBuffer,
                 in TResampler sampler,
-                Matrix4x4 matrix,
+                Matrix4x4 matrix)
-                Vector2 radialExtents,
-                Vector4 maxSourceExtents)
             {
                 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.yRadius = LinearTransformUtility.GetSamplingRadius(in sampler, source.Height, destination.Height);
-                this.maxX = destination.Width;
+                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(
+                Matrix4x4 matrix = this.matrix;
-                    this.configuration,
+                TResampler sampler = this.sampler;
-                    this.destination.GetPixelRowSpan(y),
+                float yRadius = this.yRadius;
-                    span);
+                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));
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
-                ref float xKernelSpanRef = ref MemoryMarshal.GetReference(this.xKernelBuffer.GetRowSpan(y));
 
-                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
+                    Span<TPixel> rowSpan = this.destination.GetPixelRowSpan(y);
-                    // otherwise we get rogue pixels outside of the bounds.
+                    PixelOperations<TPixel>.Instance.ToVector4(
-                    Vector2 point = TransformUtils.ProjectiveTransform2D(x, y, this.matrix);
+                        this.configuration,
-                    LinearTransformUtils.Convolve(
+                        rowSpan,
-                        in this.sampler,
+                        span,
-                        point,
+                        PixelConversionModifiers.Scale);
-                        sourceBuffer,
+
+                    for (int x = 0; x < span.Length; x++)
+                    {
+                        Vector2 point = TransformUtils.ProjectiveTransform2D(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,
+                        rowSpan,
-                        ref yKernelSpanRef,
+                        PixelConversionModifiers.Scale);
-                        ref xKernelSpanRef,
-                        this.radialExtents,
-                        this.maxSourceExtents);
                 }
+            }
+
+            [ExcludeFromCodeCoverage]
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public void InvokeMacOSX(in RowInterval rows, Span<Vector4> span)
+            {
+                Matrix4x4 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(
+                Buffer2D<TPixel> sourceBuffer = this.source.PixelBuffer;
-                    this.configuration,
+
-                    span,
+                for (int y = rows.Min; y < rows.Max; y++)
-                    this.destination.GetPixelRowSpan(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++)
+                    {
+                        Vector2 point = TransformUtils.ProjectiveTransform2D(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);
+                }
             }
         }
     }

src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernel.cs

@@ -13,7 +13,7 @@ using System.Runtime.Intrinsics.X86;
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms
 {
     /// <summary>
-    /// Points to a collection of of weights allocated in <see cref="ResizeKernelMap"/>.
+    /// Points to a collection of weights allocated in <see cref="ResizeKernelMap"/>.
     /// </summary>
     internal readonly unsafe struct ResizeKernel
     {
@@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         }
 
         /// <summary>
-        /// Gets the the length of the kernel.
+        /// Gets the length of the kernel.
         /// </summary>
         public int Length
         {

tests/ImageSharp.Benchmarks/Processing/Rotate.cs

@@ -21,21 +21,19 @@ namespace SixLabors.ImageSharp.Benchmarks.Processing
     }
 }
 
-// #### 21th February 2020 ####
+// #### 2021-04-06 ####
 //
-// BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042
-// Intel Core i7-8650U CPU 1.90GHz(Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-// .NET Core SDK = 3.1.101
+// .NET Core SDK=5.0.201
+//  [Host]     : .NET Core 5.0.4 (CoreCLR 5.0.421.11614, CoreFX 5.0.421.11614), X64 RyuJIT
+//  Job-HQWHDJ : .NET Framework 4.8 (4.8.4341.0), X64 RyuJIT
+//  Job-RPXLFC : .NET Core 2.1.26 (CoreCLR 4.6.29812.02, CoreFX 4.6.29812.01), X64 RyuJIT
+//  Job-YMSKIM : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
 //
-// [Host]     : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
-//  Job-HOGSNT : .NET Framework 4.8 (4.8.4121.0), X64 RyuJIT
-//  Job-FKDHXC : .NET Core 2.1.15 (CoreCLR 4.6.28325.01, CoreFX 4.6.28327.02), X64 RyuJIT
-//  Job-ODABAZ : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
 //
-// IterationCount=3  LaunchCount=1  WarmupCount=3
+// |   Method |        Job |       Runtime |     Mean |    Error |   StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
-//
+// |--------- |----------- |-------------- |---------:|---------:|---------:|------:|------:|------:|----------:|
-// |   Method |       Runtime |     Mean |    Error |   StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// | DoRotate | Job-BAUEPW |    .NET 4.7.2 | 30.73 ms | 0.397 ms | 0.331 ms |     - |     - |     - |   6.75 KB |
-// |--------- |-------------- |---------:|---------:|---------:|------:|------:|------:|----------:|
+// | DoRotate | Job-SNWMCN | .NET Core 2.1 | 16.31 ms | 0.317 ms | 0.352 ms |     - |     - |     - |   5.25 KB |
-// | DoRotate |    .NET 4.7.2 | 28.77 ms | 3.304 ms | 0.181 ms |     - |     - |     - |    6.5 KB |
+// | DoRotate | Job-MRMBJZ | .NET Core 3.1 | 12.21 ms | 0.239 ms | 0.245 ms |     - |     - |     - |   6.61 KB |
-// | DoRotate | .NET Core 2.1 | 16.27 ms | 1.044 ms | 0.057 ms |     - |     - |     - |   5.25 KB |
-// | DoRotate | .NET Core 3.1 | 17.12 ms | 4.352 ms | 0.239 ms |     - |     - |     - |   6.57 KB |

tests/ImageSharp.Benchmarks/Processing/Skew.cs

@@ -21,21 +21,19 @@ namespace SixLabors.ImageSharp.Benchmarks.Processing
     }
 }
 
-// #### 21th February 2020 ####
+// #### 2021-04-06 ####
 //
-// BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18363
+// BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042
-// Intel Core i7-8650U CPU 1.90GHz(Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
+// Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
-// .NET Core SDK = 3.1.101
+// .NET Core SDK=5.0.201
+//  [Host]     : .NET Core 5.0.4 (CoreCLR 5.0.421.11614, CoreFX 5.0.421.11614), X64 RyuJIT
+//  Job-HQWHDJ : .NET Framework 4.8 (4.8.4341.0), X64 RyuJIT
+//  Job-RPXLFC : .NET Core 2.1.26 (CoreCLR 4.6.29812.02, CoreFX 4.6.29812.01), X64 RyuJIT
+//  Job-YMSKIM : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
 //
-// [Host]     : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
-//  Job-VKKTMF : .NET Framework 4.8 (4.8.4121.0), X64 RyuJIT
-//  Job-KTVRKR : .NET Core 2.1.15 (CoreCLR 4.6.28325.01, CoreFX 4.6.28327.02), X64 RyuJIT
-//  Job-EONWDB : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT
 //
-// IterationCount=3  LaunchCount=1  WarmupCount=3
+// | Method |        Job |       Runtime |      Mean |     Error |    StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
-//
+// |------- |----------- |-------------- |----------:|----------:|----------:|------:|------:|------:|----------:|
-// | Method |       Runtime |     Mean |     Error |   StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
+// | DoSkew | Job-YEGFRQ |    .NET 4.7.2 | 23.563 ms | 0.0731 ms | 0.0570 ms |     - |     - |     - |   6.75 KB |
-// |------- |-------------- |---------:|----------:|---------:|------:|------:|------:|----------:|
+// | DoSkew | Job-HZHOGR | .NET Core 2.1 | 13.700 ms | 0.2727 ms | 0.5122 ms |     - |     - |     - |   5.25 KB |
-// | DoSkew |    .NET 4.7.2 | 24.60 ms | 33.971 ms | 1.862 ms |     - |     - |     - |    6.5 KB |
+// | DoSkew | Job-LTEUKY | .NET Core 3.1 |  9.971 ms | 0.0254 ms | 0.0225 ms |     - |     - |     - |   6.61 KB |
-// | DoSkew | .NET Core 2.1 | 12.13 ms |  2.256 ms | 0.124 ms |     - |     - |     - |   5.21 KB |
-// | DoSkew | .NET Core 3.1 | 12.83 ms |  1.442 ms | 0.079 ms |     - |     - |     - |   6.57 KB |

tests/ImageSharp.Tests/Helpers/RuntimeEnvironmentTests.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Runtime.InteropServices;
+using Xunit;
+
+#pragma warning disable IDE0022 // Use expression body for methods
+namespace SixLabors.ImageSharp.Tests.Helpers
+{
+    public class RuntimeEnvironmentTests
+    {
+        [Fact]
+        public void CanDetectNetCore()
+        {
+#if NET5_0_OR_GREATER
+            Assert.False(RuntimeEnvironment.IsNetCore);
+#elif NETCOREAPP
+            Assert.True(RuntimeEnvironment.IsNetCore);
+#else
+            Assert.False(RuntimeEnvironment.IsNetCore);
+#endif
+        }
+
+        [Fact]
+        public void CanDetectOSPlatform()
+        {
+            if (TestEnvironment.IsLinux)
+            {
+                Assert.True(RuntimeEnvironment.IsOSPlatform(OSPlatform.Linux));
+            }
+            else if (TestEnvironment.IsOSX)
+            {
+                Assert.True(RuntimeEnvironment.IsOSPlatform(OSPlatform.OSX));
+            }
+            else if (TestEnvironment.IsWindows)
+            {
+                Assert.True(RuntimeEnvironment.IsOSPlatform(OSPlatform.Windows));
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Processing/Processors/Transforms/AffineTransformTests.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Numerics;
 using System.Reflection;
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
@@ -18,9 +17,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
     public class AffineTransformTests
     {
         private readonly ITestOutputHelper output;
-
+        private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.033F, 3);
-        // 1 byte difference on one color component.
-        private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.0134F, 3);
 
         /// <summary>
         /// angleDeg, sx, sy, tx, ty

tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs

@@ -174,7 +174,7 @@ namespace SixLabors.ImageSharp.Tests
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
 
-            encoder = encoder ?? TestEnvironment.GetReferenceEncoder(path);
+            encoder ??= TestEnvironment.GetReferenceEncoder(path);
 
             using (FileStream stream = File.OpenWrite(path))
             {

tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/ImageSharpPngEncoderWithDefaultConfiguration.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
+{
+    /// <summary>
+    /// A Png encoder that uses the ImageSharp core encoder but the default configuration.
+    /// This allows encoding under environments with restricted memory.
+    /// </summary>
+    public sealed class ImageSharpPngEncoderWithDefaultConfiguration : IImageEncoder, IPngEncoderOptions
+    {
+        /// <inheritdoc/>
+        public PngBitDepth? BitDepth { get; set; }
+
+        /// <inheritdoc/>
+        public PngColorType? ColorType { get; set; }
+
+        /// <inheritdoc/>
+        public PngFilterMethod? FilterMethod { get; set; }
+
+        /// <inheritdoc/>
+        public PngCompressionLevel CompressionLevel { get; set; } = PngCompressionLevel.DefaultCompression;
+
+        /// <inheritdoc/>
+        public int TextCompressionThreshold { get; set; } = 1024;
+
+        /// <inheritdoc/>
+        public float? Gamma { get; set; }
+
+        /// <inheritdoc/>
+        public IQuantizer Quantizer { get; set; }
+
+        /// <inheritdoc/>
+        public byte Threshold { get; set; } = byte.MaxValue;
+
+        /// <inheritdoc/>
+        public PngInterlaceMode? InterlaceMethod { get; set; }
+
+        /// <inheritdoc/>
+        public PngChunkFilter? ChunkFilter { get; set; }
+
+        /// <inheritdoc/>
+        public bool IgnoreMetadata { get; set; }
+
+        /// <inheritdoc/>
+        public PngTransparentColorMode TransparentColorMode { get; set; }
+
+        /// <summary>
+        /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
+        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Configuration configuration = Configuration.Default;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+
+            using var encoder = new PngEncoderCore(allocator, configuration, new PngEncoderOptions(this));
+            encoder.Encode(image, stream);
+        }
+
+        /// <summary>
+        /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
+        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Configuration configuration = Configuration.Default;
+            MemoryAllocator allocator = configuration.MemoryAllocator;
+
+            // The introduction of a local variable that refers to an object the implements
+            // IDisposable means you must use async/await, where the compiler generates the
+            // state machine and a continuation.
+            using var encoder = new PngEncoderCore(allocator, configuration, new PngEncoderOptions(this));
+            await encoder.EncodeAsync(image, stream, cancellationToken).ConfigureAwait(false);
+        }
+    }
+}

tests/ImageSharp.Tests/TestUtilities/TestEnvironment.Formats.cs

@@ -57,10 +57,10 @@ namespace SixLabors.ImageSharp.Tests
                 new GifConfigurationModule(),
                 new TgaConfigurationModule());
 
-            // Magick codecs should work on all platforms
+            IImageEncoder pngEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Png : new ImageSharpPngEncoderWithDefaultConfiguration();
-            IImageEncoder pngEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Png : new PngEncoder();
             IImageEncoder bmpEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Bmp : new BmpEncoder();
 
+            // Magick codecs should work on all platforms
             cfg.ConfigureCodecs(
                 PngFormat.Instance,
                 MagickReferenceDecoder.Instance,

tests/ImageSharp.Tests/TestUtilities/TestEnvironment.cs

@@ -26,6 +26,8 @@ namespace SixLabors.ImageSharp.Tests
 
         private static readonly Lazy<bool> RunsOnCiLazy = new Lazy<bool>(() => bool.TryParse(Environment.GetEnvironmentVariable("CI"), out bool isCi) && isCi);
 
+        private static readonly Lazy<bool> RunsWithCodeCoverageLazy = new Lazy<bool>(() => bool.TryParse(Environment.GetEnvironmentVariable("codecov"), out bool isCodeCov) && isCodeCov);
+
         private static readonly Lazy<string> NetCoreVersionLazy = new Lazy<string>(GetNetCoreVersion);
 
         static TestEnvironment() => PrepareRemoteExecutor();
@@ -42,6 +44,11 @@ namespace SixLabors.ImageSharp.Tests
         /// </summary>
         internal static bool RunsOnCI => RunsOnCiLazy.Value;
 
+        /// <summary>
+        /// Gets a value indicating whether test execution is running with code coverage testing enabled.
+        /// </summary>
+        internal static bool RunsWithCodeCoverage => RunsWithCodeCoverageLazy.Value;
+
         internal static string SolutionDirectoryFullPath => SolutionDirectoryFullPathLazy.Value;
 
         private static readonly FileInfo TestAssemblyFile =

tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs

@@ -34,18 +34,16 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true,
             IImageEncoder encoder = null)
-        {
+            => image.DebugSave(
-            image.DebugSave(
                 provider,
                 (object)testOutputDetails,
                 extension,
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription,
                 encoder);
-        }
 
         /// <summary>
-        /// Saves the image only when not running in the CI server.
+        /// Saves the image for debugging purpose.
         /// </summary>
         /// <param name="image">The image.</param>
         /// <param name="provider">The image provider.</param>
@@ -64,12 +62,11 @@ namespace SixLabors.ImageSharp.Tests
             bool appendSourceFileOrDescription = true,
             IImageEncoder encoder = null)
         {
-            if (TestEnvironment.RunsOnCI)
+            if (TestEnvironment.RunsWithCodeCoverage)
             {
                 return image;
             }
 
-            // We are running locally then we want to save it out
             provider.Utility.SaveTestOutputFile(
                 image,
                 extension,
@@ -86,12 +83,10 @@ namespace SixLabors.ImageSharp.Tests
             IImageEncoder encoder,
             FormattableString testOutputDetails,
             bool appendPixelTypeToFileName = true)
-        {
+            => image.DebugSave(provider, encoder, (object)testOutputDetails, appendPixelTypeToFileName);
-            image.DebugSave(provider, encoder, (object)testOutputDetails, appendPixelTypeToFileName);
-        }
 
         /// <summary>
-        /// Saves the image only when not running in the CI server.
+        /// Saves the image for debugging purpose.
         /// </summary>
         /// <param name="image">The image</param>
         /// <param name="provider">The image provider</param>
@@ -104,19 +99,11 @@ namespace SixLabors.ImageSharp.Tests
             IImageEncoder encoder,
             object testOutputDetails = null,
             bool appendPixelTypeToFileName = true)
-        {
+            => provider.Utility.SaveTestOutputFile(
-            if (TestEnvironment.RunsOnCI)
-            {
-                return;
-            }
-
-            // We are running locally then we want to save it out
-            provider.Utility.SaveTestOutputFile(
                 image,
                 encoder: encoder,
                 testOutputDetails: testOutputDetails,
                 appendPixelTypeToFileName: appendPixelTypeToFileName);
-        }
 
         public static Image<TPixel> DebugSaveMultiFrame<TPixel>(
             this Image<TPixel> image,
@@ -126,17 +113,17 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            if (TestEnvironment.RunsOnCI)
+            if (TestEnvironment.RunsWithCodeCoverage)
             {
                 return image;
             }
 
-            // We are running locally then we want to save it out
             provider.Utility.SaveTestOutputFileMultiFrame(
                 image,
                 extension,
                 testOutputDetails: testOutputDetails,
                 appendPixelTypeToFileName: appendPixelTypeToFileName);
+
             return image;
         }
 
@@ -149,15 +136,13 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => image.CompareToReferenceOutput(
-            return image.CompareToReferenceOutput(
                 provider,
                 (object)testOutputDetails,
                 extension,
                 grayscale,
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
-        }
 
         /// <summary>
         /// Compares the image against the expected Reference output, throws an exception if the images are not similar enough.
@@ -181,8 +166,7 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => CompareToReferenceOutput(
-            return CompareToReferenceOutput(
                 image,
                 ImageComparer.Tolerant(),
                 provider,
@@ -191,7 +175,6 @@ namespace SixLabors.ImageSharp.Tests
                 grayscale,
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
-        }
 
         public static Image<TPixel> CompareToReferenceOutput<TPixel>(
             this Image<TPixel> image,
@@ -202,15 +185,13 @@ namespace SixLabors.ImageSharp.Tests
             bool grayscale = false,
             bool appendPixelTypeToFileName = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => image.CompareToReferenceOutput(
-            return image.CompareToReferenceOutput(
                 comparer,
                 provider,
                 (object)testOutputDetails,
                 extension,
                 grayscale,
                 appendPixelTypeToFileName);
-        }
 
         /// <summary>
         /// Compares the image against the expected Reference output, throws an exception if the images are not similar enough.
@@ -263,8 +244,7 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => image.CompareFirstFrameToReferenceOutput(
-            return image.CompareFirstFrameToReferenceOutput(
                 comparer,
                 provider,
                 (object)testOutputDetails,
@@ -272,7 +252,6 @@ namespace SixLabors.ImageSharp.Tests
                 grayscale,
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
-        }
 
         public static Image<TPixel> CompareFirstFrameToReferenceOutput<TPixel>(
             this Image<TPixel> image,
@@ -508,9 +487,7 @@ namespace SixLabors.ImageSharp.Tests
             ITestImageProvider provider,
             IImageDecoder referenceDecoder = null)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => CompareToOriginal(image, provider, ImageComparer.Tolerant(), referenceDecoder);
-            return CompareToOriginal(image, provider, ImageComparer.Tolerant(), referenceDecoder);
-        }
 
         public static Image<TPixel> CompareToOriginal<TPixel>(
             this Image<TPixel> image,
@@ -584,14 +561,12 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => provider.VerifyOperation(
-            provider.VerifyOperation(
                 ImageComparer.Tolerant(),
                 operation,
                 testOutputDetails,
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
-        }
 
         /// <summary>
         /// Utility method for doing the following in one step:
@@ -606,14 +581,12 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => provider.VerifyOperation(
-            provider.VerifyOperation(
                 comparer,
                 operation,
                 $"",
                 appendPixelTypeToFileName,
                 appendSourceFileOrDescription);
-        }
 
         /// <summary>
         /// Utility method for doing the following in one step:
@@ -627,9 +600,7 @@ namespace SixLabors.ImageSharp.Tests
             bool appendPixelTypeToFileName = true,
             bool appendSourceFileOrDescription = true)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
+            => provider.VerifyOperation(operation, $"", appendPixelTypeToFileName, appendSourceFileOrDescription);
-            provider.VerifyOperation(operation, $"", appendPixelTypeToFileName, appendSourceFileOrDescription);
-        }
 
         /// <summary>
         /// Loads the expected image with a reference decoder + compares it to <paramref name="image"/>.

tests/ImageSharp.Tests/TestUtilities/Tests/TestEnvironmentTests.cs

@@ -8,7 +8,6 @@ using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs;
 
 using Xunit;
@@ -85,7 +84,7 @@ namespace SixLabors.ImageSharp.Tests
         }
 
         [Theory]
-        [InlineData("lol/foo.png", typeof(PngEncoder))]
+        [InlineData("lol/foo.png", typeof(ImageSharpPngEncoderWithDefaultConfiguration))]
         [InlineData("lol/Rofl.bmp", typeof(BmpEncoder))]
         [InlineData("lol/Baz.JPG", typeof(JpegEncoder))]
         [InlineData("lol/Baz.gif", typeof(GifEncoder))]

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_RotateScaleTranslate_Rgba32_TestPattern100x50_R(50)_S(1,1)_T(-20,-10).png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:57376aa4446fc2d034d2a0cb627163ac416d1b6768b063b2c11ccf8517443bda
+oid sha256:2ef489dc0837b382ad7c7ead6b7c7042dfbfba39902d4cc81b5f3805d5b03967
-size 10135
+size 9175

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_RotateScaleTranslate_Rgba32_TestPattern100x50__original.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c83b59471a50df9e1d7b8f0e35c50aa417cd3be1730d6369f47f5cc99b87cef
+oid sha256:99d6c1d6b092a2feba2aebe2e09c521c3cc9682f3d748927cdc3cbaa38448b28
-size 6405
+size 710

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Bicubic.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f9f149093c5d9d487f3e16cb59e6807ea6ce581b5c307e57aeb4edaf921de9ca
+oid sha256:04a3b84c668758b586f4d998f080ef96b09f726b0298b28f5dd3d739b0e90744
-size 15138
+size 13138

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_CatmullRom.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f9f149093c5d9d487f3e16cb59e6807ea6ce581b5c307e57aeb4edaf921de9ca
+oid sha256:04a3b84c668758b586f4d998f080ef96b09f726b0298b28f5dd3d739b0e90744
-size 15138
+size 13138

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Lanczos2.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c7467702a784807a3a5813a75d5f643655ed5ad427e978d6ee079da67b05961
+oid sha256:6ea7ca66c31474c0bb9673a0d85c1c7465e387ebabf4e2d1e8f9daebfc7c8f34
-size 15363
+size 13956

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Lanczos3.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a836c63c0912f69683bc9c8f59687b11e6b84f257816a01ff979ad0b6f4ab656
+oid sha256:6dd98ac441f3c20ea999f058c7b21601d5981d46e9b77709c25f2930a64edb93
-size 19059
+size 17148

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Lanczos5.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:05de30dc282a0b8a096a476f689a1d2b6bb298098692a2f665c59c3d14902aa6
+oid sha256:d5c4772d9b9dc57c4b5d47450ec9d02d96e40656cf2015f171b5425945f8a598
-size 20426
+size 18726

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Lanczos8.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8892179d8edf96583900048bdd895eff24e57be0105e91efafe1de971414db0e
+oid sha256:bb025c4470cec1b0d6544924e46b84cbdb90d75da5d0f879f2c7d7ec9875dee2
-size 22457
+size 20574

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_MitchellNetravali.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2f351ec6ae6df56537e383494984c2fbcf35a66c44a6ce53d6fd8d6d74a330f3
+oid sha256:c4abaa06827cb779026f8fbb655692bdd8adab37ae5b00c3ae18ebea456eb8d9
-size 15342
+size 13459

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Robidoux.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b0fb38dbdded32a1518d62ac79f4aa88133aaddad947f23c1066dc33d6938e0b
+oid sha256:3435ade8f7988779280820342e16881b049f717735d2218ac5a971a1bd807db1
-size 15372
+size 13448

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_RobidouxSharp.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0be42a5fd4ff10680af74a99ed1e0561ae38181f4efe4641bd63891222dcdf3c
+oid sha256:f0098aa45e820544dd16a58396fa70860886b7d79900916ed97376a8328a5ff2
-size 15283
+size 13367

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Spline.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1eabaf35e0dda3eccd5e8866ddd65e0c45557c8d5cc29423a99e2f377ee1bfa9
+oid sha256:7729495277b80a42e24dd8f40cdd8a280443575710fb4e199e4871c28b558271
-size 16271
+size 14253

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Triangle.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ab9bea8f45e7d29d7a8c5e3d0182c0f3f3aa7014aa358883dee53db6dfeb3f7
+oid sha256:a2304c234b93bdabaa018263dec70e62090ad1bbb7005ef62643b88600a863fb
-size 14076
+size 12157

tests/Images/External/ReferenceOutput/AffineTransformTests/Transform_WithSampler_Rgba32_TestPattern150x150_Welch.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ea452bc46c508f6990870a34d908224a58aa350c4ccebabd4fa6ba138e8034a0
+oid sha256:54b0da9646b7f4cf83df784d69dfbec48e0bdc1788d70a9872817543f72f57c1
-size 18383
+size 16829

tests/Images/External/ReferenceOutput/Drawing/DrawImageTests/DrawTransformed.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2c83df7a2f70aec8f150799055ce42db09568b47b95216c91a79233ce69381d5
+oid sha256:233d8c6c9e101dddf5d210d47c7a20807f8f956738289068ea03b774258ef8c6
-size 191563
+size 182754