Merge pull request #186 from SixLabors/js/version-bump

JimBobSquarePants · web-flow · commit 0ccea4d5826e · 2021-12-22T12:44:51.000+11:00
Update references
diff --git a/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj b/src/ImageSharp.Drawing/ImageSharp.Drawing.csproj
@@ -12,16 +12,16 @@
     <PackageProjectUrl>$(RepositoryUrl)</PackageProjectUrl>
     <PackageTags>Image Draw Shape Path Font</PackageTags>
     <Description>An extension to ImageSharp that allows the drawing of images, paths, and text.</Description>
-    <TargetFrameworks>netcoreapp3.1;netcoreapp2.1;netstandard2.1;netstandard2.0;netstandard1.3;net472</TargetFrameworks>
+    <TargetFrameworks>netcoreapp3.1;netcoreapp2.1;netstandard2.1;netstandard2.0;net472</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
     <None Include="..\..\shared-infrastructure\branding\icons\imagesharp.drawing\sixlabors.imagesharp.drawing.128.png" Pack="true" PackagePath="" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="SixLabors.Fonts" Version="1.0.0-beta15.23" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="2.0.0-alpha.0.123" />
+    <PackageReference Include="SixLabors.Fonts" Version="1.0.0-beta15.24" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="2.0.0-alpha.0.142" />
   </ItemGroup>
 
   <Import Project="..\..\shared-infrastructure\src\SharedInfrastructure\SharedInfrastructure.projitems" Label="Shared" />
diff --git a/src/ImageSharp.Drawing/Processing/GradientBrush.cs b/src/ImageSharp.Drawing/Processing/GradientBrush.cs
@@ -159,7 +159,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                     }
                 }
 
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlays, amounts);
             }
 
diff --git a/src/ImageSharp.Drawing/Processing/ImageBrush.cs b/src/ImageSharp.Drawing/Processing/ImageBrush.cs
@@ -162,7 +162,7 @@ public override void Apply(Span<float> scanline, int x, int y)
 
                 int offsetX = x - this.offsetX;
                 int sourceY = ((y - this.offsetY) % this.sourceRegion.Width) + this.sourceRegion.Y;
-                Span<TPixel> sourceRow = this.sourceFrame.GetPixelRowSpan(sourceY);
+                Span<TPixel> sourceRow = this.sourceFrame.PixelBuffer.DangerousGetRowSpan(sourceY);
 
                 for (int i = 0; i < scanline.Length; i++)
                 {
@@ -173,7 +173,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                     overlaySpan[i] = sourceRow[sourceX];
                 }
 
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(
                     this.Configuration,
                     destinationRow,
diff --git a/src/ImageSharp.Drawing/Processing/PathGradientBrush.cs b/src/ImageSharp.Drawing/Processing/PathGradientBrush.cs
@@ -302,7 +302,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                     }
                 }
 
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlays, amounts);
             }
 
diff --git a/src/ImageSharp.Drawing/Processing/PatternBrush.cs b/src/ImageSharp.Drawing/Processing/PatternBrush.cs
@@ -159,7 +159,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                     overlays[i] = this.pattern[patternY, patternX];
                 }
 
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(
                     this.Configuration,
                     destinationRow,
diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillPathProcessor{TPixel}.cs
@@ -121,7 +121,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                             {
                                 if (hasOnes)
                                 {
-                                    source.GetPixelRowSpan(y).Slice(minX, scanlineWidth).Fill(solidBrushColor);
+                                    source.PixelBuffer.DangerousGetRowSpan(y).Slice(minX, scanlineWidth).Fill(solidBrushColor);
                                 }
 
                                 continue;
diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/FillProcessor{TPixel}.cs
@@ -102,7 +102,7 @@ public void Invoke(in RowInterval rows)
             {
                 for (int y = rows.Min; y < rows.Max; y++)
                 {
-                    this.source.GetPixelRowSpan(y).Slice(this.bounds.X, this.bounds.Width).Fill(this.color);
+                    this.source.PixelBuffer.DangerousGetRowSpan(y).Slice(this.bounds.X, this.bounds.Width).Fill(this.color);
                 }
             }
         }
diff --git a/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor{TPixel}.cs b/src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor{TPixel}.cs
@@ -127,7 +127,7 @@ void Draw(List<DrawingOperation> operations, IBrush brush)
                             for (int row = firstRow; row < end; row++)
                             {
                                 int y = startY + row;
-                                Span<float> span = buffer.GetRowSpan(row).Slice(offsetSpan);
+                                Span<float> span = buffer.DangerousGetRowSpan(row).Slice(offsetSpan);
                                 currentApp.Apply(span, startX, y);
                             }
                         }
@@ -372,7 +372,7 @@ private Buffer2D<float> Render(IPath path)
                 {
                     while (scanner.MoveToNextPixelLine())
                     {
-                        Span<float> scanline = fullBuffer.GetRowSpan(scanner.PixelLineY);
+                        Span<float> scanline = fullBuffer.DangerousGetRowSpan(scanner.PixelLineY);
                         bool scanlineDirty = scanner.ScanCurrentPixelLineInto(0, xOffset, scanline);
 
                         if (scanlineDirty && !graphicsOptions.Antialias)
diff --git a/src/ImageSharp.Drawing/Processing/RecolorBrush.cs b/src/ImageSharp.Drawing/Processing/RecolorBrush.cs
@@ -143,7 +143,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                     overlays[i] = this[offsetX, y];
                 }
 
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(
                     this.Configuration,
                     destinationRow,
diff --git a/src/ImageSharp.Drawing/Processing/SolidBrush.cs b/src/ImageSharp.Drawing/Processing/SolidBrush.cs
@@ -73,7 +73,7 @@ public SolidBrushApplicator(
             /// <inheritdoc />
             public override void Apply(Span<float> scanline, int x, int y)
             {
-                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x);
+                Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x);
 
                 // Constrain the spans to each other
                 if (destinationRow.Length > scanline.Length)
diff --git a/tests/ImageSharp.Drawing.Tests/ConfigurationTests.cs b/tests/ImageSharp.Drawing.Tests/ConfigurationTests.cs
@@ -20,7 +20,7 @@ public class ConfigurationTests
 
         public Configuration DefaultConfiguration { get; }
 
-        private readonly int expectedDefaultConfigurationCount = 7;
+        private readonly int expectedDefaultConfigurationCount = 8;
 
         public ConfigurationTests()
         {
diff --git a/tests/ImageSharp.Drawing.Tests/Drawing/FillLinearGradientBrushTests.cs b/tests/ImageSharp.Drawing.Tests/Drawing/FillLinearGradientBrushTests.cs
@@ -210,7 +210,7 @@ static void VerifyAllRowsAreUnicolor(Image<TPixel> image)
             {
                 for (int y = 0; y < image.Height; y++)
                 {
-                    Span<TPixel> row = image.GetPixelRowSpan(y);
+                    Span<TPixel> row = image.GetRootFramePixelBuffer().DangerousGetRowSpan(y);
                     TPixel firstColorOfRow = row[0];
                     foreach (TPixel p in row)
                     {
diff --git a/tests/ImageSharp.Drawing.Tests/TestFormat.cs b/tests/ImageSharp.Drawing.Tests/TestFormat.cs
@@ -252,7 +252,7 @@ public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, Cancellation
 
         private struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
         {
-            public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new PixelOperations<TestPixelForAgnosticDecode>();
+            public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 
             public void FromScaledVector4(Vector4 vector)
             {
@@ -318,6 +318,10 @@ public void FromRgba64(Rgba64 source)
             {
             }
 
+            public void FromAbgr32(Abgr32 source)
+            {
+            }
+
             public bool Equals(TestPixelForAgnosticDecode other) => false;
         }
     }
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs
@@ -32,8 +32,8 @@ public override ImageSimilarityReport<TPixelA, TPixelB> CompareImagesOrFrames<TP
 
             for (int y = 0; y < actual.Height; y++)
             {
-                Span<TPixelA> aSpan = expected.GetPixelRowSpan(y);
-                Span<TPixelB> bSpan = actual.GetPixelRowSpan(y);
+                Span<TPixelA> aSpan = expected.PixelBuffer.DangerousGetRowSpan(y);
+                Span<TPixelB> bSpan = actual.PixelBuffer.DangerousGetRowSpan(y);
 
                 PixelOperations<TPixelA>.Instance.ToRgba64(configuration, aSpan, aBuffer);
                 PixelOperations<TPixelB>.Instance.ToRgba64(configuration, bSpan, bBuffer);
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs
@@ -75,8 +75,8 @@ public override ImageSimilarityReport<TPixelA, TPixelB> CompareImagesOrFrames<TP
 
             for (int y = 0; y < actual.Height; y++)
             {
-                Span<TPixelA> aSpan = expected.GetPixelRowSpan(y);
-                Span<TPixelB> bSpan = actual.GetPixelRowSpan(y);
+                Span<TPixelA> aSpan = expected.PixelBuffer.DangerousGetRowSpan(y);
+                Span<TPixelB> bSpan = actual.PixelBuffer.DangerousGetRowSpan(y);
 
                 PixelOperations<TPixelA>.Instance.ToRgba64(configuration, aSpan, aBuffer);
                 PixelOperations<TPixelB>.Instance.ToRgba64(configuration, bSpan, bBuffer);
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Numerics;
+using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Drawing.Tests
 {
@@ -38,18 +39,18 @@ public override Image<TPixel> GetImage()
 
                 int midY = this.Height / 2;
                 int midX = this.Width / 2;
-
+                Buffer2D<TPixel> imageBuffer = result.GetRootFramePixelBuffer();
                 for (int y = 0; y < midY; y++)
                 {
-                    Span<TPixel> row = result.GetPixelRowSpan(y);
+                    Span<TPixel> row = imageBuffer.DangerousGetRowSpan(y);
 
                     row.Slice(0, midX).Fill(topLeftColor);
                     row.Slice(midX, this.Width - midX).Fill(topRightColor);
                 }
 
                 for (int y = midY; y < this.Height; y++)
                 {
-                    Span<TPixel> row = result.GetPixelRowSpan(y);
+                    Span<TPixel> row = imageBuffer.DangerousGetRowSpan(y);
 
                     row.Slice(0, midX).Fill(bottomLeftColor);
                     row.Slice(midX, this.Width - midX).Fill(bottomRightColor);
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/ReferenceCodecs/SystemDrawingBridge.cs
@@ -47,14 +47,14 @@ internal static unsafe Image<TPixel> From32bppArgbSystemDrawingBitmap<TPixel>(Bi
                 long destRowByteCount = w * sizeof(Bgra32);
 
                 Configuration configuration = image.GetConfiguration();
-
-                using (IMemoryOwner<Bgra32> workBuffer = Configuration.Default.MemoryAllocator.Allocate<Bgra32>(w))
+                image.ProcessPixelRows(accessor =>
                 {
+                    using IMemoryOwner<Bgra32> workBuffer = Configuration.Default.MemoryAllocator.Allocate<Bgra32>(w);
                     fixed (Bgra32* destPtr = &workBuffer.GetReference())
                     {
                         for (int y = 0; y < h; y++)
                         {
-                            Span<TPixel> row = image.Frames.RootFrame.GetPixelRowSpan(y);
+                            Span<TPixel> row = accessor.GetRowSpan(y);
 
                             byte* sourcePtr = sourcePtrBase + (data.Stride * y);
 
@@ -65,7 +65,7 @@ internal static unsafe Image<TPixel> From32bppArgbSystemDrawingBitmap<TPixel>(Bi
                                 row);
                         }
                     }
-                }
+                });
             }
             finally
             {
@@ -106,20 +106,19 @@ internal static unsafe Image<TPixel> From24bppRgbSystemDrawingBitmap<TPixel>(Bit
                 long destRowByteCount = w * sizeof(Bgr24);
 
                 Configuration configuration = image.GetConfiguration();
+                Buffer2D<TPixel> imageBuffer = image.GetRootFramePixelBuffer();
 
-                using (IMemoryOwner<Bgr24> workBuffer = Configuration.Default.MemoryAllocator.Allocate<Bgr24>(w))
+                using IMemoryOwner<Bgr24> workBuffer = Configuration.Default.MemoryAllocator.Allocate<Bgr24>(w);
+                fixed (Bgr24* destPtr = &workBuffer.GetReference())
                 {
-                    fixed (Bgr24* destPtr = &workBuffer.GetReference())
+                    for (int y = 0; y < h; y++)
                     {
-                        for (int y = 0; y < h; y++)
-                        {
-                            Span<TPixel> row = image.Frames.RootFrame.GetPixelRowSpan(y);
+                        Span<TPixel> row = imageBuffer.DangerousGetRowSpan(y);
 
-                            byte* sourcePtr = sourcePtrBase + (data.Stride * y);
+                        byte* sourcePtr = sourcePtrBase + (data.Stride * y);
 
-                            Buffer.MemoryCopy(sourcePtr, destPtr, destRowByteCount, sourceRowByteCount);
-                            PixelOperations<TPixel>.Instance.FromBgr24(configuration, workBuffer.GetSpan().Slice(0, w), row);
-                        }
+                        Buffer.MemoryCopy(sourcePtr, destPtr, destRowByteCount, sourceRowByteCount);
+                        PixelOperations<TPixel>.Instance.FromBgr24(configuration, workBuffer.GetSpan().Slice(0, w), row);
                     }
                 }
             }
@@ -147,21 +146,21 @@ internal static unsafe Bitmap To32bppArgbSystemDrawingBitmap<TPixel>(Image<TPixe
 
                 long destRowByteCount = data.Stride;
                 long sourceRowByteCount = w * sizeof(Bgra32);
-
-                using (IMemoryOwner<Bgra32> workBuffer = image.GetConfiguration().MemoryAllocator.Allocate<Bgra32>(w))
+                image.ProcessPixelRows(accessor =>
                 {
+                    using IMemoryOwner<Bgra32> workBuffer = image.GetConfiguration().MemoryAllocator.Allocate<Bgra32>(w);
                     fixed (Bgra32* sourcePtr = &workBuffer.GetReference())
                     {
                         for (int y = 0; y < h; y++)
                         {
-                            Span<TPixel> row = image.Frames.RootFrame.GetPixelRowSpan(y);
+                            Span<TPixel> row = accessor.GetRowSpan(y);
                             PixelOperations<TPixel>.Instance.ToBgra32(configuration, row, workBuffer.GetSpan());
                             byte* destPtr = destPtrBase + (data.Stride * y);
 
                             Buffer.MemoryCopy(sourcePtr, destPtr, destRowByteCount, sourceRowByteCount);
                         }
                     }
-                }
+                });
             }
             finally
             {
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/TestImageExtensions.cs
@@ -388,12 +388,9 @@ public static Image<TPixel> ComparePixelBufferTo<TPixel>(
             Span<TPixel> expectedPixels)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            Assert.True(image.TryGetSinglePixelSpan(out Span<TPixel> actual));
-            Assert.True(expectedPixels.Length == actual.Length, "Buffer sizes are not equal!");
-
-            for (int i = 0; i < expectedPixels.Length; i++)
+            foreach (ImageFrame<TPixel> imageFrame in image.Frames)
             {
-                Assert.True(expectedPixels[i].Equals(actual[i]), $"Pixels are different on position {i}!");
+                imageFrame.ComparePixelBufferTo(expectedPixels);
             }
 
             return image;
@@ -450,7 +447,8 @@ public static Image<TPixel> ComparePixelBufferTo<TPixel>(this Image<TPixel> imag
         public static ImageFrame<TPixel> ComparePixelBufferTo<TPixel>(this ImageFrame<TPixel> imageFrame, TPixel expectedPixel)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            Assert.True(imageFrame.TryGetSinglePixelSpan(out Span<TPixel> actualPixels));
+            Assert.True(imageFrame.DangerousTryGetSinglePixelMemory(out Memory<TPixel> actual));
+            Span<TPixel> actualPixels = actual.Span;
 
             for (int i = 0; i < actualPixels.Length; i++)
             {
@@ -465,7 +463,8 @@ public static ImageFrame<TPixel> ComparePixelBufferTo<TPixel>(
                     Span<TPixel> expectedPixels)
                     where TPixel : unmanaged, IPixel<TPixel>
         {
-            Assert.True(image.TryGetSinglePixelSpan(out Span<TPixel> actualPixels));
+            Assert.True(image.DangerousTryGetSinglePixelMemory(out Memory<TPixel> actual));
+            Span<TPixel> actualPixels = actual.Span;
 
             Assert.True(expectedPixels.Length == actualPixels.Length, "Buffer sizes are not equal!");
 
@@ -647,7 +646,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                 Rectangle sourceRectangle = this.SourceRectangle;
                 Configuration configuration = this.Configuration;
 
-                var operation = new RowIntervalOperation(configuration, sourceRectangle, source);
+                var operation = new RowIntervalOperation(configuration, sourceRectangle, source.PixelBuffer);
                 ParallelRowIterator.IterateRowIntervals<RowIntervalOperation, Vector4>(
                     configuration,
                     sourceRectangle,
@@ -658,10 +657,10 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
             {
                 private readonly Configuration configuration;
                 private readonly Rectangle bounds;
-                private readonly ImageFrame<TPixel> source;
+                private readonly Buffer2D<TPixel> source;
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public RowIntervalOperation(Configuration configuration, Rectangle bounds, ImageFrame<TPixel> source)
+                public RowIntervalOperation(Configuration configuration, Rectangle bounds, Buffer2D<TPixel> source)
                 {
                     this.configuration = configuration;
                     this.bounds = bounds;
@@ -674,7 +673,7 @@ public void Invoke(in RowInterval rows, Span<Vector4> span)
                 {
                     for (int y = rows.Min; y < rows.Max; y++)
                     {
-                        Span<TPixel> rowSpan = this.source.GetPixelRowSpan(y).Slice(this.bounds.Left, this.bounds.Width);
+                        Span<TPixel> rowSpan = this.source.DangerousGetRowSpan(y).Slice(this.bounds.Left, this.bounds.Width);
                         PixelOperations<TPixel>.Instance.ToVector4(this.configuration, rowSpan, span, PixelConversionModifiers.Scale);
                         for (int i = 0; i < span.Length; i++)
                         {
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/TestMemoryAllocator.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/TestMemoryAllocator.cs
diff --git a/tests/ImageSharp.Drawing.Tests/TestUtilities/TestUtils.cs b/tests/ImageSharp.Drawing.Tests/TestUtilities/TestUtils.cs

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ public override void Apply(Span<float> scanline, int x, int y)`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`162`		`- Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
	`162`	`+ Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);`
`163`	`163`	`this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlays, amounts);`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ public override void Apply(Span<float> scanline, int x, int y)`
`162`	`162`
`163`	`163`	`int offsetX = x - this.offsetX;`
`164`	`164`	`int sourceY = ((y - this.offsetY) % this.sourceRegion.Width) + this.sourceRegion.Y;`
`165`		`- Span<TPixel> sourceRow = this.sourceFrame.GetPixelRowSpan(sourceY);`
	`165`	`+ Span<TPixel> sourceRow = this.sourceFrame.PixelBuffer.DangerousGetRowSpan(sourceY);`
`166`	`166`
`167`	`167`	`for (int i = 0; i < scanline.Length; i++)`
`168`	`168`	`{`
`@@ -173,7 +173,7 @@ public override void Apply(Span<float> scanline, int x, int y)`
`173`	`173`	`overlaySpan[i] = sourceRow[sourceX];`
`174`	`174`	`}`
`175`	`175`
`176`		`- Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
	`176`	`+ Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);`
`177`	`177`	`this.Blender.Blend(`
`178`	`178`	`this.Configuration,`
`179`	`179`	`destinationRow,`
Original file line number	Diff line number	Diff line change
`@@ -302,7 +302,7 @@ public override void Apply(Span<float> scanline, int x, int y)`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`		`- Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
	`305`	`+ Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);`
`306`	`306`	`this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlays, amounts);`
`307`	`307`	`}`
`308`	`308`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)`
`121`	`121`	`{`
`122`	`122`	`if (hasOnes)`
`123`	`123`	`{`
`124`		`- source.GetPixelRowSpan(y).Slice(minX, scanlineWidth).Fill(solidBrushColor);`
	`124`	`+ source.PixelBuffer.DangerousGetRowSpan(y).Slice(minX, scanlineWidth).Fill(solidBrushColor);`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ public void Invoke(in RowInterval rows)`
`102`	`102`	`{`
`103`	`103`	`for (int y = rows.Min; y < rows.Max; y++)`
`104`	`104`	`{`
`105`		`- this.source.GetPixelRowSpan(y).Slice(this.bounds.X, this.bounds.Width).Fill(this.color);`
	`105`	`+ this.source.PixelBuffer.DangerousGetRowSpan(y).Slice(this.bounds.X, this.bounds.Width).Fill(this.color);`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ void Draw(List<DrawingOperation> operations, IBrush brush)`
`127`	`127`	`for (int row = firstRow; row < end; row++)`
`128`	`128`	`{`
`129`	`129`	`int y = startY + row;`
`130`		`- Span<float> span = buffer.GetRowSpan(row).Slice(offsetSpan);`
	`130`	`+ Span<float> span = buffer.DangerousGetRowSpan(row).Slice(offsetSpan);`
`131`	`131`	`currentApp.Apply(span, startX, y);`
`132`	`132`	`}`
`133`	`133`	`}`
`@@ -372,7 +372,7 @@ private Buffer2D<float> Render(IPath path)`
`372`	`372`	`{`
`373`	`373`	`while (scanner.MoveToNextPixelLine())`
`374`	`374`	`{`
`375`		`- Span<float> scanline = fullBuffer.GetRowSpan(scanner.PixelLineY);`
	`375`	`+ Span<float> scanline = fullBuffer.DangerousGetRowSpan(scanner.PixelLineY);`
`376`	`376`	`bool scanlineDirty = scanner.ScanCurrentPixelLineInto(0, xOffset, scanline);`
`377`	`377`
`378`	`378`	`if (scanlineDirty && !graphicsOptions.Antialias)`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public override void Apply(Span<float> scanline, int x, int y)`
`143`	`143`	`overlays[i] = this[offsetX, y];`
`144`	`144`	`}`
`145`	`145`
`146`		`- Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);`
	`146`	`+ Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x, scanline.Length);`
`147`	`147`	`this.Blender.Blend(`
`148`	`148`	`this.Configuration,`
`149`	`149`	`destinationRow,`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public SolidBrushApplicator(`
`73`	`73`	`/// <inheritdoc />`
`74`	`74`	`public override void Apply(Span<float> scanline, int x, int y)`
`75`	`75`	`{`
`76`		`- Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x);`
	`76`	`+ Span<TPixel> destinationRow = this.Target.PixelBuffer.DangerousGetRowSpan(y).Slice(x);`
`77`	`77`
`78`	`78`	`// Constrain the spans to each other`
`79`	`79`	`if (destinationRow.Length > scanline.Length)`