Issue 551 solidbrush blend performance

src/ImageSharp.Drawing/Processing/Drawing/Brushes/SolidBrush{TPixel}.cs

@@ -90,16 +90,23 @@ internal override void Apply(Span<float> scanline, int x, int y)
 
                 MemoryManager memoryManager = this.Target.MemoryManager;
 
-                using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
+                if (this.Options.BlendPercentage == 1f)
                 {
-                    Span<float> amountSpan = amountBuffer.Span;
-
-                    for (int i = 0; i < scanline.Length; i++)
+                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.Span, scanline);
+                }
+                else
+                {
+                    using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
                     {
-                        amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
-                    }
+                        Span<float> amountSpan = amountBuffer.Span;
+
+                        for (int i = 0; i < scanline.Length; i++)
+                        {
+                            amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
+                        }
 
-                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.Span, amountSpan);
+                        this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.Span, amountSpan);
+                    }
                 }
             }
         }

src/ImageSharp.Drawing/Processing/Drawing/Processors/FillProcessor.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Threading.Tasks;
+using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Drawing.Brushes;
@@ -49,39 +50,66 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
             int minY = Math.Max(0, startY);
             int maxY = Math.Min(source.Height, endY);
 
-            // Reset offset if necessary.
-            if (minX > 0)
-            {
-                startX = 0;
-            }
-
-            if (minY > 0)
-            {
-                startY = 0;
-            }
-
             int width = maxX - minX;
 
-            using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
-            using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
-                source,
-                sourceRectangle,
-                this.options))
+            // If there's no reason for blending, then avoid it.
+            if (this.IsSolidBrushWithoutBlending(out SolidBrush<TPixel> solidBrush))
             {
-                amount.Span.Fill(1f);
-
                 Parallel.For(
                     minY,
                     maxY,
                     configuration.ParallelOptions,
                     y =>
-                        {
-                            int offsetY = y - startY;
-                            int offsetX = minX - startX;
+                    {
+                        source.GetPixelRowSpan(y).Slice(minX, width).Fill(solidBrush.Color);
+                    });
+            }
+            else
+            {
+                // Reset offset if necessary.
+                if (minX > 0)
+                {
+                    startX = 0;
+                }
+
+                if (minY > 0)
+                {
+                    startY = 0;
+                }
+
+                using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
+                using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
+                    source,
+                    sourceRectangle,
+                    this.options))
+                {
+                    amount.Span.Fill(1f);
+
+                    Parallel.For(
+                        minY,
+                        maxY,
+                        configuration.ParallelOptions,
+                        y =>
+                            {
+                                int offsetY = y - startY;
+                                int offsetX = minX - startX;
 
-                            applicator.Apply(amount.Span, offsetX, offsetY);
-                        });
+                                applicator.Apply(amount.Span, offsetX, offsetY);
+                            });
+                }
             }
         }
+
+        private bool IsSolidBrushWithoutBlending(out SolidBrush<TPixel> solidBrush)
+        {
+            solidBrush = this.brush as SolidBrush<TPixel>;
+
+            return solidBrush != null
+                   && ((this.options.BlenderMode == PixelBlenderMode.Normal && this.options.BlendPercentage == 1f
+                                                                            && solidBrush.Color.ToVector4().W == 1f)
+                       || (this.options.BlenderMode == PixelBlenderMode.Over && this.options.BlendPercentage == 1f
+                                                                             && solidBrush.Color.ToVector4().W == 1f)
+                       || (this.options.BlenderMode == PixelBlenderMode.Src));
+        }
     }
 }

src/ImageSharp.Drawing/Processing/Drawing/Processors/FillProcessor.cs.orig

@@ -0,0 +1,121 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Drawing.Brushes;
+using SixLabors.ImageSharp.Processing.Processors;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing.Drawing.Processors
+{
+    /// <summary>
+    /// Using the brush as a source of pixels colors blends the brush color with source.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    internal class FillProcessor<TPixel> : ImageProcessor<TPixel>
+        where TPixel : struct, IPixel<TPixel>
+    {
+        /// <summary>
+        /// The brush.
+        /// </summary>
+        private readonly IBrush<TPixel> brush;
+        private readonly GraphicsOptions options;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FillProcessor{TPixel}"/> class.
+        /// </summary>
+        /// <param name="brush">The brush to source pixel colors from.</param>
+        /// <param name="options">The options</param>
+        public FillProcessor(IBrush<TPixel> brush, GraphicsOptions options)
+        {
+            this.brush = brush;
+            this.options = options;
+        }
+
+        /// <inheritdoc/>
+        protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle sourceRectangle, Configuration configuration)
+        {
+            int startX = sourceRectangle.X;
+            int endX = sourceRectangle.Right;
+            int startY = sourceRectangle.Y;
+            int endY = sourceRectangle.Bottom;
+
+            // Align start/end positions.
+            int minX = Math.Max(0, startX);
+            int maxX = Math.Min(source.Width, endX);
+            int minY = Math.Max(0, startY);
+            int maxY = Math.Min(source.Height, endY);
+
+            int width = maxX - minX;
+
+<<<<<<< HEAD
+            var solidBrush = this.brush as SolidBrush<TPixel>;
+=======
+            using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
+            using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
+                source,
+                sourceRectangle,
+                this.options))
+            {
+                amount.Span.Fill(1f);
+>>>>>>> master
+
+            // If there's no reason for blending, then avoid it.
+            if (solidBrush != null &&
+                (
+                    (this.options.BlenderMode == PixelBlenderMode.Normal && this.options.BlendPercentage == 1f && solidBrush.Color.ToVector4().W == 1f) ||
+                    (this.options.BlenderMode == PixelBlenderMode.Over && this.options.BlendPercentage == 1f && solidBrush.Color.ToVector4().W == 1f) ||
+                    (this.options.BlenderMode == PixelBlenderMode.Src)))
+            {
+                Parallel.For(
+                    minY,
+                    maxY,
+                    configuration.ParallelOptions,
+                    y =>
+                    {
+                        int offsetY = y - startY;
+                        int offsetX = minX - startX;
+                        source.GetPixelRowSpan(y).Slice(minX, width).Fill(solidBrush.Color);
+                    });
+            }
+            else
+            {
+                // Reset offset if necessary.
+                if (minX > 0)
+                {
+                    startX = 0;
+                }
+
+                if (minY > 0)
+                {
+                    startY = 0;
+                }
+
+                using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
+                using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
+                    source,
+                    sourceRectangle,
+                    this.options))
+                {
+                    amount.Span.Fill(this.options.BlendPercentage);
+
+                    Parallel.For(
+                        minY,
+                        maxY,
+                        configuration.ParallelOptions,
+                        y =>
+                            {
+                                int offsetY = y - startY;
+                                int offsetX = minX - startX;
+
+                                applicator.Apply(amount.Span, offsetX, offsetY);
+                            });
+                }
+            }
+        }
+    }
+}