Configurable & optimized memory management

src/ImageSharp.Drawing/Brushes/ImageBrush{TPixel}.cs

@@ -122,24 +122,27 @@ public override void Dispose()
             internal override void Apply(Span<float> scanline, int x, int y)
             {
                 // Create a span for colors
-                using (var amountBuffer = new Buffer<float>(scanline.Length))
-                using (var overlay = new Buffer<TPixel>(scanline.Length))
+                using (IBuffer<float> amountBuffer = this.Target.MemoryManager.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = this.Target.MemoryManager.Allocate<TPixel>(scanline.Length))
                 {
+                    Span<float> amountSpan = amountBuffer.Span;
+                    Span<TPixel> overlaySpan = overlay.Span;
+
                     int sourceY = (y - this.offsetY) % this.yLength;
                     int offsetX = x - this.offsetX;
                     Span<TPixel> sourceRow = this.source.GetPixelRowSpan(sourceY);
 
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountBuffer[i] = scanline[i] * this.Options.BlendPercentage;
+                        amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
 
                         int sourceX = (i + offsetX) % this.xLength;
                         TPixel pixel = sourceRow[sourceX];
-                        overlay[i] = pixel;
+                        overlaySpan[i] = pixel;
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(destinationRow, destinationRow, overlay, amountBuffer);
+                    this.Blender.Blend(this.source.MemoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

src/ImageSharp.Drawing/Brushes/PatternBrush{TPixel}.cs

@@ -152,19 +152,24 @@ public override void Dispose()
             internal override void Apply(Span<float> scanline, int x, int y)
             {
                 int patternY = y % this.pattern.Height;
-                using (var amountBuffer = new Buffer<float>(scanline.Length))
-                using (var overlay = new Buffer<TPixel>(scanline.Length))
+                MemoryManager memoryManager = this.Target.MemoryManager;
+
+                using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
                 {
+                    Span<float> amountSpan = amountBuffer.Span;
+                    Span<TPixel> overlaySpan = overlay.Span;
+
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountBuffer[i] = (scanline[i] * this.Options.BlendPercentage).Clamp(0, 1);
+                        amountSpan[i] = (scanline[i] * this.Options.BlendPercentage).Clamp(0, 1);
 
                         int patternX = (x + i) % this.pattern.Width;
-                        overlay[i] = this.pattern[patternY, patternX];
+                        overlaySpan[i] = this.pattern[patternY, patternX];
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(destinationRow, destinationRow, overlay, amountBuffer);
+                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

src/ImageSharp.Drawing/Brushes/Processors/BrushApplicator.cs

@@ -65,21 +65,26 @@ internal BrushApplicator(ImageFrame<TPixel> target, GraphicsOptions options)
         /// <remarks>scanlineBuffer will be > scanlineWidth but provide and offset in case we want to share a larger buffer across runs.</remarks>
         internal virtual void Apply(Span<float> scanline, int x, int y)
         {
-            using (var amountBuffer = new Buffer<float>(scanline.Length))
-            using (var overlay = new Buffer<TPixel>(scanline.Length))
+            MemoryManager memoryManager = this.Target.MemoryManager;
+
+            using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
+            using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
             {
+                Span<float> amountSpan = amountBuffer.Span;
+                Span<TPixel> overlaySpan = overlay.Span;
+
                 for (int i = 0; i < scanline.Length; i++)
                 {
                     if (this.Options.BlendPercentage < 1)
                     {
-                        amountBuffer[i] = scanline[i] * this.Options.BlendPercentage;
+                        amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
                     }
 
-                    overlay[i] = this[x + i, y];
+                    overlaySpan[i] = this[x + i, y];
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                this.Blender.Blend(destinationRow, destinationRow, overlay, amountBuffer);
+                this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
             }
         }
     }

src/ImageSharp.Drawing/Brushes/RecolorBrush{TPixel}.cs

@@ -144,22 +144,27 @@ public override void Dispose()
             /// <inheritdoc />
             internal override void Apply(Span<float> scanline, int x, int y)
             {
-                using (var amountBuffer = new Buffer<float>(scanline.Length))
-                using (var overlay = new Buffer<TPixel>(scanline.Length))
+                MemoryManager memoryManager = this.Target.MemoryManager;
+
+                using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
                 {
+                    Span<float> amountSpan = amountBuffer.Span;
+                    Span<TPixel> overlaySpan = overlay.Span;
+
                     for (int i = 0; i < scanline.Length; i++)
                     {
-                        amountBuffer[i] = scanline[i] * this.Options.BlendPercentage;
+                        amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
 
                         int offsetX = x + i;
 
                         // no doubt this one can be optermised further but I can't imagine its
                         // actually being used and can probably be removed/interalised for now
-                        overlay[i] = this[offsetX, y];
+                        overlaySpan[i] = this[offsetX, y];
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(destinationRow, destinationRow, overlay, amountBuffer);
+                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

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

@@ -61,17 +61,14 @@ private class SolidBrushApplicator : BrushApplicator<TPixel>
             public SolidBrushApplicator(ImageFrame<TPixel> source, TPixel color, GraphicsOptions options)
                 : base(source, options)
             {
-                this.Colors = new Buffer<TPixel>(source.Width);
-                for (int i = 0; i < this.Colors.Length; i++)
-                {
-                    this.Colors[i] = color;
-                }
+                this.Colors = source.MemoryManager.Allocate<TPixel>(source.Width);
+                this.Colors.Span.Fill(color);
             }
 
             /// <summary>
             /// Gets the colors.
             /// </summary>
-            protected Buffer<TPixel> Colors { get; }
+            protected IBuffer<TPixel> Colors { get; }
 
             /// <summary>
             /// Gets the color for a single pixel.
@@ -81,7 +78,7 @@ public SolidBrushApplicator(ImageFrame<TPixel> source, TPixel color, GraphicsOpt
             /// <returns>
             /// The color
             /// </returns>
-            internal override TPixel this[int x, int y] => this.Colors[x];
+            internal override TPixel this[int x, int y] => this.Colors.Span[x];
 
             /// <inheritdoc />
             public override void Dispose()
@@ -96,18 +93,23 @@ internal override void Apply(Span<float> scanline, int x, int y)
                 {
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
 
-                    using (var amountBuffer = new Buffer<float>(scanline.Length))
+                    MemoryManager memoryManager = this.Target.MemoryManager;
+
+                    using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
                     {
+                        Span<float> amountSpan = amountBuffer.Span;
+
                         for (int i = 0; i < scanline.Length; i++)
                         {
-                            amountBuffer[i] = scanline[i] * this.Options.BlendPercentage;
+                            amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
                         }
 
-                        this.Blender.Blend(destinationRow, destinationRow, this.Colors, amountBuffer);
+                        this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.Span, amountSpan);
                     }
                 }
                 catch (Exception)
                 {
+                    // TODO: Why are we catching exceptions here silently ???
                     throw;
                 }
             }

src/ImageSharp.Drawing/Paths/ShapePath.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Buffers;
 using System.Numerics;
+
+using SixLabors.ImageSharp.Memory;
 using SixLabors.Shapes;
 
 namespace SixLabors.ImageSharp.Drawing

src/ImageSharp.Drawing/Paths/ShapeRegion.cs

@@ -46,18 +46,17 @@ public override int Scan(float y, float[] buffer, int offset)
         {
             var start = new PointF(this.Bounds.Left - 1, y);
             var end = new PointF(this.Bounds.Right + 1, y);
-            using (var innerBuffer = new Buffer<PointF>(buffer.Length))
-            {
-                PointF[] array = innerBuffer.Array;
-                int count = this.Shape.FindIntersections(start, end, array, 0);
 
-                for (int i = 0; i < count; i++)
-                {
-                    buffer[i + offset] = array[i].X;
-                }
+            // TODO: This is a temporal workaround because of the lack of Span<T> API-s on IPath. We should use MemoryManager.Allocate() here!
+            PointF[] innerBuffer = new PointF[buffer.Length];
+            int count = this.Shape.FindIntersections(start, end, innerBuffer, 0);
 
-                return count;
+            for (int i = 0; i < count; i++)
+            {
+                buffer[i + offset] = innerBuffer[i].X;
             }
+
+            return count;
         }
     }
 }

src/ImageSharp.Drawing/Processors/DrawImageProcessor.cs

@@ -73,12 +73,12 @@ protected override void OnApply(ImageFrame<TPixel> source, Rectangle sourceRecta
             int maxY = Math.Min(this.Location.Y + bounds.Height, sourceRectangle.Bottom);
 
             int width = maxX - minX;
-            using (var amount = new Buffer<float>(width))
+
+            MemoryManager memoryManager = this.Image.GetConfiguration().MemoryManager;
+
+            using (IBuffer<float> amount = memoryManager.Allocate<float>(width))
             {
-                for (int i = 0; i < width; i++)
-                {
-                    amount[i] = this.Opacity;
-                }
+                amount.Span.Fill(this.Opacity);
 
                 Parallel.For(
                     minY,
@@ -88,7 +88,7 @@ protected override void OnApply(ImageFrame<TPixel> source, Rectangle sourceRecta
                         {
                             Span<TPixel> background = source.GetPixelRowSpan(y).Slice(minX, width);
                             Span<TPixel> foreground = targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);
-                            blender.Blend(background, background, foreground, amount);
+                            blender.Blend(memoryManager, background, background, foreground, amount.Span);
                         });
             }
         }

src/ImageSharp.Drawing/Processors/FillProcessor.cs

@@ -66,25 +66,25 @@ protected override void OnApply(ImageFrame<TPixel> source, Rectangle sourceRecta
 
             int width = maxX - minX;
 
-            using (var amount = new Buffer<float>(width))
-            using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(source, sourceRectangle, this.options))
+            using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
+            using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
+                source,
+                sourceRectangle,
+                this.options))
             {
-                    for (int i = 0; i < width; i++)
-                    {
-                        amount[i] = this.options.BlendPercentage;
-                    }
+                amount.Span.Fill(this.options.BlendPercentage);
 
-                    Parallel.For(
+                Parallel.For(
                     minY,
                     maxY,
                     configuration.ParallelOptions,
                     y =>
-                    {
-                        int offsetY = y - startY;
-                        int offsetX = minX - startX;
+                        {
+                            int offsetY = y - startY;
+                            int offsetX = minX - startX;
 
-                        applicator.Apply(amount, offsetX, offsetY);
-                    });
+                            applicator.Apply(amount.Span, offsetX, offsetY);
+                        });
             }
         }
     }