Buffer2D.GetRowSpan -> DangerousGetRowSpan

4 years ago · ff383c9eab
65 changed files with 141 additions and 141 deletions
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@ -306,7 +306,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                    int newY = Invert(y, height, inverted);
                    int rowStartIdx = y * width;
                    Span<byte> bufferRow = bufferSpan.Slice(rowStartIdx, width);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);

                    bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
                    if (rowHasUndefinedPixels)
@ -377,7 +377,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                for (int y = 0; y < height; y++)
                {
                    int newY = Invert(y, height, inverted);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
                    bool rowHasUndefinedPixels = rowsWithUndefinedPixelsSpan[y];
                    if (rowHasUndefinedPixels)
                    {
@ -826,7 +826,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                int newY = Invert(y, height, inverted);
                this.stream.Read(rowSpan);
                int offset = 0;
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);

                for (int x = 0; x < arrayWidth; x++)
                {
@ -878,7 +878,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
            {
                this.stream.Read(bufferSpan);
                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);

                int offset = 0;
                for (int x = 0; x < width; x++)
@ -933,7 +933,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
            {
                this.stream.Read(rowSpan);
                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                PixelOperations<TPixel>.Instance.FromBgr24Bytes(
                    this.Configuration,
                    rowSpan,
@ -961,7 +961,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
            {
                this.stream.Read(rowSpan);
                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                PixelOperations<TPixel>.Instance.FromBgra32Bytes(
                    this.Configuration,
                    rowSpan,
@ -1031,7 +1031,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                    this.stream.Read(rowSpan);

                    int newY = Invert(y, height, inverted);
-                    Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);

                    PixelOperations<TPixel>.Instance.FromBgra32Bytes(
                        this.Configuration,
@ -1054,7 +1054,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                    width);

                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);

                for (int x = 0; x < width; x++)
                {
@ -1109,7 +1109,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
            {
                this.stream.Read(bufferSpan);
                int newY = Invert(y, height, inverted);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);

                int offset = 0;
                for (int x = 0; x < width; x++)
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@ -274,7 +274,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToBgra32Bytes(
                    this.configuration,
                    pixelSpan,
@ -300,7 +300,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToBgr24Bytes(
                    this.configuration,
                    pixelSpan,
@ -326,7 +326,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);

                PixelOperations<TPixel>.Instance.ToBgra5551Bytes(
                    this.configuration,
--- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
@ -445,7 +445,7 @@ namespace SixLabors.ImageSharp.Formats.Gif

            for (int y = descriptorTop; y < descriptorBottom && y < imageHeight; y++)
            {
-                ref byte indicesRowRef = ref MemoryMarshal.GetReference(indices.GetRowSpan(y - descriptorTop));
+                ref byte indicesRowRef = ref MemoryMarshal.GetReference(indices.DangerousGetRowSpan(y - descriptorTop));

                // Check if this image is interlaced.
                int writeY; // the target y offset to write to
--- a/src/ImageSharp/Formats/Gif/LzwDecoder.cs
+++ b/src/ImageSharp/Formats/Gif/LzwDecoder.cs
@ -115,14 +115,14 @@ namespace SixLabors.ImageSharp.Formats.Gif
            int y = 0;
            int x = 0;
            int rowMax = width;
-            ref byte pixelsRowRef = ref MemoryMarshal.GetReference(pixels.GetRowSpan(y));
+            ref byte pixelsRowRef = ref MemoryMarshal.GetReference(pixels.DangerousGetRowSpan(y));
            while (xyz < length)
            {
                // Reset row reference.
                if (xyz == rowMax)
                {
                    x = 0;
-                    pixelsRowRef = ref MemoryMarshal.GetReference(pixels.GetRowSpan(++y));
+                    pixelsRowRef = ref MemoryMarshal.GetReference(pixels.DangerousGetRowSpan(++y));
                    rowMax = (y * width) + width;
                }

--- a/src/ImageSharp/Formats/Gif/LzwEncoder.cs
+++ b/src/ImageSharp/Formats/Gif/LzwEncoder.cs
@ -275,7 +275,7 @@ namespace SixLabors.ImageSharp.Formats.Gif

            for (int y = 0; y < indexedPixels.Height; y++)
            {
-                ref byte rowSpanRef = ref MemoryMarshal.GetReference(indexedPixels.GetRowSpan(y));
+                ref byte rowSpanRef = ref MemoryMarshal.GetReference(indexedPixels.DangerousGetRowSpan(y));
                int offsetX = y == 0 ? 1 : 0;

                for (int x = offsetX; x < indexedPixels.Width; x++)
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
@ -206,12 +206,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
            {
                this.ComponentCount = componentBuffers.Count;

-                this.Component0 = componentBuffers[0].GetRowSpan(row);
+                this.Component0 = componentBuffers[0].DangerousGetRowSpan(row);

                // In case of grayscale, Component1 and Component2 point to Component0 memory area
-                this.Component1 = this.ComponentCount > 1 ? componentBuffers[1].GetRowSpan(row) : this.Component0;
-                this.Component2 = this.ComponentCount > 2 ? componentBuffers[2].GetRowSpan(row) : this.Component0;
-                this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].GetRowSpan(row) : Span<float>.Empty;
+                this.Component1 = this.ComponentCount > 1 ? componentBuffers[1].DangerousGetRowSpan(row) : this.Component0;
+                this.Component2 = this.ComponentCount > 2 ? componentBuffers[2].DangerousGetRowSpan(row) : this.Component0;
+                this.Component3 = this.ComponentCount > 3 ? componentBuffers[3].DangerousGetRowSpan(row) : Span<float>.Empty;
            }

            internal ComponentValues(
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
@ -202,7 +202,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                        // by the basic H and V specified for the component
                        for (int y = 0; y < v; y++)
                        {
-                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(y);
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(y);
                            ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);

                            for (int x = 0; x < h; x++)
@ -253,7 +253,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
            for (int j = 0; j < h; j++)
            {
                this.cancellationToken.ThrowIfCancellationRequested();
-                Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);

                for (int i = 0; i < w; i++)
@ -376,7 +376,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                        for (int y = 0; y < v; y++)
                        {
                            int blockRow = (mcuRow * v) + y;
-                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(blockRow);
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(blockRow);
                            ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);

                            for (int x = 0; x < h; x++)
@ -421,7 +421,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                {
                    this.cancellationToken.ThrowIfCancellationRequested();

-                    Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                    Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                    ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);

                    for (int i = 0; i < w; i++)
@ -449,7 +449,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                {
                    this.cancellationToken.ThrowIfCancellationRequested();

-                    Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
+                    Span<Block8x8> blockSpan = component.SpectralBlocks.DangerousGetRowSpan(j);
                    ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);

                    for (int i = 0; i < w; i++)
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs
@ -95,8 +95,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder

                int yBuffer = y * this.blockAreaSize.Height;

-                Span<float> colorBufferRow = this.ColorBuffer.GetRowSpan(yBuffer);
-                Span<Block8x8> blockRow = spectralBuffer.GetRowSpan(yBlock);
+                Span<float> colorBufferRow = this.ColorBuffer.DangerousGetRowSpan(yBuffer);
+                Span<Block8x8> blockRow = spectralBuffer.DangerousGetRowSpan(yBlock);

                // see: https://github.com/SixLabors/ImageSharp/issues/824
                int widthInBlocks = Math.Min(spectralBuffer.Width, this.SizeInBlocks.Width);
@ -117,7 +117,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
            Buffer2D<Block8x8> spectralBlocks = this.Component.SpectralBlocks;
            for (int i = 0; i < spectralBlocks.Height; i++)
            {
-                spectralBlocks.GetRowSpan(i).Clear();
+                spectralBlocks.DangerousGetRowSpan(i).Clear();
            }
        }

--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
@ -162,7 +162,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                {
                    Span<TPixel> proxyRow = this.paddedProxyPixelRow.GetSpan();
                    PixelOperations<TPixel>.Instance.PackFromRgbPlanes(this.configuration, r, g, b, proxyRow);
-                    proxyRow.Slice(0, width).CopyTo(this.pixelBuffer.GetRowSpan(yy));
+                    proxyRow.Slice(0, width).CopyTo(this.pixelBuffer.DangerousGetRowSpan(yy));
                }
            }

--- a/src/ImageSharp/Formats/Jpeg/Components/RowOctet.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/RowOctet.cs
@ -86,7 +86,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
            int i = 0;
            while (y < yEnd)
            {
-                this[i++] = buffer.GetRowSpan(y++);
+                this[i++] = buffer.DangerousGetRowSpan(y++);
            }
        }

--- a/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaDecoderCore.cs
@ -234,7 +234,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            for (int y = 0; y < height; y++)
            {
                int newY = InvertY(y, height, origin);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);

                switch (colorMapPixelSizeInBytes)
                {
@ -318,7 +318,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
                for (int y = 0; y < height; y++)
                {
                    int newY = InvertY(y, height, origin);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
                    int rowStartIdx = y * width * bytesPerPixel;
                    for (int x = 0; x < width; x++)
                    {
@ -364,7 +364,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
                for (int y = 0; y < height; y++)
                {
                    int newY = InvertY(y, height, origin);
-                    Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                    for (int x = width - 1; x >= 0; x--)
                    {
                        this.ReadL8Pixel(color, x, pixelSpan);
@ -412,7 +412,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            for (int y = 0; y < height; y++)
            {
                int newY = InvertY(y, height, origin);
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);

                if (invertX)
                {
@ -479,7 +479,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
                for (int y = 0; y < height; y++)
                {
                    int newY = InvertY(y, height, origin);
-                    Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(newY);
                    for (int x = width - 1; x >= 0; x--)
                    {
                        this.ReadBgr24Pixel(color, x, pixelSpan);
@ -548,7 +548,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            for (int y = 0; y < height; y++)
            {
                int newY = InvertY(y, height, origin);
-                Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
                if (invertX)
                {
                    for (int x = width - 1; x >= 0; x--)
@ -587,7 +587,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
                for (int y = 0; y < height; y++)
                {
                    int newY = InvertY(y, height, origin);
-                    Span<TPixel> pixelRow = pixels.GetRowSpan(newY);
+                    Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(newY);
                    int rowStartIdx = y * width * bytesPerPixel;
                    for (int x = 0; x < width; x++)
                    {
@ -654,7 +654,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            where TPixel : unmanaged, IPixel<TPixel>
        {
            this.currentStream.Read(row);
-            Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+            Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
            PixelOperations<TPixel>.Instance.FromL8Bytes(this.Configuration, row, pixelSpan, width);
        }

@ -681,7 +681,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            where TPixel : unmanaged, IPixel<TPixel>
        {
            this.currentStream.Read(row);
-            Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+            Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
            PixelOperations<TPixel>.Instance.FromBgr24Bytes(this.Configuration, row, pixelSpan, width);
        }

@ -700,7 +700,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
            where TPixel : unmanaged, IPixel<TPixel>
        {
            this.currentStream.Read(row);
-            Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+            Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
            PixelOperations<TPixel>.Instance.FromBgra32Bytes(this.Configuration, row, pixelSpan, width);
        }

--- a/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tga/TgaEncoderCore.cs
@ -276,7 +276,7 @@ namespace SixLabors.ImageSharp.Formats.Tga

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToL8Bytes(
                    this.configuration,
                    pixelSpan,
@ -300,7 +300,7 @@ namespace SixLabors.ImageSharp.Formats.Tga

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToBgra5551Bytes(
                    this.configuration,
                    pixelSpan,
@ -324,7 +324,7 @@ namespace SixLabors.ImageSharp.Formats.Tga

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToBgr24Bytes(
                    this.configuration,
                    pixelSpan,
@ -348,7 +348,7 @@ namespace SixLabors.ImageSharp.Formats.Tga

            for (int y = pixels.Height - 1; y >= 0; y--)
            {
-                Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
+                Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
                PixelOperations<TPixel>.Instance.ToBgra32Bytes(
                    this.configuration,
                    pixelSpan,
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
@ -79,7 +79,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
            int offset = 0;
            for (int y = 0; y < pixelBuffer.Height; y++)
            {
-                Span<Rgb24> pixelRowSpan = pixelBuffer.GetRowSpan(y);
+                Span<Rgb24> pixelRowSpan = pixelBuffer.DangerousGetRowSpan(y);
                Span<byte> rgbBytes = MemoryMarshal.AsBytes(pixelRowSpan);
                rgbBytes.CopyTo(buffer.Slice(offset));
                offset += rgbBytes.Length;
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs
@ -41,7 +41,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero24TiffColor{TPixel}.cs
@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32FloatTiffColor{TPixel}.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero32TiffColor{TPixel}.cs
@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero8TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero8TiffColor{TPixel}.cs
@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                int byteCount = pixelRow.Length;
                PixelOperations<TPixel>.Instance.FromL8Bytes(
                    this.configuration,
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor{TPixel}.cs
@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    int value = bitReader.ReadBits(this.bitsPerSample0);
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor{TPixel}.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    int index = bitReader.ReadBits(this.bitsPerSample0);
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs
@ -42,7 +42,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);

                if (this.isBigEndian)
                {
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb16PlanarTiffColor{TPixel}.cs
@ -39,7 +39,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb242424TiffColor{TPixel}.cs
@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            Span<byte> bufferSpan = buffer.AsSpan(bufferStartIdx);
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);

                if (this.isBigEndian)
                {
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb24PlanarTiffColor{TPixel}.cs
@ -41,7 +41,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb323232TiffColor{TPixel}.cs
@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);

                if (this.isBigEndian)
                {
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb32PlanarTiffColor{TPixel}.cs
@ -38,7 +38,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb444TiffColor{TPixel}.cs
@ -23,7 +23,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            var bgra = default(Bgra4444);
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y);

                for (int x = left; x < left + width; x += 2)
                {
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb888TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb888TiffColor{TPixel}.cs
@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                int byteCount = pixelRow.Length * 3;
                PixelOperations<TPixel>.Instance.FromRgb24Bytes(
                    this.configuration,
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbFloat323232TiffColor{TPixel}.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);

                if (this.isBigEndian)
                {
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor{TPixel}.cs
@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    float r = rBitReader.ReadBits(this.bitsPerSampleR) / this.rFactor;
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor{TPixel}.cs
@ -47,7 +47,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    float r = bitReader.ReadBits(this.bitsPerSampleR) / this.rFactor;
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero16TiffColor{TPixel}.cs
@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero24TiffColor{TPixel}.cs
@ -37,7 +37,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32FloatTiffColor{TPixel}.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero32TiffColor{TPixel}.cs
@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            int offset = 0;
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                if (this.isBigEndian)
                {
                    for (int x = 0; x < pixelRow.Length; x++)
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor{TPixel}.cs
@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
            var l8 = default(L8);
            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    byte intensity = (byte)(byte.MaxValue - data[offset++]);
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor{TPixel}.cs
@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    int value = bitReader.ReadBits(this.bitsPerSample0);
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrPlanarTiffColor{TPixel}.cs
@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    Rgba32 rgba = this.converter.ConvertToRgba32(yData[offset], cbData[offset], crData[offset]);
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/YCbCrTiffColor{TPixel}.cs
@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation

            for (int y = top; y < top + height; y++)
            {
-                Span<TPixel> pixelRow = pixels.GetRowSpan(y).Slice(left, width);
+                Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
                for (int x = 0; x < pixelRow.Length; x++)
                {
                    Rgba32 rgba = this.converter.ConvertToRgba32(ycbcrData[offset], ycbcrData[offset + 1], ycbcrData[offset + 2]);
--- a/src/ImageSharp/Formats/Tiff/Writers/TiffCompositeColorWriter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/Writers/TiffCompositeColorWriter{TPixel}.cs
@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
            int stripPixelsRowIdx = 0;
            for (int row = y; row < lastRow; row++)
            {
-                Span<TPixel> stripPixelsRow = this.Image.PixelBuffer.GetRowSpan(row);
+                Span<TPixel> stripPixelsRow = this.Image.PixelBuffer.DangerousGetRowSpan(row);
                stripPixelsRow.CopyTo(stripPixels.Slice(stripPixelsRowIdx * width, width));
                stripPixelsRowIdx++;
            }
--- a/src/ImageSharp/ImageFrame{TPixel}.cs
+++ b/src/ImageSharp/ImageFrame{TPixel}.cs
@ -192,7 +192,7 @@ namespace SixLabors.ImageSharp
            Guard.MustBeGreaterThanOrEqualTo(rowIndex, 0, nameof(rowIndex));
            Guard.MustBeLessThan(rowIndex, this.Height, nameof(rowIndex));

-            return this.PixelBuffer.GetRowSpan(rowIndex);
+            return this.PixelBuffer.DangerousGetRowSpan(rowIndex);
        }

        /// <summary>
--- a/src/ImageSharp/Image{TPixel}.cs
+++ b/src/ImageSharp/Image{TPixel}.cs
@ -317,7 +317,7 @@ namespace SixLabors.ImageSharp

            this.EnsureNotDisposed();

-            return this.PixelSourceUnsafe.PixelBuffer.GetRowSpan(rowIndex);
+            return this.PixelSourceUnsafe.PixelBuffer.DangerousGetRowSpan(rowIndex);
        }

        /// <summary>
--- a/src/ImageSharp/IndexedImageFrame{TPixel}.cs
+++ b/src/ImageSharp/IndexedImageFrame{TPixel}.cs
@ -99,7 +99,7 @@ namespace SixLabors.ImageSharp
        /// <returns>The pixel row as a <see cref="Span{T}"/>.</returns>
        [MethodImpl(InliningOptions.ShortMethod)]
        public Span<byte> GetWritablePixelRowSpanUnsafe(int rowIndex)
-            => this.pixelBuffer.GetRowSpan(rowIndex);
+            => this.pixelBuffer.DangerousGetRowSpan(rowIndex);

        /// <inheritdoc/>
        public void Dispose()
--- a/src/ImageSharp/Memory/Buffer2DRegion{T}.cs
+++ b/src/ImageSharp/Memory/Buffer2DRegion{T}.cs
@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.Memory
            int xx = this.Rectangle.X;
            int width = this.Rectangle.Width;

-            return this.Buffer.GetRowSpan(yy).Slice(xx, width);
+            return this.Buffer.DangerousGetRowSpan(yy).Slice(xx, width);
        }

        /// <summary>
@ -138,7 +138,7 @@ namespace SixLabors.ImageSharp.Memory
        {
            int y = this.Rectangle.Y;
            int x = this.Rectangle.X;
-            return ref this.Buffer.GetRowSpan(y)[x];
+            return ref this.Buffer.DangerousGetRowSpan(y)[x];
        }

        internal void Clear()
--- a/src/ImageSharp/Memory/Buffer2D{T}.cs
+++ b/src/ImageSharp/Memory/Buffer2D{T}.cs
@ -75,7 +75,7 @@ namespace SixLabors.ImageSharp.Memory
                DebugGuard.MustBeLessThan(x, this.Width, nameof(x));
                DebugGuard.MustBeLessThan(y, this.Height, nameof(y));

-                return ref this.GetRowSpan(y)[x];
+                return ref this.DangerousGetRowSpan(y)[x];
            }
        }

@ -95,7 +95,7 @@ namespace SixLabors.ImageSharp.Memory
        /// <returns>The <see cref="Span{T}"/> of the pixels in the row.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when row index is out of range.</exception>
        [MethodImpl(InliningOptions.ShortMethod)]
-        public Span<T> GetRowSpan(int y)
+        public Span<T> DangerousGetRowSpan(int y)
        {
            DebugGuard.MustBeGreaterThanOrEqualTo(y, 0, nameof(y));
            DebugGuard.MustBeLessThan(y, this.Height, nameof(y));
--- a/src/ImageSharp/PixelAccessor{TPixel}.cs
+++ b/src/ImageSharp/PixelAccessor{TPixel}.cs
@ -67,6 +67,6 @@ namespace SixLabors.ImageSharp
        /// <param name="rowIndex">The row index.</param>
        /// <returns>The <see cref="Span{TPixel}"/>.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when row index is out of range.</exception>
-        public Span<TPixel> GetRowSpan(int rowIndex) => this.buffer.GetRowSpan(rowIndex);
+        public Span<TPixel> GetRowSpan(int rowIndex) => this.buffer.DangerousGetRowSpan(rowIndex);
    }
 }
--- a/src/ImageSharp/Processing/Extensions/ProcessingExtensions.IntegralImage.cs
+++ b/src/ImageSharp/Processing/Extensions/ProcessingExtensions.IntegralImage.cs
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Processing
            {
                Span<L8> tempSpan = tempRow.GetSpan();
                Span<TPixel> sourceRow = source.GetPixelRowSpan(0);
-                Span<ulong> destRow = intImage.GetRowSpan(0);
+                Span<ulong> destRow = intImage.DangerousGetRowSpan(0);

                PixelOperations<TPixel>.Instance.ToL8(configuration, sourceRow, tempSpan);

@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Processing
                for (int y = 1; y < endY; y++)
                {
                    sourceRow = source.GetPixelRowSpan(y);
-                    destRow = intImage.GetRowSpan(y);
+                    destRow = intImage.DangerousGetRowSpan(y);

                    PixelOperations<TPixel>.Instance.ToL8(configuration, sourceRow, tempSpan);

--- a/src/ImageSharp/Processing/Processors/Convolution/BokehBlurProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/BokehBlurProcessor{TPixel}.cs
@ -231,11 +231,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                int kernelSize = this.kernel.Length;

                // Clear the target buffer for each row run
-                Span<ComplexVector4> targetBuffer = this.targetValues.GetRowSpan(y);
+                Span<ComplexVector4> targetBuffer = this.targetValues.DangerousGetRowSpan(y);
                targetBuffer.Clear();

                // Execute the bulk pixel format conversion for the current row
-                Span<TPixel> sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, span);

                ref Vector4 sourceBase = ref MemoryMarshal.GetReference(span);
@ -295,7 +295,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            [MethodImpl(InliningOptions.ShortMethod)]
            public void Invoke(int y, Span<Vector4> span)
            {
-                Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
+                Span<TPixel> targetRowSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(this.bounds.X);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, targetRowSpan.Slice(0, span.Length), span, PixelConversionModifiers.Premultiply);
                ref Vector4 baseRef = ref MemoryMarshal.GetReference(span);

@ -335,7 +335,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            [MethodImpl(InliningOptions.ShortMethod)]
            public void Invoke(int y, Span<Vector4> span)
            {
-                Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
+                Span<TPixel> targetRowSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(this.bounds.X);

                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, targetRowSpan.Slice(0, span.Length), span, PixelConversionModifiers.Premultiply);

@ -378,8 +378,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                Vector4 low = Vector4.Zero;
                var high = new Vector4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);

-                Span<TPixel> targetPixelSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
-                Span<Vector4> sourceRowSpan = this.sourceValues.GetRowSpan(y).Slice(this.bounds.X);
+                Span<TPixel> targetPixelSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(this.bounds.X);
+                Span<Vector4> sourceRowSpan = this.sourceValues.DangerousGetRowSpan(y).Slice(this.bounds.X);
                ref Vector4 sourceRef = ref MemoryMarshal.GetReference(sourceRowSpan);

                for (int x = 0; x < this.bounds.Width; x++)
@ -422,13 +422,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            [MethodImpl(InliningOptions.ShortMethod)]
            public unsafe void Invoke(int y)
            {
-                Span<Vector4> sourceRowSpan = this.sourceValues.GetRowSpan(y).Slice(this.bounds.X, this.bounds.Width);
+                Span<Vector4> sourceRowSpan = this.sourceValues.DangerousGetRowSpan(y).Slice(this.bounds.X, this.bounds.Width);
                ref Vector4 sourceRef = ref MemoryMarshal.GetReference(sourceRowSpan);

                Numerics.Clamp(MemoryMarshal.Cast<Vector4, float>(sourceRowSpan), 0, float.PositiveInfinity);
                Numerics.CubeRootOnXYZ(sourceRowSpan);

-                Span<TPixel> targetPixelSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
+                Span<TPixel> targetPixelSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(this.bounds.X);

                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, sourceRowSpan.Slice(0, this.bounds.Width), targetPixelSpan, PixelConversionModifiers.Premultiply);
            }
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DRowOperation{TPixel}.cs
@ -87,7 +87,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            {
                // Get the precalculated source sample row for this kernel row and copy to our buffer.
                int sampleY = Unsafe.Add(ref sampleRowBase, kY);
-                sourceRow = this.sourcePixels.GetRowSpan(sampleY).Slice(boundsX, boundsWidth);
+                sourceRow = this.sourcePixels.DangerousGetRowSpan(sampleY).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                ref Vector4 sourceBase = ref MemoryMarshal.GetReference(sourceBuffer);
@ -110,7 +110,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution

            // Now we need to combine the values and copy the original alpha values
            // from the source row.
-            sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+            sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
            PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

            for (int x = 0; x < sourceRow.Length; x++)
@ -123,7 +123,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                target.W = Unsafe.Add(ref MemoryMarshal.GetReference(sourceBuffer), x).W;
            }

-            Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+            Span<TPixel> targetRowSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
            PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetYBuffer, targetRowSpan);
        }

@ -152,7 +152,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            {
                // Get the precalculated source sample row for this kernel row and copy to our buffer.
                int sampleY = Unsafe.Add(ref sampleRowBase, kY);
-                Span<TPixel> sourceRow = this.sourcePixels.GetRowSpan(sampleY).Slice(boundsX, boundsWidth);
+                Span<TPixel> sourceRow = this.sourcePixels.DangerousGetRowSpan(sampleY).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                Numerics.Premultiply(sourceBuffer);
@ -186,7 +186,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution

            Numerics.UnPremultiply(targetYBuffer);

-            Span<TPixel> targetRow = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+            Span<TPixel> targetRow = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
            PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetYBuffer, targetRow);
        }
    }
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor{TPixel}.cs
@ -157,7 +157,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                targetBuffer.Clear();

                // Get the precalculated source sample row for this kernel row and copy to our buffer.
-                Span<TPixel> sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                ref Vector4 sourceBase = ref MemoryMarshal.GetReference(sourceBuffer);
@ -187,7 +187,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                }

                // Now we need to copy the original alpha values from the source row.
-                sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                targetStart = ref MemoryMarshal.GetReference(targetBuffer);
@ -200,7 +200,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
                }

-                Span<TPixel> targetRow = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> targetRow = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetBuffer, targetRow);
            }

@ -219,7 +219,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                targetBuffer.Clear();

                // Get the precalculated source sample row for this kernel row and copy to our buffer.
-                Span<TPixel> sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                Numerics.Premultiply(sourceBuffer);
@ -252,7 +252,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution

                Numerics.UnPremultiply(targetBuffer);

-                Span<TPixel> targetRow = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> targetRow = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetBuffer, targetRow);
            }
        }
@ -327,7 +327,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                while (Unsafe.IsAddressLessThan(ref kernelStart, ref kernelEnd))
                {
                    // Get the precalculated source sample row for this kernel row and copy to our buffer.
-                    sourceRow = this.sourcePixels.GetRowSpan(sampleRowBase).Slice(boundsX, boundsWidth);
+                    sourceRow = this.sourcePixels.DangerousGetRowSpan(sampleRowBase).Slice(boundsX, boundsWidth);

                    PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

@ -349,7 +349,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                }

                // Now we need to copy the original alpha values from the source row.
-                sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);
                {
                    ref Vector4 sourceBase = ref MemoryMarshal.GetReference(sourceBuffer);
@ -364,7 +364,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                    }
                }

-                Span<TPixel> targetRow = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> targetRow = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetBuffer, targetRow);
            }

@ -392,7 +392,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                while (Unsafe.IsAddressLessThan(ref kernelStart, ref kernelEnd))
                {
                    // Get the precalculated source sample row for this kernel row and copy to our buffer.
-                    sourceRow = this.sourcePixels.GetRowSpan(sampleRowBase).Slice(boundsX, boundsWidth);
+                    sourceRow = this.sourcePixels.DangerousGetRowSpan(sampleRowBase).Slice(boundsX, boundsWidth);

                    PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

@ -415,7 +415,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution

                Numerics.UnPremultiply(targetBuffer);

-                Span<TPixel> targetRow = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> targetRow = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetBuffer, targetRow);
            }
        }
--- a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs
@ -118,7 +118,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                Span<Vector4> targetBuffer = span.Slice(this.bounds.Width);

                ref Vector4 targetRowRef = ref MemoryMarshal.GetReference(span);
-                Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                Span<TPixel> targetRowSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);

                var state = new ConvolutionState(in this.kernel, this.map);
                int row = y - this.bounds.Y;
@ -135,7 +135,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                    {
                        // Get the precalculated source sample row for this kernel row and copy to our buffer.
                        int offsetY = Unsafe.Add(ref sampleRowBase, kY);
-                        sourceRow = this.sourcePixels.GetRowSpan(offsetY).Slice(boundsX, boundsWidth);
+                        sourceRow = this.sourcePixels.DangerousGetRowSpan(offsetY).Slice(boundsX, boundsWidth);
                        PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                        ref Vector4 sourceBase = ref MemoryMarshal.GetReference(sourceBuffer);
@ -155,7 +155,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                    }

                    // Now we need to copy the original alpha values from the source row.
-                    sourceRow = this.sourcePixels.GetRowSpan(y).Slice(boundsX, boundsWidth);
+                    sourceRow = this.sourcePixels.DangerousGetRowSpan(y).Slice(boundsX, boundsWidth);
                    PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                    for (int x = 0; x < sourceRow.Length; x++)
@ -174,7 +174,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
                    {
                        // Get the precalculated source sample row for this kernel row and copy to our buffer.
                        int offsetY = Unsafe.Add(ref sampleRowBase, kY);
-                        Span<TPixel> sourceRow = this.sourcePixels.GetRowSpan(offsetY).Slice(boundsX, boundsWidth);
+                        Span<TPixel> sourceRow = this.sourcePixels.DangerousGetRowSpan(offsetY).Slice(boundsX, boundsWidth);
                        PixelOperations<TPixel>.Instance.ToVector4(this.configuration, sourceRow, sourceBuffer);

                        Numerics.Premultiply(sourceBuffer);
--- a/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/EdgeDetectorCompassProcessor{TPixel}.cs
@ -117,8 +117,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
            [MethodImpl(InliningOptions.ShortMethod)]
            public void Invoke(int y)
            {
-                ref TPixel passPixelsBase = ref MemoryMarshal.GetReference(this.passPixels.GetRowSpan(y));
-                ref TPixel targetPixelsBase = ref MemoryMarshal.GetReference(this.targetPixels.GetRowSpan(y));
+                ref TPixel passPixelsBase = ref MemoryMarshal.GetReference(this.passPixels.DangerousGetRowSpan(y));
+                ref TPixel targetPixelsBase = ref MemoryMarshal.GetReference(this.targetPixels.DangerousGetRowSpan(y));

                for (int x = this.minX; x < this.maxX; x++)
                {
--- a/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor{TPixel}.cs
@ -176,7 +176,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Effects
                        }
                    }

-                    Span<TPixel> targetRowAreaPixelSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X, this.bounds.Width);
+                    Span<TPixel> targetRowAreaPixelSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(this.bounds.X, this.bounds.Width);

                    PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, targetRowAreaVector4Span, targetRowAreaPixelSpan);
                }
--- a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
@ -525,7 +525,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
            }

            [MethodImpl(InliningOptions.ShortMethod)]
-            public Span<int> GetCdfLutSpan(int tileX, int tileY) => this.cdfLutBuffer2D.GetRowSpan(tileY).Slice(tileX * this.luminanceLevels, this.luminanceLevels);
+            public Span<int> GetCdfLutSpan(int tileX, int tileY) => this.cdfLutBuffer2D.DangerousGetRowSpan(tileY).Slice(tileX * this.luminanceLevels, this.luminanceLevels);

            /// <summary>
            /// Remaps the grey value with the cdf.
@ -599,7 +599,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                        int cdfY = this.tileYStartPositions[index].CdfY;
                        int y = this.tileYStartPositions[index].Y;
                        int endY = Math.Min(y + this.tileHeight, this.sourceHeight);
-                        Span<int> cdfMinSpan = this.cdfMinBuffer2D.GetRowSpan(cdfY);
+                        Span<int> cdfMinSpan = this.cdfMinBuffer2D.DangerousGetRowSpan(cdfY);
                        cdfMinSpan.Clear();

                        using IMemoryOwner<int> histogramBuffer = this.allocator.Allocate<int>(this.luminanceLevels);
@ -609,7 +609,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Normalization
                        for (int x = 0; x < this.sourceWidth; x += this.tileWidth)
                        {
                            histogram.Clear();
-                            Span<int> cdfLutSpan = this.cdfLutBuffer2D.GetRowSpan(index).Slice(cdfX * this.luminanceLevels, this.luminanceLevels);
+                            Span<int> cdfLutSpan = this.cdfLutBuffer2D.DangerousGetRowSpan(index).Slice(cdfX * this.luminanceLevels, this.luminanceLevels);
                            ref int cdfBase = ref MemoryMarshal.GetReference(cdfLutSpan);

                            int xlimit = Math.Min(x + this.tileWidth, this.sourceWidth);
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
@ -80,7 +80,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
                // Loop through each row
                for (int y = bounds.Top; y < bounds.Bottom; y++)
                {
-                    Span<TPixel> row = source.GetRowSpan(y).Slice(bounds.Left, bounds.Width);
+                    Span<TPixel> row = source.DangerousGetRowSpan(y).Slice(bounds.Left, bounds.Width);
                    PixelOperations<TPixel>.Instance.ToRgba32(this.Configuration, row, bufferSpan);

                    for (int x = 0; x < bufferSpan.Length; x++)
--- a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
@ -384,7 +384,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization

            for (int y = bounds.Top; y < bounds.Bottom; y++)
            {
-                Span<TPixel> row = source.GetRowSpan(y).Slice(bounds.Left, bounds.Width);
+                Span<TPixel> row = source.DangerousGetRowSpan(y).Slice(bounds.Left, bounds.Width);
                PixelOperations<TPixel>.Instance.ToRgba32(this.Configuration, row, bufferSpan);

                for (int x = 0; x < bufferSpan.Length; x++)
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernelMap.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernelMap.cs
@ -252,7 +252,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
            int length = right - left + 1;
            this.ValidateSizesForCreateKernel(length, dataRowIndex, left, right);

-            Span<float> rowSpan = this.data.GetRowSpan(dataRowIndex);
+            Span<float> rowSpan = this.data.DangerousGetRowSpan(dataRowIndex);

            ref float rowReference = ref MemoryMarshal.GetReference(rowSpan);
            float* rowPtr = (float*)Unsafe.AsPointer(ref rowReference);
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeWorker.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeWorker.cs
@ -105,7 +105,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms

        [MethodImpl(InliningOptions.ShortMethod)]
        public Span<Vector4> GetColumnSpan(int x, int startY)
-            => this.transposedFirstPassBuffer.GetRowSpan(x).Slice(startY - this.currentWindow.Min);
+            => this.transposedFirstPassBuffer.DangerousGetRowSpan(x).Slice(startY - this.currentWindow.Min);

        public void Initialize()
            => this.CalculateFirstPassValues(this.currentWindow);
@ -140,7 +140,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                    Unsafe.Add(ref tempRowBase, x) = kernel.ConvolveCore(ref firstPassColumnBase);
                }

-                Span<TPixel> targetRowSpan = destination.GetRowSpan(y);
+                Span<TPixel> targetRowSpan = destination.DangerousGetRowSpan(y);

                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, tempColSpan, targetRowSpan, this.conversionModifiers);
            }
--- a/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs
+++ b/tests/ImageSharp.Benchmarks/PixelBlenders/PorterDuffBulkVsPixel.cs
@ -70,7 +70,7 @@ namespace SixLabors.ImageSharp.Benchmarks
            Buffer2D<Rgba32> pixels = image.GetRootFramePixelBuffer();
            for (int y = 0; y < image.Height; y++)
            {
-                Span<Rgba32> span = pixels.GetRowSpan(y);
+                Span<Rgba32> span = pixels.DangerousGetRowSpan(y);
                this.BulkVectorConvert(span, span, span, amounts.GetSpan());
            }

@ -86,7 +86,7 @@ namespace SixLabors.ImageSharp.Benchmarks
            Buffer2D<Rgba32> pixels = image.GetRootFramePixelBuffer();
            for (int y = 0; y < image.Height; y++)
            {
-                Span<Rgba32> span = pixels.GetRowSpan(y);
+                Span<Rgba32> span = pixels.DangerousGetRowSpan(y);
                this.BulkPixelConvert(span, span, span, amounts.GetSpan());
            }

--- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs
@ -183,7 +183,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                    Buffer2D<Block8x8> spectralBlocks = component.SpectralBlocks;
                    for (int i = 0; i < spectralBlocks.Height; i++)
                    {
-                        spectralBlocks.GetRowSpan(i).Clear();
+                        spectralBlocks.DangerousGetRowSpan(i).Clear();
                    }
                }
            }
--- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs
@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils

                for (int y = startIndex; y < endIndex; y++)
                {
-                    Span<Block8x8> blockRow = data.GetRowSpan(y - startIndex);
+                    Span<Block8x8> blockRow = data.DangerousGetRowSpan(y - startIndex);
                    for (int x = 0; x < this.WidthInBlocks; x++)
                    {
                        short[] block = blockRow[x].ToArray();
@ -80,7 +80,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils
                Buffer2D<Block8x8> data = c.SpectralBlocks;
                for (int y = 0; y < this.HeightInBlocks; y++)
                {
-                    Span<Block8x8> blockRow = data.GetRowSpan(y);
+                    Span<Block8x8> blockRow = data.DangerousGetRowSpan(y);
                    for (int x = 0; x < this.WidthInBlocks; x++)
                    {
                        short[] block = blockRow[x].ToArray();
--- a/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs
+++ b/tests/ImageSharp.Tests/Image/ProcessPixelRowsTestBase.cs
@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Tests
            Buffer2D<L16> buffer = image.Frames.RootFrame.PixelBuffer;
            for (int y = 0; y < 256; y++)
            {
-                Span<L16> row = buffer.GetRowSpan(y);
+                Span<L16> row = buffer.DangerousGetRowSpan(y);
                for (int x = 0; x < 256; x++)
                {
                    int actual = row[x].PackedValue;
@ -78,7 +78,7 @@ namespace SixLabors.ImageSharp.Tests
            Buffer2D<L16> buffer = img1.Frames.RootFrame.PixelBuffer;
            for (int y = 0; y < 256; y++)
            {
-                Span<L16> row = buffer.GetRowSpan(y);
+                Span<L16> row = buffer.DangerousGetRowSpan(y);
                for (int x = 0; x < 256; x++)
                {
                    row[x] = new L16((ushort)(x * y));
@ -100,7 +100,7 @@ namespace SixLabors.ImageSharp.Tests
            buffer = img2.Frames.RootFrame.PixelBuffer;
            for (int y = 0; y < 256; y++)
            {
-                Span<L16> row = buffer.GetRowSpan(y);
+                Span<L16> row = buffer.DangerousGetRowSpan(y);
                for (int x = 0; x < 256; x++)
                {
                    int actual = row[x].PackedValue;
@ -116,7 +116,7 @@ namespace SixLabors.ImageSharp.Tests
            Buffer2D<L16> buffer2 = img1.Frames.RootFrame.PixelBuffer;
            for (int y = 0; y < 256; y++)
            {
-                Span<L16> row = buffer2.GetRowSpan(y);
+                Span<L16> row = buffer2.DangerousGetRowSpan(y);
                for (int x = 0; x < 256; x++)
                {
                    row[x] = new L16((ushort)(x * y));
@ -142,8 +142,8 @@ namespace SixLabors.ImageSharp.Tests
            Buffer2D<L16> buffer3 = img3.Frames.RootFrame.PixelBuffer;
            for (int y = 0; y < 256; y++)
            {
-                Span<L16> row2 = buffer2.GetRowSpan(y);
-                Span<L16> row3 = buffer3.GetRowSpan(y);
+                Span<L16> row2 = buffer2.DangerousGetRowSpan(y);
+                Span<L16> row3 = buffer3.DangerousGetRowSpan(y);
                for (int x = 0; x < 256; x++)
                {
                    int actual2 = row2[x].PackedValue;
--- a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
+++ b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
@ -127,7 +127,7 @@ namespace SixLabors.ImageSharp.Tests.Memory

            using (Buffer2D<TestStructs.Foo> buffer = this.MemoryAllocator.Allocate2D<TestStructs.Foo>(width, height))
            {
-                Span<TestStructs.Foo> span = buffer.GetRowSpan(y);
+                Span<TestStructs.Foo> span = buffer.DangerousGetRowSpan(y);

                Assert.Equal(width, span.Length);

@ -177,7 +177,7 @@ namespace SixLabors.ImageSharp.Tests.Memory
            this.MemoryAllocator.BufferCapacityInBytes = bufferCapacity;
            using Buffer2D<byte> buffer = this.MemoryAllocator.Allocate2D<byte>(width, height);

-            Exception ex = Assert.ThrowsAny<Exception>(() => buffer.GetRowSpan(y));
+            Exception ex = Assert.ThrowsAny<Exception>(() => buffer.DangerousGetRowSpan(y));
            Assert.True(ex is ArgumentOutOfRangeException || ex is IndexOutOfRangeException);
        }

@ -268,8 +268,8 @@ namespace SixLabors.ImageSharp.Tests.Memory
                Buffer2D<int>.SwapOrCopyContent(dest, source);
            }

-            int actual1 = dest.GetRowSpan(0)[0];
-            int actual2 = dest.GetRowSpan(0)[0];
+            int actual1 = dest.DangerousGetRowSpan(0)[0];
+            int actual2 = dest.DangerousGetRowSpan(0)[0];
            int actual3 = dest.GetSafeRowMemory(0).Span[0];
            int actual5 = dest[0, 0];

@ -297,7 +297,7 @@ namespace SixLabors.ImageSharp.Tests.Memory

                for (int y = 0; y < b.Height; y++)
                {
-                    Span<float> row = b.GetRowSpan(y);
+                    Span<float> row = b.DangerousGetRowSpan(y);

                    Span<float> s = row.Slice(startIndex, columnCount);
                    Span<float> d = row.Slice(destIndex, columnCount);
@ -320,7 +320,7 @@ namespace SixLabors.ImageSharp.Tests.Memory

                for (int y = 0; y < b.Height; y++)
                {
-                    Span<float> row = b.GetRowSpan(y);
+                    Span<float> row = b.DangerousGetRowSpan(y);

                    Span<float> s = row.Slice(0, 22);
                    Span<float> d = row.Slice(50, 22);
--- a/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs
+++ b/tests/ImageSharp.Tests/Memory/BufferAreaTests.cs
@ -127,7 +127,7 @@ namespace SixLabors.ImageSharp.Tests.Memory

            for (int y = 0; y < 13; y++)
            {
-                Span<int> row = buffer.GetRowSpan(y);
+                Span<int> row = buffer.DangerousGetRowSpan(y);
                Assert.True(row.SequenceEqual(emptyRow));
            }
        }
@ -151,7 +151,7 @@ namespace SixLabors.ImageSharp.Tests.Memory

            for (int y = region.Rectangle.Y; y < region.Rectangle.Bottom; y++)
            {
-                Span<int> span = buffer.GetRowSpan(y).Slice(region.Rectangle.X, region.Width);
+                Span<int> span = buffer.DangerousGetRowSpan(y).Slice(region.Rectangle.X, region.Width);
                Assert.True(span.SequenceEqual(new int[region.Width]));
            }
        }
--- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
@ -429,8 +429,8 @@ namespace SixLabors.ImageSharp.Tests

            for (int y = 0; y < expected.Height; y++)
            {
-                Span<T> expectedRow = expected.GetRowSpan(y);
-                Span<T> actualRow = actual.GetRowSpan(y);
+                Span<T> expectedRow = expected.DangerousGetRowSpan(y);
+                Span<T> actualRow = actual.DangerousGetRowSpan(y);
                for (int x = 0; x < expectedRow.Length; x++)
                {
                    T expectedVal = expectedRow[x];