Introduce basic Memory<T> API-s

src/ImageSharp.Drawing/Primitives/Region.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Primitives
@@ -19,7 +20,7 @@ public abstract class Region
         /// Gets the bounding box that entirely surrounds this region.
         /// </summary>
         /// <remarks>
-        /// This should always contains all possible points returned from <see cref="Scan(float, float[], int)"/>.
+        /// This should always contains all possible points returned from <see cref="Scan"/>.
         /// </remarks>
         public abstract Rectangle Bounds { get; }
 
@@ -28,8 +29,8 @@ public abstract class Region
         /// </summary>
         /// <param name="y">The position along the y axis to find intersections.</param>
         /// <param name="buffer">The buffer.</param>
-        /// <param name="offset">The point in the buffer to start setting offset.</param>
+        /// <param name="configuration">A <see cref="Configuration"/> instance in the context of the caller.</param>
         /// <returns>The number of intersections found.</returns>
-        public abstract int Scan(float y, float[] buffer, int offset);
+        public abstract int Scan(float y, Span<float> buffer, Configuration configuration);
     }
 }

src/ImageSharp.Drawing/Primitives/ShapeRegion.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 using SixLabors.Shapes;
 
@@ -39,21 +40,23 @@ public ShapeRegion(IPath shape)
         public override Rectangle Bounds { get; }
 
         /// <inheritdoc/>
-        public override int Scan(float y, float[] buffer, int offset)
+        public override int Scan(float y, Span<float> buffer, Configuration configuration)
         {
             var start = new PointF(this.Bounds.Left - 1, y);
             var end = new PointF(this.Bounds.Right + 1, y);
 
-            // TODO: This is a temporary workaround because of the lack of Span<T> API-s on IPath. We should use MemoryManager.Allocate() here!
-            var innerBuffer = new PointF[buffer.Length];
-            int count = this.Shape.FindIntersections(start, end, innerBuffer, 0);
-
-            for (int i = 0; i < count; i++)
+            using (IBuffer<PointF> tempBuffer = configuration.MemoryAllocator.Allocate<PointF>(buffer.Length))
             {
-                buffer[i + offset] = innerBuffer[i].X;
-            }
+                Span<PointF> innerBuffer = tempBuffer.GetSpan();
+                int count = this.Shape.FindIntersections(start, end, innerBuffer);
 
-            return count;
+                for (int i = 0; i < count; i++)
+                {
+                    buffer[i] = innerBuffer[i].X;
+                }
+
+                return count;
+            }
         }
     }
 }

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

@@ -3,8 +3,8 @@
 
 using System;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.Memory;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Brushes
 {
@@ -65,13 +65,13 @@ 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)
         {
-            MemoryManager memoryManager = this.Target.MemoryManager;
+            MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;
 
-            using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
-            using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
+            using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))
+            using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))
             {
-                Span<float> amountSpan = amountBuffer.Span;
-                Span<TPixel> overlaySpan = overlay.Span;
+                Span<float> amountSpan = amountBuffer.GetSpan();
+                Span<TPixel> overlaySpan = overlay.GetSpan();
 
                 for (int i = 0; i < scanline.Length; i++)
                 {
@@ -88,7 +88,7 @@ internal virtual void Apply(Span<float> scanline, int x, int y)
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
+                this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
             }
         }
     }

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

@@ -3,8 +3,8 @@
 
 using System;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Brushes
@@ -118,11 +118,11 @@ public override void Dispose()
             internal override void Apply(Span<float> scanline, int x, int y)
             {
                 // Create a span for colors
-                using (IBuffer<float> amountBuffer = this.Target.MemoryManager.Allocate<float>(scanline.Length))
-                using (IBuffer<TPixel> overlay = this.Target.MemoryManager.Allocate<TPixel>(scanline.Length))
+                using (IBuffer<float> amountBuffer = this.Target.MemoryAllocator.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = this.Target.MemoryAllocator.Allocate<TPixel>(scanline.Length))
                 {
-                    Span<float> amountSpan = amountBuffer.Span;
-                    Span<TPixel> overlaySpan = overlay.Span;
+                    Span<float> amountSpan = amountBuffer.GetSpan();
+                    Span<TPixel> overlaySpan = overlay.GetSpan();
 
                     int sourceY = (y - this.offsetY) % this.yLength;
                     int offsetX = x - this.offsetX;
@@ -138,7 +138,7 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(this.source.MemoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(this.source.MemoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

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

@@ -4,9 +4,9 @@
 using System;
 using System.Numerics;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Primitives;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Brushes
@@ -151,13 +151,13 @@ public override void Dispose()
             internal override void Apply(Span<float> scanline, int x, int y)
             {
                 int patternY = y % this.pattern.Rows;
-                MemoryManager memoryManager = this.Target.MemoryManager;
+                MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;
 
-                using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
-                using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
+                using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))
                 {
-                    Span<float> amountSpan = amountBuffer.Span;
-                    Span<TPixel> overlaySpan = overlay.Span;
+                    Span<float> amountSpan = amountBuffer.GetSpan();
+                    Span<TPixel> overlaySpan = overlay.GetSpan();
 
                     for (int i = 0; i < scanline.Length; i++)
                     {
@@ -168,7 +168,7 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

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

@@ -4,8 +4,8 @@
 using System;
 using System.Numerics;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Brushes
@@ -136,13 +136,13 @@ public override void Dispose()
             /// <inheritdoc />
             internal override void Apply(Span<float> scanline, int x, int y)
             {
-                MemoryManager memoryManager = this.Target.MemoryManager;
+                MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;
 
-                using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
-                using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))
+                using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))
+                using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))
                 {
-                    Span<float> amountSpan = amountBuffer.Span;
-                    Span<TPixel> overlaySpan = overlay.Span;
+                    Span<float> amountSpan = amountBuffer.GetSpan();
+                    Span<TPixel> overlaySpan = overlay.GetSpan();
 
                     for (int i = 0; i < scanline.Length; i++)
                     {
@@ -156,7 +156,7 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
                 }
             }
         }

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

@@ -3,8 +3,8 @@
 
 using System;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Brushes
@@ -58,8 +58,8 @@ private class SolidBrushApplicator : BrushApplicator<TPixel>
             public SolidBrushApplicator(ImageFrame<TPixel> source, TPixel color, GraphicsOptions options)
                 : base(source, options)
             {
-                this.Colors = source.MemoryManager.Allocate<TPixel>(source.Width);
-                this.Colors.Span.Fill(color);
+                this.Colors = source.MemoryAllocator.Allocate<TPixel>(source.Width);
+                this.Colors.GetSpan().Fill(color);
             }
 
             /// <summary>
@@ -75,7 +75,7 @@ public SolidBrushApplicator(ImageFrame<TPixel> source, TPixel color, GraphicsOpt
             /// <returns>
             /// The color
             /// </returns>
-            internal override TPixel this[int x, int y] => this.Colors.Span[x];
+            internal override TPixel this[int x, int y] => this.Colors.GetSpan()[x];
 
             /// <inheritdoc />
             public override void Dispose()
@@ -88,24 +88,24 @@ internal override void Apply(Span<float> scanline, int x, int y)
             {
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
 
-                MemoryManager memoryManager = this.Target.MemoryManager;
+                MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;
 
                 if (this.Options.BlendPercentage == 1f)
                 {
-                    this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.Span, scanline);
+                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), scanline);
                 }
                 else
                 {
-                    using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))
+                    using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))
                     {
-                        Span<float> amountSpan = amountBuffer.Span;
+                        Span<float> amountSpan = amountBuffer.GetSpan();
 
                         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(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);
                     }
                 }
             }

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

@@ -4,9 +4,9 @@
 using System;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors;
+using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Processors
@@ -133,11 +133,11 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
 
             int width = maxX - minX;
 
-            MemoryManager memoryManager = this.Image.GetConfiguration().MemoryManager;
+            MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator;
 
-            using (IBuffer<float> amount = memoryManager.Allocate<float>(width))
+            using (IBuffer<float> amount = memoryAllocator.Allocate<float>(width))
             {
-                amount.Span.Fill(this.Opacity);
+                amount.GetSpan().Fill(this.Opacity);
 
                 Parallel.For(
                     minY,
@@ -147,7 +147,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
                         {
                             Span<TPixel> background = source.GetPixelRowSpan(y).Slice(minX, width);
                             Span<TPixel> foreground = targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);
-                            blender.Blend(memoryManager, background, background, foreground, amount.Span);
+                            blender.Blend(memoryAllocator, background, background, foreground, amount.GetSpan());
                         });
             }
         }

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

@@ -4,10 +4,10 @@
 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.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Drawing.Processors
@@ -77,13 +77,13 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
                     startY = 0;
                 }
 
-                using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))
+                using (IBuffer<float> amount = source.MemoryAllocator.Allocate<float>(width))
                 using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(
                     source,
                     sourceRectangle,
                     this.options))
                 {
-                    amount.Span.Fill(1f);
+                    amount.GetSpan().Fill(1f);
 
                     Parallel.For(
                         minY,
@@ -94,7 +94,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
                                 int offsetY = y - startY;
                                 int offsetX = minX - startX;
 
-                                applicator.Apply(amount.Span, offsetX, offsetY);
+                                applicator.Apply(amount.GetSpan(), offsetX, offsetY);
                             });
                 }
             }