Fix arguments order and tests

src/ImageSharp/Advanced/ParallelRowIterator.cs

@@ -21,15 +21,15 @@ namespace SixLabors.ImageSharp.Advanced
         /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
         /// </summary>
         /// <typeparam name="T">The type of row operation to perform.</typeparam>
-        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
         /// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
-        /// <param name="body">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public static void IterateRows<T>(Rectangle rectangle, Configuration configuration, in T body)
+        public static void IterateRows<T>(Configuration configuration, Rectangle rectangle, in T operation)
             where T : struct, IRowIntervalOperation
         {
             var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
-            IterateRows(rectangle, in parallelSettings, in body);
+            IterateRows(rectangle, in parallelSettings, in operation);
         }
 
         /// <summary>
@@ -38,7 +38,7 @@ namespace SixLabors.ImageSharp.Advanced
         /// <typeparam name="T">The type of row operation to perform.</typeparam>
         /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
         /// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
-        /// <param name="operation">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
         public static void IterateRows<T>(
             Rectangle rectangle,
             in ParallelExecutionSettings parallelSettings,
@@ -81,10 +81,10 @@ namespace SixLabors.ImageSharp.Advanced
         /// </summary>
         /// <typeparam name="T">The type of row operation to perform.</typeparam>
         /// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
-        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
         /// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
-        /// <param name="operation">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
+        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
-        public static void IterateRows<T, TBuffer>(Rectangle rectangle, Configuration configuration, in T operation)
+        /// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
+        public static void IterateRows<T, TBuffer>(Configuration configuration, Rectangle rectangle, in T operation)
             where T : struct, IRowIntervalOperation<TBuffer>
             where TBuffer : unmanaged
         {
@@ -100,7 +100,7 @@ namespace SixLabors.ImageSharp.Advanced
         /// <typeparam name="TBuffer">The type of buffer elements.</typeparam>
         /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
         /// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
-        /// <param name="operation">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
+        /// <param name="operation">The operation defining the iteration logic on a single <see cref="RowInterval"/>.</param>
         public static void IterateRows<T, TBuffer>(
             Rectangle rectangle,
             in ParallelExecutionSettings parallelSettings,
@@ -143,118 +143,6 @@ namespace SixLabors.ImageSharp.Advanced
                 rowOperation.Invoke);
         }
 
-        /// <summary>
-        /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
-        /// </summary>
-        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
-        /// <param name="configuration">The <see cref="Configuration"/> to get the parallel settings from.</param>
-        /// <param name="body">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
-        internal static void IterateRows(Rectangle rectangle, Configuration configuration, Action<RowInterval> body)
-        {
-            var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
-            IterateRows(rectangle, in parallelSettings, body);
-        }
-
-        /// <summary>
-        /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s.
-        /// </summary>
-        /// <param name="rectangle">The <see cref="Rectangle"/>.</param>
-        /// <param name="parallelSettings">The <see cref="ParallelExecutionSettings"/>.</param>
-        /// <param name="body">The method body defining the iteration logic on a single <see cref="RowInterval"/>.</param>
-        internal static void IterateRows(
-            Rectangle rectangle,
-            in ParallelExecutionSettings parallelSettings,
-            Action<RowInterval> body)
-        {
-            ValidateRectangle(rectangle);
-
-            int top = rectangle.Top;
-            int bottom = rectangle.Bottom;
-            int width = rectangle.Width;
-            int height = rectangle.Height;
-
-            int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask);
-            int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
-
-            // Avoid TPL overhead in this trivial case:
-            if (numOfSteps == 1)
-            {
-                var rows = new RowInterval(top, bottom);
-                body(rows);
-                return;
-            }
-
-            int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-            var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-            var rowInfo = new WrappingRowIntervalInfo(top, bottom, verticalStep);
-            var rowAction = new WrappingRowIntervalOperation(in rowInfo, body);
-
-            Parallel.For(
-                0,
-                numOfSteps,
-                parallelOptions,
-                rowAction.Invoke);
-        }
-
-        /// <summary>
-        /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
-        /// instantiating a temporary buffer for each <paramref name="body"/> invocation.
-        /// </summary>
-        internal static void IterateRows<TBuffer>(
-            Rectangle rectangle,
-            Configuration configuration,
-            Action<RowInterval, Memory<TBuffer>> body)
-            where TBuffer : unmanaged
-        {
-            var parallelSettings = ParallelExecutionSettings.FromConfiguration(configuration);
-            IterateRows(rectangle, in parallelSettings, body);
-        }
-
-        /// <summary>
-        /// Iterate through the rows of a rectangle in optimized batches defined by <see cref="RowInterval"/>-s
-        /// instantiating a temporary buffer for each <paramref name="body"/> invocation.
-        /// </summary>
-        internal static void IterateRows<TBuffer>(
-            Rectangle rectangle,
-            in ParallelExecutionSettings parallelSettings,
-            Action<RowInterval, Memory<TBuffer>> body)
-            where TBuffer : unmanaged
-        {
-            ValidateRectangle(rectangle);
-
-            int top = rectangle.Top;
-            int bottom = rectangle.Bottom;
-            int width = rectangle.Width;
-            int height = rectangle.Height;
-
-            int maxSteps = DivideCeil(width * height, parallelSettings.MinimumPixelsProcessedPerTask);
-            int numOfSteps = Math.Min(parallelSettings.MaxDegreeOfParallelism, maxSteps);
-            MemoryAllocator allocator = parallelSettings.MemoryAllocator;
-
-            // Avoid TPL overhead in this trivial case:
-            if (numOfSteps == 1)
-            {
-                var rows = new RowInterval(top, bottom);
-                using (IMemoryOwner<TBuffer> buffer = allocator.Allocate<TBuffer>(width))
-                {
-                    body(rows, buffer.Memory);
-                }
-
-                return;
-            }
-
-            int verticalStep = DivideCeil(rectangle.Height, numOfSteps);
-            var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = numOfSteps };
-            var rowInfo = new WrappingRowIntervalInfo(top, bottom, verticalStep, width);
-            var rowAction = new WrappingRowIntervalBufferOperation<TBuffer>(in rowInfo, allocator, body);
-
-            Parallel.For(
-                0,
-                numOfSteps,
-                parallelOptions,
-                rowAction.Invoke);
-        }
-
         [MethodImpl(InliningOptions.ShortMethod)]
         private static int DivideCeil(int dividend, int divisor) => 1 + ((dividend - 1) / divisor);
 

src/ImageSharp/ImageFrame{TPixel}.cs

@@ -259,11 +259,12 @@ namespace SixLabors.ImageSharp
             }
 
             var target = new ImageFrame<TPixel2>(configuration, this.Width, this.Height, this.Metadata.DeepClone());
+            var operation = new RowIntervalOperation<TPixel2>(this, target, configuration);
 
             ParallelRowIterator.IterateRows(
-                this.Bounds(),
                 configuration,
-                new RowIntervalOperation<TPixel2>(this, target, configuration));
+                this.Bounds(),
+                in operation);
 
             return target;
         }

src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor{TPixel}.cs

@@ -50,11 +50,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
             bool isAlphaOnly = typeof(TPixel) == typeof(A8);
 
             var workingRect = Rectangle.FromLTRB(startX, startY, endX, endY);
-
+            var operation = new RowIntervalOperation(source, upper, lower, threshold, startX, endX, isAlphaOnly);
             ParallelRowIterator.IterateRows(
-                workingRect,
                 configuration,
-                new RowIntervalOperation(source, upper, lower, threshold, startX, endX, isAlphaOnly));
+                workingRect,
+                in operation);
         }
 
         /// <summary>

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

@@ -268,10 +268,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
             // Preliminary gamma highlight pass
+            var gammaOperation = new ApplyGammaExposureRowIntervalOperation(this.SourceRectangle, source.PixelBuffer, this.Configuration, this.gamma);
             ParallelRowIterator.IterateRows<ApplyGammaExposureRowIntervalOperation, Vector4>(
-                this.SourceRectangle,
                 this.Configuration,
-                new ApplyGammaExposureRowIntervalOperation(this.SourceRectangle, source.PixelBuffer, this.Configuration, this.gamma));
+                this.SourceRectangle,
+                in gammaOperation);
 
             // Create a 0-filled buffer to use to store the result of the component convolutions
             using Buffer2D<Vector4> processingBuffer = this.Configuration.MemoryAllocator.Allocate2D<Vector4>(source.Size(), AllocationOptions.Clean);
@@ -282,10 +283,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             float inverseGamma = 1 / this.gamma;
 
             // Apply the inverse gamma exposure pass, and write the final pixel data
+            var operation = new ApplyInverseGammaExposureRowIntervalOperation(this.SourceRectangle, source.PixelBuffer, processingBuffer, this.Configuration, inverseGamma);
             ParallelRowIterator.IterateRows(
-                this.SourceRectangle,
                 this.Configuration,
-                new ApplyInverseGammaExposureRowIntervalOperation(this.SourceRectangle, source.PixelBuffer, processingBuffer, this.Configuration, inverseGamma));
+                this.SourceRectangle,
+                in operation);
         }
 
         /// <summary>
@@ -314,16 +316,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                 Vector4 parameters = Unsafe.Add(ref paramsRef, i);
 
                 // Compute the vertical 1D convolution
+                var verticalOperation = new ApplyVerticalConvolutionRowIntervalOperation(ref sourceRectangle, firstPassBuffer, source.PixelBuffer, kernel);
                 ParallelRowIterator.IterateRows(
-                    sourceRectangle,
                     configuration,
-                    new ApplyVerticalConvolutionRowIntervalOperation(ref sourceRectangle, firstPassBuffer, source.PixelBuffer, kernel));
+                    sourceRectangle,
+                    in verticalOperation);
 
                 // Compute the horizontal 1D convolutions and accumulate the partial results on the target buffer
+                var horizontalOperation = new ApplyHorizontalConvolutionRowIntervalOperation(ref sourceRectangle, processingBuffer, firstPassBuffer, kernel, parameters.Z, parameters.W);
                 ParallelRowIterator.IterateRows(
-                    sourceRectangle,
                     configuration,
-                    new ApplyHorizontalConvolutionRowIntervalOperation(ref sourceRectangle, processingBuffer, firstPassBuffer, kernel, parameters.Z, parameters.W));
+                    sourceRectangle,
+                    in horizontalOperation);
             }
         }
 

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

@@ -65,11 +65,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             source.CopyTo(targetPixels);
 
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
+            var operation = new RowIntervalOperation(interest, targetPixels, source.PixelBuffer, this.KernelY, this.KernelX, this.Configuration, this.PreserveAlpha);
 
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest, targetPixels, source.PixelBuffer, this.KernelY, this.KernelX, this.Configuration, this.PreserveAlpha));
+                interest,
+                in operation);
 
             Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
         }

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

@@ -64,16 +64,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
 
             // Horizontal convolution
+            var horizontalOperation = new RowIntervalOperation(interest, firstPassPixels, source.PixelBuffer, this.KernelX, this.Configuration, this.PreserveAlpha);
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest, firstPassPixels, source.PixelBuffer, this.KernelX, this.Configuration, this.PreserveAlpha));
+                interest,
+                in horizontalOperation);
 
             // Vertical convolution
+            var verticalOperation = new RowIntervalOperation(interest, source.PixelBuffer, firstPassPixels, this.KernelY, this.Configuration, this.PreserveAlpha);
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest, source.PixelBuffer, firstPassPixels, this.KernelY, this.Configuration, this.PreserveAlpha));
+                interest,
+                in verticalOperation);
         }
 
         /// <summary>

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

@@ -56,11 +56,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             source.CopyTo(targetPixels);
 
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
-
+            var operation = new RowIntervalOperation(interest, targetPixels, source.PixelBuffer, this.KernelXY, this.Configuration, this.PreserveAlpha);
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest, targetPixels, source.PixelBuffer, this.KernelXY, this.Configuration, this.PreserveAlpha));
+                interest,
+                in operation);
 
             Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
         }

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

@@ -102,10 +102,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                     processor.Apply(pass);
                 }
 
+                var operation = new RowIntervalOperation(source.PixelBuffer, pass.PixelBuffer, minX, maxX, shiftY, shiftX);
                 ParallelRowIterator.IterateRows(
-                    Rectangle.FromLTRB(minX, minY, maxX, maxY),
                     this.Configuration,
-                    new RowIntervalOperation(source.PixelBuffer, pass.PixelBuffer, minX, maxX, shiftY, shiftX));
+                    Rectangle.FromLTRB(minX, minY, maxX, maxY),
+                    in operation);
             }
         }
 

src/ImageSharp/Processing/Processors/Drawing/DrawImageProcessor{TPixelBg,TPixelFg}.cs

@@ -99,10 +99,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
                     "Cannot draw image because the source image does not overlap the target image.");
             }
 
+            var operation = new RowIntervalOperation(source, targetImage, blender, configuration, minX, width, locationY, targetX, this.Opacity);
             ParallelRowIterator.IterateRows(
-                workingRect,
                 configuration,
-                new RowIntervalOperation(source, targetImage, blender, configuration, minX, width, locationY, targetX, this.Opacity));
+                workingRect,
+                in operation);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor{TPixel}.cs

@@ -47,10 +47,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Effects
 
             source.CopyTo(targetPixels);
 
+            var operation = new RowIntervalOperation(this.SourceRectangle, targetPixels, source, this.Configuration, brushSize >> 1, this.definition.Levels);
             ParallelRowIterator.IterateRows(
-                this.SourceRectangle,
                 this.Configuration,
-                new RowIntervalOperation(this.SourceRectangle, targetPixels, source, this.Configuration, brushSize >> 1, this.definition.Levels));
+                this.SourceRectangle,
+                in operation);
 
             Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
         }

src/ImageSharp/Processing/Processors/Effects/PixelRowDelegateProcessor{TPixel,TDelegate}.cs

@@ -50,11 +50,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Effects
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
+            var operation = new RowIntervalOperation(interest.X, source, this.Configuration, this.modifiers, this.rowDelegate);
 
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest.X, source, this.Configuration, this.modifiers, this.rowDelegate));
+                interest,
+                in operation);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Filters/FilterProcessor{TPixel}.cs

@@ -36,11 +36,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
+            var operation = new RowIntervalOperation(interest.X, source, this.definition.Matrix, this.Configuration);
 
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                interest,
                 this.Configuration,
-                new RowIntervalOperation(interest.X, source, this.definition.Matrix, this.Configuration));
+                interest,
+                in operation);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs

@@ -80,10 +80,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                     yStart += tileHeight;
                 }
 
+                var operation = new RowIntervalOperation(cdfData, tileYStartPositions, tileWidth, tileHeight, tileCount, halfTileWidth, luminanceLevels, source);
                 ParallelRowIterator.IterateRows(
-                    new Rectangle(0, 0, sourceWidth, tileYStartPositions.Count),
                     this.Configuration,
-                    new RowIntervalOperation(cdfData, tileYStartPositions, tileWidth, tileHeight, tileCount, halfTileWidth, luminanceLevels, source));
+                    new Rectangle(0, 0, sourceWidth, tileYStartPositions.Count),
+                    in operation);
 
                 ref TPixel pixelsBase = ref source.GetPixelReference(0, 0);
 
@@ -510,7 +511,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
 
             public void CalculateLookupTables(ImageFrame<TPixel> source, HistogramEqualizationProcessor<TPixel> processor)
             {
-                var rowOperation = new RowIntervalOperation(
+                var operation = new RowIntervalOperation(
                     processor,
                     this.memoryAllocator,
                     this.cdfMinBuffer2D,
@@ -522,9 +523,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                     source);
 
                 ParallelRowIterator.IterateRows(
-                    new Rectangle(0, 0, this.sourceWidth, this.tileYStartPositions.Count),
                     this.configuration,
-                    in rowOperation);
+                    new Rectangle(0, 0, this.sourceWidth, this.tileYStartPositions.Count),
+                    in operation);
             }
 
             [MethodImpl(InliningOptions.ShortMethod)]

src/ImageSharp/Processing/Processors/Normalization/GlobalHistogramEqualizationProcessor{TPixel}.cs

@@ -52,10 +52,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
             using IMemoryOwner<int> histogramBuffer = memoryAllocator.Allocate<int>(this.LuminanceLevels, AllocationOptions.Clean);
 
             // Build the histogram of the grayscale levels
+            var grayscaleOperation = new GrayscaleLevelsRowIntervalOperation(workingRect, histogramBuffer, source, this.LuminanceLevels);
             ParallelRowIterator.IterateRows(
-                workingRect,
                 this.Configuration,
-                new GrayscaleLevelsRowIntervalOperation(workingRect, histogramBuffer, source, this.LuminanceLevels));
+                workingRect,
+                in grayscaleOperation);
 
             Span<int> histogram = histogramBuffer.GetSpan();
             if (this.ClipHistogramEnabled)
@@ -74,10 +75,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
             float numberOfPixelsMinusCdfMin = numberOfPixels - cdfMin;
 
             // Apply the cdf to each pixel of the image
+            var cdfOperation = new CdfApplicationRowIntervalOperation(workingRect, cdfBuffer, source, this.LuminanceLevels, numberOfPixelsMinusCdfMin);
             ParallelRowIterator.IterateRows(
-                workingRect,
                 this.Configuration,
-                new CdfApplicationRowIntervalOperation(workingRect, cdfBuffer, source, this.LuminanceLevels, numberOfPixelsMinusCdfMin));
+                workingRect,
+                in cdfOperation);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor{TPixel}.cs

@@ -49,10 +49,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
 
             PixelBlender<TPixel> blender = PixelOperations<TPixel>.Instance.GetPixelBlender(graphicsOptions);
 
+            var operation = new RowIntervalOperation(configuration, interest, blender, amount, colors, source);
             ParallelRowIterator.IterateRows(
-                interest,
                 configuration,
-                new RowIntervalOperation(configuration, interest, blender, amount, colors, source));
+                interest,
+                in operation);
         }
 
         private readonly struct RowIntervalOperation : IRowIntervalOperation

src/ImageSharp/Processing/Processors/Overlays/GlowProcessor{TPixel}.cs

@@ -55,10 +55,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
             using IMemoryOwner<TPixel> rowColors = allocator.Allocate<TPixel>(interest.Width);
             rowColors.GetSpan().Fill(glowColor);
 
+            var operation = new RowIntervalOperation(configuration, interest, rowColors, this.blender, center, maxDistance, blendPercent, source);
             ParallelRowIterator.IterateRows<RowIntervalOperation, float>(
-                interest,
                 configuration,
-                new RowIntervalOperation(configuration, interest, rowColors, this.blender, center, maxDistance, blendPercent, source));
+                interest,
+                in operation);
         }
 
         private readonly struct RowIntervalOperation : IRowIntervalOperation<float>

src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor{TPixel}.cs

@@ -63,10 +63,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
             using IMemoryOwner<TPixel> rowColors = allocator.Allocate<TPixel>(interest.Width);
             rowColors.GetSpan().Fill(vignetteColor);
 
+            var operation = new RowIntervalOperation(configuration, interest, rowColors, this.blender, center, maxDistance, blendPercent, source);
             ParallelRowIterator.IterateRows<RowIntervalOperation, float>(
-                interest,
                 configuration,
-                new RowIntervalOperation(configuration, interest, rowColors, this.blender, center, maxDistance, blendPercent, source));
+                interest,
+                in operation);
         }
 
         private readonly struct RowIntervalOperation : IRowIntervalOperation<float>

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

@@ -58,20 +58,22 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
 
             if (this.resampler is NearestNeighborResampler)
             {
+                var nnOperation = new NearestNeighborRowIntervalOperation(this.SourceRectangle, ref matrix, width, source, destination);
                 ParallelRowIterator.IterateRows(
-                    targetBounds,
                     configuration,
-                    new NearestNeighborRowIntervalOperation(this.SourceRectangle, ref matrix, width, source, destination));
+                    targetBounds,
+                    in nnOperation);
 
                 return;
             }
 
             using var kernelMap = new TransformKernelMap(configuration, source.Size(), destination.Size(), this.resampler);
 
+            var operation = new RowIntervalOperation(configuration, kernelMap, ref matrix, width, source, destination);
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                targetBounds,
                 configuration,
-                new RowIntervalOperation(configuration, kernelMap, ref matrix, width, source, destination));
+                targetBounds,
+                in operation);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Transforms/FlipProcessor{TPixel}.cs

@@ -76,10 +76,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="configuration">The configuration.</param>
         private void FlipY(ImageFrame<TPixel> source, Configuration configuration)
         {
+            var operation = new RowIntervalOperation(source);
             ParallelRowIterator.IterateRows(
-                source.Bounds(),
                 configuration,
-                new RowIntervalOperation(source));
+                source.Bounds(),
+                in operation);
         }
 
         private readonly struct RowIntervalOperation : IRowIntervalOperation

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

@@ -60,20 +60,22 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
             {
                 Rectangle sourceBounds = this.SourceRectangle;
 
+                var nnOperation = new NearestNeighborRowIntervalOperation(ref sourceBounds, ref matrix, width, source, destination);
                 ParallelRowIterator.IterateRows(
-                    targetBounds,
                     configuration,
-                    new NearestNeighborRowIntervalOperation(ref sourceBounds, ref matrix, width, source, destination));
+                    targetBounds,
+                    in nnOperation);
 
                 return;
             }
 
             using var kernelMap = new TransformKernelMap(configuration, source.Size(), destination.Size(), this.resampler);
 
+            var operation = new RowIntervalOperation(configuration, kernelMap, ref matrix, width, source, destination);
             ParallelRowIterator.IterateRows<RowIntervalOperation, Vector4>(
-                targetBounds,
                 configuration,
-                new RowIntervalOperation(configuration, kernelMap, ref matrix, width, source, destination));
+                targetBounds,
+                in operation);
         }
 
         private readonly struct NearestNeighborRowIntervalOperation : IRowIntervalOperation

src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs

@@ -95,10 +95,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 float widthFactor = sourceRectangle.Width / (float)this.targetRectangle.Width;
                 float heightFactor = sourceRectangle.Height / (float)this.targetRectangle.Height;
 
+                var operation = new RowIntervalOperation(sourceRectangle, this.targetRectangle, widthFactor, heightFactor, source, destination);
                 ParallelRowIterator.IterateRows(
-                    interest,
                     configuration,
-                    new RowIntervalOperation(sourceRectangle, this.targetRectangle, widthFactor, heightFactor, source, destination));
+                    interest,
+                    in operation);
 
                 return;
             }

src/ImageSharp/Processing/Processors/Transforms/RotateProcessor{TPixel}.cs

@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     internal class RotateProcessor<TPixel> : AffineTransformProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
-        private float degrees;
+        private readonly float degrees;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="RotateProcessor{TPixel}"/> class.
@@ -131,10 +131,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="configuration">The configuration.</param>
         private void Rotate180(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Configuration configuration)
         {
+            var operation = new Rotate180RowIntervalOperation(source.Width, source.Height, source, destination);
             ParallelRowIterator.IterateRows(
-                source.Bounds(),
                 configuration,
-                new Rotate180RowIntervalOperation(source.Width, source.Height, source, destination));
+                source.Bounds(),
+                in operation);
         }
 
         /// <summary>
@@ -145,10 +146,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="configuration">The configuration.</param>
         private void Rotate270(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Configuration configuration)
         {
+            var operation = new Rotate270RowIntervalOperation(destination.Bounds(), source.Width, source.Height, source, destination);
             ParallelRowIterator.IterateRows(
-                source.Bounds(),
                 configuration,
-                new Rotate270RowIntervalOperation(destination.Bounds(), source.Width, source.Height, source, destination));
+                source.Bounds(),
+                in operation);
         }
 
         /// <summary>
@@ -159,10 +161,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="configuration">The configuration.</param>
         private void Rotate90(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Configuration configuration)
         {
+            var operation = new Rotate90RowIntervalOperation(destination.Bounds(), source.Width, source.Height, source, destination);
             ParallelRowIterator.IterateRows(
-                source.Bounds(),
                 configuration,
-                new Rotate90RowIntervalOperation(destination.Bounds(), source.Width, source.Height, source, destination));
+                source.Bounds(),
+                in operation);
         }
 
         private readonly struct Rotate180RowIntervalOperation : IRowIntervalOperation

tests/ImageSharp.Tests/Helpers/ParallelRowIteratorTests.cs

@@ -10,7 +10,6 @@ using System.Threading;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
-
 using Xunit;
 using Xunit.Abstractions;
 
@@ -64,10 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
             int actualNumberOfSteps = 0;
 
-            ParallelRowIterator.IterateRows(
+            void RowAction(RowInterval rows)
-                rectangle,
-                parallelSettings,
-                rows =>
             {
                 Assert.True(rows.Min >= minY);
                 Assert.True(rows.Max <= maxY);
@@ -77,7 +73,14 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
                 Interlocked.Increment(ref actualNumberOfSteps);
                 Assert.Equal(expected, step);
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation(RowAction);
+
+            ParallelRowIterator.IterateRows(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedNumberOfSteps, actualNumberOfSteps);
         }
@@ -102,16 +105,20 @@ namespace SixLabors.ImageSharp.Tests.Helpers
             int[] expectedData = Enumerable.Repeat(0, minY).Concat(Enumerable.Range(minY, maxY - minY)).ToArray();
             var actualData = new int[maxY];
 
-            ParallelRowIterator.IterateRows(
+            void RowAction(RowInterval rows)
-                rectangle,
-                parallelSettings,
-                rows =>
             {
                 for (int y = rows.Min; y < rows.Max; y++)
                 {
                     actualData[y] = y;
                 }
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation(RowAction);
+
+            ParallelRowIterator.IterateRows(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedData, actualData);
         }
@@ -136,10 +143,8 @@ namespace SixLabors.ImageSharp.Tests.Helpers
             var bufferHashes = new ConcurrentBag<int>();
 
             int actualNumberOfSteps = 0;
-            ParallelRowIterator.IterateRows(
+
-                rectangle,
+            void RowAction(RowInterval rows, Memory<Vector4> buffer)
-                parallelSettings,
-                (RowInterval rows, Memory<Vector4> buffer) =>
             {
                 Assert.True(rows.Min >= minY);
                 Assert.True(rows.Max <= maxY);
@@ -151,7 +156,14 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
                 Interlocked.Increment(ref actualNumberOfSteps);
                 Assert.Equal(expected, step);
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+
+            ParallelRowIterator.IterateRows<TestRowIntervalOperation<Vector4>, Vector4>(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedNumberOfSteps, actualNumberOfSteps);
 
@@ -179,16 +191,20 @@ namespace SixLabors.ImageSharp.Tests.Helpers
             int[] expectedData = Enumerable.Repeat(0, minY).Concat(Enumerable.Range(minY, maxY - minY)).ToArray();
             var actualData = new int[maxY];
 
-            ParallelRowIterator.IterateRows(
+            void RowAction(RowInterval rows, Memory<Vector4> buffer)
-                rectangle,
-                parallelSettings,
-                (RowInterval rows, Memory<Vector4> buffer) =>
             {
                 for (int y = rows.Min; y < rows.Max; y++)
                 {
                     actualData[y] = y;
                 }
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+
+            ParallelRowIterator.IterateRows<TestRowIntervalOperation<Vector4>, Vector4>(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedData, actualData);
         }
@@ -225,10 +241,7 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
             int actualNumberOfSteps = 0;
 
-            ParallelRowIterator.IterateRows(
+            void RowAction(RowInterval rows)
-                rectangle,
-                parallelSettings,
-                rows =>
             {
                 Assert.True(rows.Min >= 0);
                 Assert.True(rows.Max <= height);
@@ -238,7 +251,14 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
                 Interlocked.Increment(ref actualNumberOfSteps);
                 Assert.Equal(expected, step);
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation(RowAction);
+
+            ParallelRowIterator.IterateRows(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedNumberOfSteps, actualNumberOfSteps);
         }
@@ -262,10 +282,8 @@ namespace SixLabors.ImageSharp.Tests.Helpers
             var rectangle = new Rectangle(0, 0, width, height);
 
             int actualNumberOfSteps = 0;
-            ParallelRowIterator.IterateRows(
+
-                rectangle,
+            void RowAction(RowInterval rows, Memory<Vector4> buffer)
-                parallelSettings,
-                (RowInterval rows, Memory<Vector4> buffer) =>
             {
                 Assert.True(rows.Min >= 0);
                 Assert.True(rows.Max <= height);
@@ -275,7 +293,14 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
                 Interlocked.Increment(ref actualNumberOfSteps);
                 Assert.Equal(expected, step);
-                    });
+            }
+
+            var operation = new TestRowIntervalOperation<Vector4>(RowAction);
+
+            ParallelRowIterator.IterateRows<TestRowIntervalOperation<Vector4>, Vector4>(
+                rectangle,
+                in parallelSettings,
+                in operation);
 
             Assert.Equal(expectedNumberOfSteps, actualNumberOfSteps);
         }
@@ -325,17 +350,21 @@ namespace SixLabors.ImageSharp.Tests.Helpers
                 // Fill actual data using IterateRows:
                 var settings = new ParallelExecutionSettings(maxDegreeOfParallelism, memoryAllocator);
 
-                ParallelRowIterator.IterateRows(
+                void RowAction(RowInterval rows)
-                    rect,
-                    settings,
-                    rows =>
                 {
                     this.output.WriteLine(rows.ToString());
                     for (int y = rows.Min; y < rows.Max; y++)
                     {
                         FillRow(y, actual);
                     }
-                        });
+                }
+
+                var operation = new TestRowIntervalOperation(RowAction);
+
+                ParallelRowIterator.IterateRows(
+                    rect,
+                    settings,
+                    in operation);
 
                 // Assert:
                 TestImageExtensions.CompareBuffers(expected.GetSpan(), actual.GetSpan());
@@ -353,8 +382,14 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
             var rect = new Rectangle(0, 0, width, height);
 
+            void RowAction(RowInterval rows)
+            {
+            }
+
+            var operation = new TestRowIntervalOperation(RowAction);
+
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
-                () => ParallelRowIterator.IterateRows(rect, parallelSettings, rows => { }));
+                () => ParallelRowIterator.IterateRows(rect, in parallelSettings, in operation));
 
             Assert.Contains(width <= 0 ? "Width" : "Height", ex.Message);
         }
@@ -370,10 +405,38 @@ namespace SixLabors.ImageSharp.Tests.Helpers
 
             var rect = new Rectangle(0, 0, width, height);
 
+            void RowAction(RowInterval rows, Memory<Rgba32> memory)
+            {
+            }
+
+            var operation = new TestRowIntervalOperation<Rgba32>(RowAction);
+
             ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(
-                () => ParallelRowIterator.IterateRows<Rgba32>(rect, parallelSettings, (rows, memory) => { }));
+                () => ParallelRowIterator.IterateRows<TestRowIntervalOperation<Rgba32>, Rgba32>(rect, in parallelSettings, in operation));
 
             Assert.Contains(width <= 0 ? "Width" : "Height", ex.Message);
         }
+
+        private readonly struct TestRowIntervalOperation : IRowIntervalOperation
+        {
+            private readonly Action<RowInterval> action;
+
+            public TestRowIntervalOperation(Action<RowInterval> action)
+                => this.action = action;
+
+            public void Invoke(in RowInterval rows) => this.action(rows);
+        }
+
+        private readonly struct TestRowIntervalOperation<TBuffer> : IRowIntervalOperation<TBuffer>
+            where TBuffer : unmanaged
+        {
+            private readonly Action<RowInterval, Memory<TBuffer>> action;
+
+            public TestRowIntervalOperation(Action<RowInterval, Memory<TBuffer>> action)
+                => this.action = action;
+
+            public void Invoke(in RowInterval rows, Memory<TBuffer> memory)
+                => this.action(rows, memory);
+        }
     }
 }

tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs

@@ -702,25 +702,44 @@ namespace SixLabors.ImageSharp.Tests
             {
                 Rectangle sourceRectangle = this.SourceRectangle;
                 Configuration configuration = this.Configuration;
-                ParallelRowIterator.IterateRows<Vector4>(
+
-                    sourceRectangle,
+                var operation = new RowOperation(configuration, sourceRectangle, source);
+
+                ParallelRowIterator.IterateRows<RowOperation, Vector4>(
                     configuration,
-                    (rows, temp) =>
+                    sourceRectangle,
+                    in operation);
+            }
+
+            private readonly struct RowOperation : IRowIntervalOperation<Vector4>
             {
-                            Span<Vector4> tempSpan = temp.Span;
+                private readonly Configuration configuration;
+                private readonly Rectangle bounds;
+                private readonly ImageFrame<TPixel> source;
+
+                public RowOperation(Configuration configuration, Rectangle bounds, ImageFrame<TPixel> source)
+                {
+                    this.configuration = configuration;
+                    this.bounds = bounds;
+                    this.source = source;
+                }
+
+                public void Invoke(in RowInterval rows, Memory<Vector4> memory)
+                {
+                    Span<Vector4> tempSpan = memory.Span;
                     for (int y = rows.Min; y < rows.Max; y++)
                     {
-                                Span<TPixel> rowSpan = source.GetPixelRowSpan(y).Slice(sourceRectangle.Left, sourceRectangle.Width);
+                        Span<TPixel> rowSpan = this.source.GetPixelRowSpan(y).Slice(this.bounds.Left, this.bounds.Width);
-                                PixelOperations<TPixel>.Instance.ToVector4(configuration, rowSpan, tempSpan, PixelConversionModifiers.Scale);
+                        PixelOperations<TPixel>.Instance.ToVector4(this.configuration, rowSpan, tempSpan, PixelConversionModifiers.Scale);
                         for (int i = 0; i < tempSpan.Length; i++)
                         {
                             ref Vector4 v = ref tempSpan[i];
                             v.W = 1F;
                         }
 
-                                PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, tempSpan, rowSpan, PixelConversionModifiers.Scale);
+                        PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, tempSpan, rowSpan, PixelConversionModifiers.Scale);
+                    }
                 }
-                        });
             }
         }
     }