Refactor brush renderers and FlushScene parallel loop

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Backends/FlushScene.cs

@@ -670,61 +670,51 @@ private void ExecuteCore<TPixel>(
             }
         });
 
-        try
-        {
-            _ = Parallel.For(
-                0,
-                this.RowCount,
-                options,
-                () => new ExecuteWorkerState<TPixel>(
-                    allocator,
+        _ = Parallel.For(
+            0,
+            this.RowCount,
+            options,
+            () => new ExecuteWorkerState<TPixel>(
+                allocator,
+                this.maxWordsPerRow,
+                this.maxCoverStride,
+                this.maxWidth,
+                this.maxBandCapacity),
+            (sceneRow, _, state) =>
+            {
+                DefaultRasterizer.WorkerScratch scratch = state.Scratch!;
+                DefaultRasterizer.Context context = scratch.CreateContext(
+                    this.maxWidth,
                     this.maxWordsPerRow,
                     this.maxCoverStride,
-                    this.maxWidth,
-                    this.maxBandCapacity),
-                (sceneRow, _, state) =>
+                    this.maxBandCapacity,
+                    IntersectionRule.NonZero,
+                    RasterizationMode.Antialiased,
+                    antialiasThreshold: 0F);
+
+                int rowStart = this.rowOffsets[sceneRow];
+                int rowEnd = this.rowOffsets[sceneRow + 1];
+                if (rowStart >= rowEnd)
                 {
-                    DefaultRasterizer.WorkerScratch scratch = state.Scratch!;
-                    DefaultRasterizer.Context context = scratch.CreateContext(
-                        this.maxWidth,
-                        this.maxWordsPerRow,
-                        this.maxCoverStride,
-                        this.maxBandCapacity,
-                        IntersectionRule.NonZero,
-                        RasterizationMode.Antialiased,
-                        antialiasThreshold: 0F);
-
-                    int rowStart = this.rowOffsets[sceneRow];
-                    int rowEnd = this.rowOffsets[sceneRow + 1];
-                    if (rowStart >= rowEnd)
-                    {
-                        return state;
-                    }
-
-                    BandTarget<TPixel> rootTarget = BandTarget<TPixel>.CreateRoot(destinationFrame);
-                    this.ExecuteBand(
-                        configuration,
-                        sourceCommands,
-                        preparedBrushes,
-                        lineData.Span,
-                        startCovers.Span,
-                        sceneRow,
-                        rowStart,
-                        rowEnd,
-                        ref context,
-                        state,
-                        rootTarget);
                     return state;
-                },
-                state => state.Dispose());
-        }
-        finally
-        {
-            for (int i = 0; i < preparedBrushes.Length; i++)
-            {
-                preparedBrushes[i].Dispose();
-            }
-        }
+                }
+
+                BandTarget<TPixel> rootTarget = BandTarget<TPixel>.CreateRoot(destinationFrame);
+                this.ExecuteBand(
+                    configuration,
+                    sourceCommands,
+                    preparedBrushes,
+                    lineData.Span,
+                    startCovers.Span,
+                    sceneRow,
+                    rowStart,
+                    rowEnd,
+                    ref context,
+                    state,
+                    rootTarget);
+                return state;
+            },
+            state => state.Dispose());
     }
 
     /// <summary>

src/ImageSharp.Drawing/Processing/BrushRenderer.cs

@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Drawing.Processing;
 /// Renders a <see cref="Brush"/> against individual coverage scanlines.
 /// </summary>
 /// <typeparam name="TPixel">The pixel format.</typeparam>
-public abstract class BrushRenderer<TPixel> : IDisposable
+public abstract class BrushRenderer<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
     /// <summary>
@@ -47,18 +47,6 @@ protected BrushRenderer(
     /// </summary>
     protected int CanvasWidth { get; }
 
-    /// <summary>
-    /// Gets a value indicating whether this renderer owns disposable resources.
-    /// </summary>
-    internal virtual bool RequiresDispose => false;
-
-    /// <inheritdoc />
-    public void Dispose()
-    {
-        this.Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
     /// <summary>
     /// Applies the opacity weighting for each pixel in a scanline to the target based on the
     /// pattern contained in the brush.

src/ImageSharp.Drawing/Processing/ImageBrush.cs

@@ -169,7 +169,7 @@ private static void ThrowIfInvalidImagePixelFormat()
     /// The image brush applicator.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    private class ImageBrushRenderer<TPixel> : BrushRenderer<TPixel>
+    private sealed class ImageBrushRenderer<TPixel> : BrushRenderer<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
         private readonly ImageFrame<TPixel> sourceFrame;

src/ImageSharp.Drawing/Processing/RecolorBrush.cs

@@ -74,7 +74,7 @@ public override int GetHashCode()
     /// The recolor brush applicator.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    private class RecolorBrushRenderer<TPixel> : BrushRenderer<TPixel>
+    private sealed class RecolorBrushRenderer<TPixel> : BrushRenderer<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
         private readonly Vector4 sourceColor;

src/ImageSharp.Drawing/Processing/SweepGradientBrush.cs

@@ -226,17 +226,16 @@ public override BrushRenderer<TPixel> CreateRenderer<TPixel>(
         Configuration configuration,
         GraphicsOptions options,
         int canvasWidth,
-        RectangleF region)
-    {
+        RectangleF region) =>
+
         // The renderer precomputes the angular interval once and then samples it per pixel.
-        return new SweepGradientBrushRenderer<TPixel>(
+        new SweepGradientBrushRenderer<TPixel>(
             configuration,
             options,
             canvasWidth,
             this,
             this.ColorStopsArray,
             this.RepetitionMode);
-    }
 
     /// <summary>
     /// The sweep (conic) gradient brush applicator.