First working no-clamp version for 2 pass convolution

.gitattributes

@@ -80,8 +80,11 @@
 *.pvr               binary
 *.snk               binary
 *.tga               binary
+*.tif               binary
+*.tiff              binary
 *.ttc               binary
 *.ttf               binary
+*.wbmp              binary
 *.webp              binary
 *.woff              binary
 *.woff2             binary

src/ImageSharp/Common/Helpers/DenseMatrixUtils.cs

@@ -6,6 +6,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors.Convolution;
 
 namespace SixLabors.ImageSharp
 {
@@ -156,38 +157,32 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="matrix">The dense matrix.</param>
+        /// <param name="yOffsetSpan">The span containing precalculated kernel y-offsets.</param>
+        /// <param name="xOffsetSpan">The span containing precalculated kernel x-offsets.</param>
         /// <param name="sourcePixels">The source frame.</param>
         /// <param name="targetRowRef">The target row base reference.</param>
         /// <param name="row">The current row.</param>
         /// <param name="column">The current column.</param>
-        /// <param name="minRow">The minimum working area row.</param>
-        /// <param name="maxRow">The maximum working area row.</param>
-        /// <param name="minColumn">The minimum working area column.</param>
-        /// <param name="maxColumn">The maximum working area column.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Convolve3<TPixel>(
             in DenseMatrix<float> matrix,
+            Span<int> yOffsetSpan,
+            Span<int> xOffsetSpan,
             Buffer2D<TPixel> sourcePixels,
             ref Vector4 targetRowRef,
             int row,
-            int column,
+            int column)
-            int minRow,
-            int maxRow,
-            int minColumn,
-            int maxColumn)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Vector4 vector = default;
 
             ConvolveImpl(
                 in matrix,
+                yOffsetSpan,
+                xOffsetSpan,
                 sourcePixels,
                 row,
                 column,
-                minRow,
-                maxRow,
-                minColumn,
-                maxColumn,
                 ref vector);
 
             ref Vector4 target = ref Unsafe.Add(ref targetRowRef, column);
@@ -203,38 +198,32 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="matrix">The dense matrix.</param>
+        /// <param name="yOffsetSpan">The span containing precalculated kernel y-offsets.</param>
+        /// <param name="xOffsetSpan">The span containing precalculated kernel x-offsets.</param>
         /// <param name="sourcePixels">The source frame.</param>
         /// <param name="targetRowRef">The target row base reference.</param>
         /// <param name="row">The current row.</param>
         /// <param name="column">The current column.</param>
-        /// <param name="minRow">The minimum working area row.</param>
-        /// <param name="maxRow">The maximum working area row.</param>
-        /// <param name="minColumn">The minimum working area column.</param>
-        /// <param name="maxColumn">The maximum working area column.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
         public static void Convolve4<TPixel>(
             in DenseMatrix<float> matrix,
+            Span<int> yOffsetSpan,
+            Span<int> xOffsetSpan,
             Buffer2D<TPixel> sourcePixels,
             ref Vector4 targetRowRef,
             int row,
-            int column,
+            int column)
-            int minRow,
-            int maxRow,
-            int minColumn,
-            int maxColumn)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Vector4 vector = default;
 
             ConvolveImpl(
                 in matrix,
+                yOffsetSpan,
+                xOffsetSpan,
                 sourcePixels,
                 row,
                 column,
-                minRow,
-                maxRow,
-                minColumn,
-                maxColumn,
                 ref vector);
 
             ref Vector4 target = ref Unsafe.Add(ref targetRowRef, column);
@@ -245,33 +234,28 @@ namespace SixLabors.ImageSharp
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void ConvolveImpl<TPixel>(
             in DenseMatrix<float> matrix,
+            Span<int> yOffsetSpan,
+            Span<int> xOffsetSpan,
             Buffer2D<TPixel> sourcePixels,
             int row,
             int column,
-            int minRow,
+            ref Vector4 targetVector)
-            int maxRow,
-            int minColumn,
-            int maxColumn,
-            ref Vector4 vector)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int matrixHeight = matrix.Rows;
             int matrixWidth = matrix.Columns;
-            int radiusY = matrixHeight >> 1;
-            int radiusX = matrixWidth >> 1;
-            int sourceOffsetColumnBase = column + minColumn;
 
             for (int y = 0; y < matrixHeight; y++)
             {
-                int offsetY = Numerics.Clamp(row + y - radiusY, minRow, maxRow);
+                int offsetY = yOffsetSpan[(row * matrixHeight) + y];
                 Span<TPixel> sourceRowSpan = sourcePixels.GetRowSpan(offsetY);
 
                 for (int x = 0; x < matrixWidth; x++)
                 {
-                    int offsetX = Numerics.Clamp(sourceOffsetColumnBase + x - radiusX, minColumn, maxColumn);
+                    int offsetX = xOffsetSpan[(column * matrixWidth) + x];
                     var currentColor = sourceRowSpan[offsetX].ToVector4();
                     Numerics.Premultiply(ref currentColor);
-                    vector += matrix[y, x] * currentColor;
+                    targetVector += matrix[y, x] * currentColor;
                 }
             }
         }

src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor{TPixel}.cs

@@ -63,19 +63,45 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
 
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
 
-            // Horizontal convolution
+            using (var mapX = new KernelOffsetMap(this.Configuration.MemoryAllocator))
-            var horizontalOperation = new RowOperation(interest, firstPassPixels, source.PixelBuffer, this.KernelX, this.Configuration, this.PreserveAlpha);
+            {
-            ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+                mapX.BuildOffsetMap(this.KernelX, interest);
-                this.Configuration,
+
-                interest,
+                // Horizontal convolution
-                in horizontalOperation);
+                var horizontalOperation = new RowOperation(
-
+                    interest,
-            // Vertical convolution
+                    firstPassPixels,
-            var verticalOperation = new RowOperation(interest, source.PixelBuffer, firstPassPixels, this.KernelY, this.Configuration, this.PreserveAlpha);
+                    source.PixelBuffer,
-            ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+                    mapX,
-                this.Configuration,
+                    this.KernelX,
-                interest,
+                    this.Configuration,
-                in verticalOperation);
+                    this.PreserveAlpha);
+
+                ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+                    this.Configuration,
+                    interest,
+                    in horizontalOperation);
+            }
+
+            using (var mapY = new KernelOffsetMap(this.Configuration.MemoryAllocator))
+            {
+                mapY.BuildOffsetMap(this.KernelY, interest);
+
+                // Vertical convolution
+                var verticalOperation = new RowOperation(
+                    interest,
+                    source.PixelBuffer,
+                    firstPassPixels,
+                    mapY,
+                    this.KernelY,
+                    this.Configuration,
+                    this.PreserveAlpha);
+
+                ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+                    this.Configuration,
+                    interest,
+                    in verticalOperation);
+            }
         }
 
         /// <summary>
@@ -86,6 +112,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             private readonly Rectangle bounds;
             private readonly Buffer2D<TPixel> targetPixels;
             private readonly Buffer2D<TPixel> sourcePixels;
+            private readonly KernelOffsetMap map;
             private readonly DenseMatrix<float> kernel;
             private readonly Configuration configuration;
             private readonly bool preserveAlpha;
@@ -95,6 +122,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                 Rectangle bounds,
                 Buffer2D<TPixel> targetPixels,
                 Buffer2D<TPixel> sourcePixels,
+                KernelOffsetMap map,
                 DenseMatrix<float> kernel,
                 Configuration configuration,
                 bool preserveAlpha)
@@ -102,6 +130,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                 this.bounds = bounds;
                 this.targetPixels = targetPixels;
                 this.sourcePixels = sourcePixels;
+                this.map = map;
                 this.kernel = kernel;
                 this.configuration = configuration;
                 this.preserveAlpha = preserveAlpha;
@@ -112,43 +141,38 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             public void Invoke(int y, Span<Vector4> span)
             {
                 ref Vector4 spanRef = ref MemoryMarshal.GetReference(span);
-
-                int maxY = this.bounds.Bottom - 1;
-                int maxX = this.bounds.Right - 1;
-
                 Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
                 PixelOperations<TPixel>.Instance.ToVector4(this.configuration, targetRowSpan.Slice(0, span.Length), span);
+                Span<int> yOffsets = this.map.GetYOffsetSpan();
+                Span<int> xOffsets = this.map.GetXOffsetSpan();
+                int row = y - this.bounds.Y;
 
                 if (this.preserveAlpha)
                 {
-                    for (int x = 0; x < this.bounds.Width; x++)
+                    for (int column = 0; column < this.bounds.Width; column++)
                     {
                         DenseMatrixUtils.Convolve3(
                             in this.kernel,
+                            yOffsets,
+                            xOffsets,
                             this.sourcePixels,
                             ref spanRef,
-                            y,
+                            row,
-                            x,
+                            column);
-                            this.bounds.Y,
-                            maxY,
-                            this.bounds.X,
-                            maxX);
                     }
                 }
                 else
                 {
-                    for (int x = 0; x < this.bounds.Width; x++)
+                    for (int column = 0; column < this.bounds.Width; column++)
                     {
                         DenseMatrixUtils.Convolve4(
                             in this.kernel,
+                            yOffsets,
+                            xOffsets,
                             this.sourcePixels,
                             ref spanRef,
-                            y,
+                            row,
-                            x,
+                            column);
-                            this.bounds.Y,
-                            maxY,
-                            this.bounds.X,
-                            maxX);
                     }
                 }
 

src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs

@@ -51,16 +51,22 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
         /// <inheritdoc/>
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
-            using Buffer2D<TPixel> targetPixels = this.Configuration.MemoryAllocator.Allocate2D<TPixel>(source.Size());
+            MemoryAllocator allocator = this.Configuration.MemoryAllocator;
+            using Buffer2D<TPixel> targetPixels = allocator.Allocate2D<TPixel>(source.Size());
 
             source.CopyTo(targetPixels);
 
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
-            var operation = new RowOperation(interest, targetPixels, source.PixelBuffer, this.KernelXY, this.Configuration, this.PreserveAlpha);
+            using (var map = new KernelOffsetMap(allocator))
-            ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+            {
-               this.Configuration,
+                map.BuildOffsetMap(this.KernelXY, interest);
-               interest,
+
-               in operation);
+                var operation = new RowOperation(interest, targetPixels, source.PixelBuffer, map, this.KernelXY, this.Configuration, this.PreserveAlpha);
+                ParallelRowIterator.IterateRows<RowOperation, Vector4>(
+                   this.Configuration,
+                   interest,
+                   in operation);
+            }
 
             Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
         }
@@ -71,10 +77,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
         private readonly struct RowOperation : IRowOperation<Vector4>
         {
             private readonly Rectangle bounds;
-            private readonly int maxY;
-            private readonly int maxX;
             private readonly Buffer2D<TPixel> targetPixels;
             private readonly Buffer2D<TPixel> sourcePixels;
+            private readonly KernelOffsetMap map;
             private readonly DenseMatrix<float> kernel;
             private readonly Configuration configuration;
             private readonly bool preserveAlpha;
@@ -84,15 +89,15 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                 Rectangle bounds,
                 Buffer2D<TPixel> targetPixels,
                 Buffer2D<TPixel> sourcePixels,
+                KernelOffsetMap map,
                 DenseMatrix<float> kernel,
                 Configuration configuration,
                 bool preserveAlpha)
             {
                 this.bounds = bounds;
-                this.maxY = this.bounds.Bottom - 1;
-                this.maxX = this.bounds.Right - 1;
                 this.targetPixels = targetPixels;
                 this.sourcePixels = sourcePixels;
+                this.map = map;
                 this.kernel = kernel;
                 this.configuration = configuration;
                 this.preserveAlpha = preserveAlpha;
@@ -103,40 +108,38 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             public void Invoke(int y, Span<Vector4> span)
             {
                 ref Vector4 spanRef = ref MemoryMarshal.GetReference(span);
-
                 Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
                 PixelOperations<TPixel>.Instance.ToVector4(this.configuration, targetRowSpan.Slice(0, span.Length), span);
+                Span<int> yOffsetSpan = this.map.GetYOffsetSpan();
+                Span<int> xOffsetSpan = this.map.GetXOffsetSpan();
+                int row = y - this.bounds.Y;
 
                 if (this.preserveAlpha)
                 {
-                    for (int x = 0; x < this.bounds.Width; x++)
+                    for (int column = 0; column < this.bounds.Width; column++)
                     {
                         DenseMatrixUtils.Convolve3(
                             in this.kernel,
+                            yOffsetSpan,
+                            xOffsetSpan,
                             this.sourcePixels,
                             ref spanRef,
-                            y,
+                            row,
-                            x,
+                            column);
-                            this.bounds.Y,
-                            this.maxY,
-                            this.bounds.X,
-                            this.maxX);
                     }
                 }
                 else
                 {
-                    for (int x = 0; x < this.bounds.Width; x++)
+                    for (int column = 0; column < this.bounds.Width; column++)
                     {
                         DenseMatrixUtils.Convolve4(
                             in this.kernel,
+                            yOffsetSpan,
+                            xOffsetSpan,
                             this.sourcePixels,
                             ref spanRef,
-                            y,
+                            row,
-                            x,
+                            column);
-                            this.bounds.Y,
-                            this.maxY,
-                            this.bounds.X,
-                            this.maxX);
                     }
                 }
 

src/ImageSharp/Processing/Processors/Convolution/Kernels/KernelOffsetMap.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Convolution
+{
+    /// <summary>
+    /// Provides a map of the convolution kernel sampling offsets.
+    /// </summary>
+    internal sealed class KernelOffsetMap : IDisposable
+    {
+        private readonly MemoryAllocator allocator;
+        private bool isDisposed;
+        private IMemoryOwner<int> yOffsets;
+        private IMemoryOwner<int> xOffsets;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KernelOffsetMap"/> class.
+        /// </summary>
+        /// <param name="allocator">The memory allocator.</param>
+        public KernelOffsetMap(MemoryAllocator allocator) => this.allocator = allocator;
+
+        public void BuildOffsetMap(in DenseMatrix<float> matrix, Rectangle bounds)
+        {
+            int matrixHeight = matrix.Rows;
+            int matrixWidth = matrix.Columns;
+            this.yOffsets = this.allocator.Allocate<int>(bounds.Height * matrixHeight);
+            this.xOffsets = this.allocator.Allocate<int>(bounds.Width * matrixWidth);
+
+            int minY = bounds.Y;
+            int maxY = bounds.Bottom - 1;
+            int minX = bounds.X;
+            int maxX = bounds.Right - 1;
+
+            int radiusY = matrixHeight >> 1;
+            int radiusX = matrixWidth >> 1;
+
+            // Calculate the potential sampling y-offsets.
+            Span<int> ySpan = this.yOffsets.GetSpan();
+            for (int row = 0; row < bounds.Height; row++)
+            {
+                for (int y = 0; y < matrixHeight; y++)
+                {
+                    ySpan[(row * matrixHeight) + y] = row + y + minY - radiusY;
+                }
+            }
+
+            if (matrixHeight > 1)
+            {
+                Numerics.Clamp(ySpan, minY, maxY);
+            }
+
+            // Calculate the potential sampling x-offsets.
+            Span<int> xSpan = this.xOffsets.GetSpan();
+            for (int column = 0; column < bounds.Width; column++)
+            {
+                for (int x = 0; x < matrixWidth; x++)
+                {
+                    xSpan[(column * matrixWidth) + x] = column + x + minX - radiusX;
+                }
+            }
+
+            if (matrixWidth > 1)
+            {
+                Numerics.Clamp(xSpan, minX, maxX);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Span<int> GetYOffsetSpan() => this.yOffsets.GetSpan();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Span<int> GetXOffsetSpan() => this.xOffsets.GetSpan();
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (!this.isDisposed)
+            {
+                this.yOffsets.Dispose();
+                this.xOffsets.Dispose();
+
+                this.isDisposed = true;
+            }
+        }
+    }
+}