Single row value delegate option

src/ImageSharp/Advanced/IRowIntervalOperation.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Advanced

src/ImageSharp/Advanced/IRowIntervalOperation{TBuffer}.cs

@@ -2,8 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Buffers;
-using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Advanced

src/ImageSharp/Advanced/IRowOperation.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Advanced
+{
+    /// <summary>
+    /// Defines the contract for an action that operates on a row.
+    /// </summary>
+    public interface IRowOperation
+    {
+        /// <summary>
+        /// Invokes the method passing the row y coordinate.
+        /// </summary>
+        /// <param name="y">The row y coordinate.</param>
+        void Invoke(int y);
+    }
+}

src/ImageSharp/Advanced/IRowOperation{TBuffer}.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Advanced
+{
+    /// <summary>
+    /// Defines the contract for an action that operates on a row with a temporary buffer.
+    /// </summary>
+    /// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
+    public interface IRowOperation<TBuffer>
+        where TBuffer : unmanaged
+    {
+        /// <summary>
+        /// Invokes the method passing the row and a buffer.
+        /// </summary>
+        /// <param name="y">The row y coordinate.</param>
+        /// <param name="span">The contiguous region of memory.</param>
+        void Invoke(int y, Span<TBuffer> span);
+    }
+}

src/ImageSharp/Advanced/ParallelRowIterator.Wrappers.cs

@@ -17,51 +17,130 @@ namespace SixLabors.ImageSharp.Advanced
     /// </content>
     public static partial class ParallelRowIterator
     {
-        private readonly struct IterationParameters
+        private readonly struct RowOperationWrapper<T>
+            where T : struct, IRowOperation
         {
-            public readonly int MinY;
-            public readonly int MaxY;
-            public readonly int StepY;
-            public readonly int Width;
+            private readonly int minY;
+            private readonly int maxY;
+            private readonly int stepY;
+            private readonly T action;
 
-            public IterationParameters(int minY, int maxY, int stepY)
-                : this(minY, maxY, stepY, 0)
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public RowOperationWrapper(
+                int minY,
+                int maxY,
+                int stepY,
+                in T action)
             {
+                this.minY = minY;
+                this.maxY = maxY;
+                this.stepY = stepY;
+                this.action = action;
             }
 
-            public IterationParameters(int minY, int maxY, int stepY, int width)
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public void Invoke(int i)
             {
-                this.MinY = minY;
-                this.MaxY = maxY;
-                this.StepY = stepY;
-                this.Width = width;
+                int yMin = this.minY + (i * this.stepY);
+
+                if (yMin >= this.maxY)
+                {
+                    return;
+                }
+
+                int yMax = Math.Min(yMin + this.stepY, this.maxY);
+
+                for (int y = yMin; y < yMax; y++)
+                {
+                    // Skip the safety copy when invoking a potentially impure method on a readonly field
+                    Unsafe.AsRef(this.action).Invoke(y);
+                }
+            }
+        }
+
+        private readonly struct RowOperationWrapper<T, TBuffer>
+            where T : struct, IRowOperation<TBuffer>
+            where TBuffer : unmanaged
+        {
+            private readonly int minY;
+            private readonly int maxY;
+            private readonly int stepY;
+            private readonly int width;
+            private readonly MemoryAllocator allocator;
+            private readonly T action;
+
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public RowOperationWrapper(
+                int minY,
+                int maxY,
+                int stepY,
+                int width,
+                MemoryAllocator allocator,
+                in T action)
+            {
+                this.minY = minY;
+                this.maxY = maxY;
+                this.stepY = stepY;
+                this.width = width;
+                this.allocator = allocator;
+                this.action = action;
+            }
+
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public void Invoke(int i)
+            {
+                int yMin = this.minY + (i * this.stepY);
+
+                if (yMin >= this.maxY)
+                {
+                    return;
+                }
+
+                int yMax = Math.Min(yMin + this.stepY, this.maxY);
+
+                using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.width);
+
+                Span<TBuffer> span = buffer.Memory.Span;
+
+                for (int y = yMin; y < yMax; y++)
+                {
+                    Unsafe.AsRef(this.action).Invoke(y, span);
+                }
             }
         }
 
         private readonly struct RowIntervalOperationWrapper<T>
             where T : struct, IRowIntervalOperation
         {
-            private readonly IterationParameters info;
+            private readonly int minY;
+            private readonly int maxY;
+            private readonly int stepY;
             private readonly T operation;
 
             [MethodImpl(InliningOptions.ShortMethod)]
-            public RowIntervalOperationWrapper(in IterationParameters info, in T operation)
+            public RowIntervalOperationWrapper(
+                int minY,
+                int maxY,
+                int stepY,
+                in T operation)
             {
-                this.info = info;
+                this.minY = minY;
+                this.maxY = maxY;
+                this.stepY = stepY;
                 this.operation = operation;
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public void Invoke(int i)
             {
-                int yMin = this.info.MinY + (i * this.info.StepY);
+                int yMin = this.minY + (i * this.stepY);
 
-                if (yMin >= this.info.MaxY)
+                if (yMin >= this.maxY)
                 {
                     return;
                 }
 
-                int yMax = Math.Min(yMin + this.info.StepY, this.info.MaxY);
+                int yMax = Math.Min(yMin + this.stepY, this.maxY);
                 var rows = new RowInterval(yMin, yMax);
 
                 // Skip the safety copy when invoking a potentially impure method on a readonly field
@@ -73,35 +152,44 @@ private readonly struct RowIntervalOperationWrapper<T, TBuffer>
             where T : struct, IRowIntervalOperation<TBuffer>
             where TBuffer : unmanaged
         {
-            private readonly IterationParameters info;
+            private readonly int minY;
+            private readonly int maxY;
+            private readonly int stepY;
+            private readonly int width;
             private readonly MemoryAllocator allocator;
             private readonly T operation;
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public RowIntervalOperationWrapper(
-                in IterationParameters info,
+                int minY,
+                int maxY,
+                int stepY,
+                int width,
                 MemoryAllocator allocator,
                 in T operation)
             {
-                this.info = info;
+                this.minY = minY;
+                this.maxY = maxY;
+                this.stepY = stepY;
+                this.width = width;
                 this.allocator = allocator;
                 this.operation = operation;
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]
             public void Invoke(int i)
             {
-                int yMin = this.info.MinY + (i * this.info.StepY);
+                int yMin = this.minY + (i * this.stepY);
 
-                if (yMin >= this.info.MaxY)
+                if (yMin >= this.maxY)
                 {
                     return;
                 }
 
-                int yMax = Math.Min(yMin + this.info.StepY, this.info.MaxY);
+                int yMax = Math.Min(yMin + this.stepY, this.maxY);
                 var rows = new RowInterval(yMin, yMax);
 
-                using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.info.Width);
+                using IMemoryOwner<TBuffer> buffer = this.allocator.Allocate<TBuffer>(this.width);
 
                 Unsafe.AsRef(in this.operation).Invoke(in rows, buffer.Memory.Span);
             }