RENAME: MemoryManager -> MemoryAllocator

antonfirsov · antonfirsov · commit 1c6283e78d92 · 2018-06-10T02:37:19.000+02:00
diff --git a/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs b/src/ImageSharp.Drawing/Primitives/ShapeRegion.cs
@@ -45,7 +45,7 @@ public override int Scan(float y, Span<float> buffer, Configuration configuratio
             var start = new PointF(this.Bounds.Left - 1, y);
             var end = new PointF(this.Bounds.Right + 1, y);
 
-            using (IBuffer<PointF> tempBuffer = configuration.MemoryManager.Allocate<PointF>(buffer.Length))
+            using (IBuffer<PointF> tempBuffer = configuration.MemoryAllocator.Allocate<PointF>(buffer.Length))
             {
                 Span<PointF> innerBuffer = tempBuffer.GetSpan();
                 int count = this.Shape.FindIntersections(start, end, innerBuffer);
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Brushes/BrushApplicator.cs b/src/ImageSharp.Drawing/Processing/Drawing/Brushes/BrushApplicator.cs
@@ -65,10 +65,10 @@ 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.GetSpan();
                 Span<TPixel> overlaySpan = overlay.GetSpan();
@@ -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);
             }
         }
     }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Brushes/ImageBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Drawing/Brushes/ImageBrush{TPixel}.cs
@@ -118,8 +118,8 @@ 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.GetSpan();
                     Span<TPixel> overlaySpan = overlay.GetSpan();
@@ -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);
                 }
             }
         }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Brushes/PatternBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Drawing/Brushes/PatternBrush{TPixel}.cs
@@ -151,10 +151,10 @@ 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.GetSpan();
                     Span<TPixel> overlaySpan = overlay.GetSpan();
@@ -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);
                 }
             }
         }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Brushes/RecolorBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Drawing/Brushes/RecolorBrush{TPixel}.cs
@@ -136,10 +136,10 @@ 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.GetSpan();
                     Span<TPixel> overlaySpan = overlay.GetSpan();
@@ -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);
                 }
             }
         }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Brushes/SolidBrush{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Drawing/Brushes/SolidBrush{TPixel}.cs
@@ -58,7 +58,7 @@ 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 = source.MemoryAllocator.Allocate<TPixel>(source.Width);
                 this.Colors.GetSpan().Fill(color);
             }
 
@@ -88,15 +88,15 @@ 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.GetSpan(), 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.GetSpan();
 
@@ -105,7 +105,7 @@ internal override void Apply(Span<float> scanline, int x, int y)
                             amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
                         }
 
-                        this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);
+                        this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);
                     }
                 }
             }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Processors/DrawImageProcessor.cs b/src/ImageSharp.Drawing/Processing/Drawing/Processors/DrawImageProcessor.cs
@@ -133,9 +133,9 @@ 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.GetSpan().Fill(this.Opacity);
 
@@ -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.GetSpan());
+                            blender.Blend(memoryAllocator, background, background, foreground, amount.GetSpan());
                         });
             }
         }
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Processors/FillProcessor.cs b/src/ImageSharp.Drawing/Processing/Drawing/Processors/FillProcessor.cs
@@ -77,7 +77,7 @@ 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,
diff --git a/src/ImageSharp.Drawing/Processing/Drawing/Processors/FillRegionProcessor.cs b/src/ImageSharp.Drawing/Processing/Drawing/Processors/FillRegionProcessor.cs
@@ -96,8 +96,8 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
             using (BrushApplicator<TPixel> applicator = this.Brush.CreateApplicator(source, rect, this.Options))
             {
                 int scanlineWidth = maxX - minX;
-                using (IBuffer<float> bBuffer = source.MemoryManager.Allocate<float>(maxIntersections))
-                using (IBuffer<float> bScanline = source.MemoryManager.Allocate<float>(scanlineWidth))
+                using (IBuffer<float> bBuffer = source.MemoryAllocator.Allocate<float>(maxIntersections))
+                using (IBuffer<float> bScanline = source.MemoryAllocator.Allocate<float>(scanlineWidth))
                 {
                     bool scanlineDirty = true;
                     float subpixelFraction = 1f / subpixelCount;
diff --git a/tests/ImageSharp.Tests/FakeImageOperationsProvider.cs b/tests/ImageSharp.Tests/FakeImageOperationsProvider.cs
@@ -55,7 +55,7 @@ public FakeImageOperations(Image<TPixel> source, bool mutate)
 
             public List<AppliedOperation> Applied { get; } = new List<AppliedOperation>();
 
-            public MemoryManager MemoryManager => this.Source.GetConfiguration().MemoryManager;
+            public MemoryAllocator MemoryAllocator => this.Source.GetConfiguration().MemoryAllocator;
 
             public Image<TPixel> Apply()
             {

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public override int Scan(float y, Span<float> buffer, Configuration configuratio`
`45`	`45`	`var start = new PointF(this.Bounds.Left - 1, y);`
`46`	`46`	`var end = new PointF(this.Bounds.Right + 1, y);`
`47`	`47`
`48`		`- using (IBuffer<PointF> tempBuffer = configuration.MemoryManager.Allocate<PointF>(buffer.Length))`
	`48`	`+ using (IBuffer<PointF> tempBuffer = configuration.MemoryAllocator.Allocate<PointF>(buffer.Length))`
`49`	`49`	`{`
`50`	`50`	`Span<PointF> innerBuffer = tempBuffer.GetSpan();`
`51`	`51`	`int count = this.Shape.FindIntersections(start, end, innerBuffer);`
Original file line number	Diff line number	Diff line change
`@@ -65,10 +65,10 @@ internal BrushApplicator(ImageFrame<TPixel> target, GraphicsOptions options)`
`65`	`65`	`/// <remarks>scanlineBuffer will be > scanlineWidth but provide and offset in case we want to share a larger buffer across runs.</remarks>`
`66`	`66`	`internal virtual void Apply(Span<float> scanline, int x, int y)`
`67`	`67`	`{`
`68`		`- MemoryManager memoryManager = this.Target.MemoryManager;`
	`68`	`+ MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;`
`69`	`69`
`70`		`- using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))`
`71`		`- using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))`
	`70`	`+ using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))`
	`71`	`+ using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))`
`72`	`72`	`{`
`73`	`73`	`Span<float> amountSpan = amountBuffer.GetSpan();`
`74`	`74`	`Span<TPixel> overlaySpan = overlay.GetSpan();`
`@@ -88,7 +88,7 @@ internal virtual void Apply(Span<float> scanline, int x, int y)`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
`91`		`- this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);`
	`91`	`+ this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,8 @@ public override void Dispose()`
`118`	`118`	`internal override void Apply(Span<float> scanline, int x, int y)`
`119`	`119`	`{`
`120`	`120`	`// Create a span for colors`
`121`		`- using (IBuffer<float> amountBuffer = this.Target.MemoryManager.Allocate<float>(scanline.Length))`
`122`		`- using (IBuffer<TPixel> overlay = this.Target.MemoryManager.Allocate<TPixel>(scanline.Length))`
	`121`	`+ using (IBuffer<float> amountBuffer = this.Target.MemoryAllocator.Allocate<float>(scanline.Length))`
	`122`	`+ using (IBuffer<TPixel> overlay = this.Target.MemoryAllocator.Allocate<TPixel>(scanline.Length))`
`123`	`123`	`{`
`124`	`124`	`Span<float> amountSpan = amountBuffer.GetSpan();`
`125`	`125`	`Span<TPixel> overlaySpan = overlay.GetSpan();`
`@@ -138,7 +138,7 @@ internal override void Apply(Span<float> scanline, int x, int y)`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
`141`		`- this.Blender.Blend(this.source.MemoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);`
	`141`	`+ this.Blender.Blend(this.source.MemoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,10 +151,10 @@ public override void Dispose()`
`151`	`151`	`internal override void Apply(Span<float> scanline, int x, int y)`
`152`	`152`	`{`
`153`	`153`	`int patternY = y % this.pattern.Rows;`
`154`		`- MemoryManager memoryManager = this.Target.MemoryManager;`
	`154`	`+ MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;`
`155`	`155`
`156`		`- using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))`
`157`		`- using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))`
	`156`	`+ using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))`
	`157`	`+ using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))`
`158`	`158`	`{`
`159`	`159`	`Span<float> amountSpan = amountBuffer.GetSpan();`
`160`	`160`	`Span<TPixel> overlaySpan = overlay.GetSpan();`
`@@ -168,7 +168,7 @@ internal override void Apply(Span<float> scanline, int x, int y)`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
`171`		`- this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);`
	`171`	`+ this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,10 +136,10 @@ public override void Dispose()`
`136`	`136`	`/// <inheritdoc />`
`137`	`137`	`internal override void Apply(Span<float> scanline, int x, int y)`
`138`	`138`	`{`
`139`		`- MemoryManager memoryManager = this.Target.MemoryManager;`
	`139`	`+ MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;`
`140`	`140`
`141`		`- using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))`
`142`		`- using (IBuffer<TPixel> overlay = memoryManager.Allocate<TPixel>(scanline.Length))`
	`141`	`+ using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))`
	`142`	`+ using (IBuffer<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length))`
`143`	`143`	`{`
`144`	`144`	`Span<float> amountSpan = amountBuffer.GetSpan();`
`145`	`145`	`Span<TPixel> overlaySpan = overlay.GetSpan();`
`@@ -156,7 +156,7 @@ internal override void Apply(Span<float> scanline, int x, int y)`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
`159`		`- this.Blender.Blend(memoryManager, destinationRow, destinationRow, overlaySpan, amountSpan);`
	`159`	`+ this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ private class SolidBrushApplicator : BrushApplicator<TPixel>`
`58`	`58`	`public SolidBrushApplicator(ImageFrame<TPixel> source, TPixel color, GraphicsOptions options)`
`59`	`59`	`: base(source, options)`
`60`	`60`	`{`
`61`		`- this.Colors = source.MemoryManager.Allocate<TPixel>(source.Width);`
	`61`	`+ this.Colors = source.MemoryAllocator.Allocate<TPixel>(source.Width);`
`62`	`62`	`this.Colors.GetSpan().Fill(color);`
`63`	`63`	`}`
`64`	`64`
`@@ -88,15 +88,15 @@ internal override void Apply(Span<float> scanline, int x, int y)`
`88`	`88`	`{`
`89`	`89`	`Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
`90`	`90`
`91`		`- MemoryManager memoryManager = this.Target.MemoryManager;`
	`91`	`+ MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;`
`92`	`92`
`93`	`93`	`if (this.Options.BlendPercentage == 1f)`
`94`	`94`	`{`
`95`		`- this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.GetSpan(), scanline);`
	`95`	`+ this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), scanline);`
`96`	`96`	`}`
`97`	`97`	`else`
`98`	`98`	`{`
`99`		`- using (IBuffer<float> amountBuffer = memoryManager.Allocate<float>(scanline.Length))`
	`99`	`+ using (IBuffer<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length))`
`100`	`100`	`{`
`101`	`101`	`Span<float> amountSpan = amountBuffer.GetSpan();`
`102`	`102`
`@@ -105,7 +105,7 @@ internal override void Apply(Span<float> scanline, int x, int y)`
`105`	`105`	`amountSpan[i] = scanline[i] * this.Options.BlendPercentage;`
`106`	`106`	`}`
`107`	`107`
`108`		`- this.Blender.Blend(memoryManager, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);`
	`108`	`+ this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,9 +133,9 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source`
`133`	`133`
`134`	`134`	`int width = maxX - minX;`
`135`	`135`
`136`		`- MemoryManager memoryManager = this.Image.GetConfiguration().MemoryManager;`
	`136`	`+ MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator;`
`137`	`137`
`138`		`- using (IBuffer<float> amount = memoryManager.Allocate<float>(width))`
	`138`	`+ using (IBuffer<float> amount = memoryAllocator.Allocate<float>(width))`
`139`	`139`	`{`
`140`	`140`	`amount.GetSpan().Fill(this.Opacity);`
`141`	`141`
`@@ -147,7 +147,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source`
`147`	`147`	`{`
`148`	`148`	`Span<TPixel> background = source.GetPixelRowSpan(y).Slice(minX, width);`
`149`	`149`	`Span<TPixel> foreground = targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);`
`150`		`- blender.Blend(memoryManager, background, background, foreground, amount.GetSpan());`
	`150`	`+ blender.Blend(memoryAllocator, background, background, foreground, amount.GetSpan());`
`151`	`151`	`});`
`152`	`152`	`}`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source`
`77`	`77`	`startY = 0;`
`78`	`78`	`}`
`79`	`79`
`80`		`- using (IBuffer<float> amount = source.MemoryManager.Allocate<float>(width))`
	`80`	`+ using (IBuffer<float> amount = source.MemoryAllocator.Allocate<float>(width))`
`81`	`81`	`using (BrushApplicator<TPixel> applicator = this.brush.CreateApplicator(`
`82`	`82`	`source,`
`83`	`83`	`sourceRectangle,`
Original file line number	Diff line number	Diff line change
`@@ -96,8 +96,8 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source`
`96`	`96`	`using (BrushApplicator<TPixel> applicator = this.Brush.CreateApplicator(source, rect, this.Options))`
`97`	`97`	`{`
`98`	`98`	`int scanlineWidth = maxX - minX;`
`99`		`- using (IBuffer<float> bBuffer = source.MemoryManager.Allocate<float>(maxIntersections))`
`100`		`- using (IBuffer<float> bScanline = source.MemoryManager.Allocate<float>(scanlineWidth))`
	`99`	`+ using (IBuffer<float> bBuffer = source.MemoryAllocator.Allocate<float>(maxIntersections))`
	`100`	`+ using (IBuffer<float> bScanline = source.MemoryAllocator.Allocate<float>(scanlineWidth))`
`101`	`101`	`{`
`102`	`102`	`bool scanlineDirty = true;`
`103`	`103`	`float subpixelFraction = 1f / subpixelCount;`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public FakeImageOperations(Image<TPixel> source, bool mutate)`
`55`	`55`
`56`	`56`	`public List<AppliedOperation> Applied { get; } = new List<AppliedOperation>();`
`57`	`57`
`58`		`- public MemoryManager MemoryManager => this.Source.GetConfiguration().MemoryManager;`
	`58`	`+ public MemoryAllocator MemoryAllocator => this.Source.GetConfiguration().MemoryAllocator;`
`59`	`59`
`60`	`60`	`public Image<TPixel> Apply()`
`61`	`61`	`{`