Merge branch 'master' into webp

src/ImageSharp/Compression/Zlib/Deflater.cs

@@ -222,7 +222,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// The number of compressed bytes added to the output, or 0 if either
         /// <see cref="IsNeedingInput"/> or <see cref="IsFinished"/> returns true or length is zero.
         /// </returns>
-        public int Deflate(byte[] output, int offset, int length)
+        public int Deflate(Span<byte> output, int offset, int length)
         {
             int origLength = length;
 

src/ImageSharp/Compression/Zlib/DeflaterEngine.cs

@@ -130,9 +130,9 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// This array contains the part of the uncompressed stream that
         /// is of relevance. The current character is indexed by strstart.
         /// </summary>
-        private IManagedByteBuffer windowMemoryOwner;
+        private IMemoryOwner<byte> windowMemoryOwner;
         private MemoryHandle windowMemoryHandle;
-        private readonly byte[] window;
+        private readonly Memory<byte> window;
         private readonly byte* pinnedWindowPointer;
 
         private int maxChain;
@@ -153,19 +153,19 @@ namespace SixLabors.ImageSharp.Compression.Zlib
 
             // Create pinned pointers to the various buffers to allow indexing
             // without bounds checks.
-            this.windowMemoryOwner = memoryAllocator.AllocateManagedByteBuffer(2 * DeflaterConstants.WSIZE);
-            this.window = this.windowMemoryOwner.Array;
-            this.windowMemoryHandle = this.windowMemoryOwner.Memory.Pin();
+            this.windowMemoryOwner = memoryAllocator.Allocate<byte>(2 * DeflaterConstants.WSIZE);
+            this.window = this.windowMemoryOwner.Memory;
+            this.windowMemoryHandle = this.window.Pin();
             this.pinnedWindowPointer = (byte*)this.windowMemoryHandle.Pointer;
 
             this.headMemoryOwner = memoryAllocator.Allocate<short>(DeflaterConstants.HASH_SIZE);
             this.head = this.headMemoryOwner.Memory;
-            this.headMemoryHandle = this.headMemoryOwner.Memory.Pin();
+            this.headMemoryHandle = this.head.Pin();
             this.pinnedHeadPointer = (short*)this.headMemoryHandle.Pointer;
 
             this.prevMemoryOwner = memoryAllocator.Allocate<short>(DeflaterConstants.WSIZE);
             this.prev = this.prevMemoryOwner.Memory;
-            this.prevMemoryHandle = this.prevMemoryOwner.Memory.Pin();
+            this.prevMemoryHandle = this.prev.Pin();
             this.pinnedPrevPointer = (short*)this.prevMemoryHandle.Pointer;
 
             // We start at index 1, to avoid an implementation deficiency, that
@@ -303,7 +303,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     case DeflaterConstants.DEFLATE_STORED:
                         if (this.strstart > this.blockStart)
                         {
-                            this.huffman.FlushStoredBlock(this.window, this.blockStart, this.strstart - this.blockStart, false);
+                            this.huffman.FlushStoredBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, false);
                             this.blockStart = this.strstart;
                         }
 
@@ -313,7 +313,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     case DeflaterConstants.DEFLATE_FAST:
                         if (this.strstart > this.blockStart)
                         {
-                            this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, false);
+                            this.huffman.FlushBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, false);
                             this.blockStart = this.strstart;
                         }
 
@@ -327,7 +327,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
 
                         if (this.strstart > this.blockStart)
                         {
-                            this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, false);
+                            this.huffman.FlushBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, false);
                             this.blockStart = this.strstart;
                         }
 
@@ -362,7 +362,10 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     more = this.inputEnd - this.inputOff;
                 }
 
-                Buffer.BlockCopy(this.inputBuf, this.inputOff, this.window, this.strstart + this.lookahead, more);
+                Unsafe.CopyBlockUnaligned(
+                    ref this.window.Span[this.strstart + this.lookahead],
+                    ref this.inputBuf[this.inputOff],
+                    unchecked((uint)more));
 
                 this.inputOff += more;
                 this.lookahead += more;
@@ -426,7 +429,11 @@ namespace SixLabors.ImageSharp.Compression.Zlib
 
         private void SlideWindow()
         {
-            Unsafe.CopyBlockUnaligned(ref this.window[0], ref this.window[DeflaterConstants.WSIZE], DeflaterConstants.WSIZE);
+            Unsafe.CopyBlockUnaligned(
+                ref this.window.Span[0],
+                ref this.window.Span[DeflaterConstants.WSIZE],
+                DeflaterConstants.WSIZE);
+
             this.matchStart -= DeflaterConstants.WSIZE;
             this.strstart -= DeflaterConstants.WSIZE;
             this.blockStart -= DeflaterConstants.WSIZE;
@@ -663,7 +670,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     lastBlock = false;
                 }
 
-                this.huffman.FlushStoredBlock(this.window, this.blockStart, storedLength, lastBlock);
+                this.huffman.FlushStoredBlock(this.window.Span, this.blockStart, storedLength, lastBlock);
                 this.blockStart += storedLength;
                 return !(lastBlock || storedLength == 0);
             }
@@ -683,7 +690,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                 if (this.lookahead == 0)
                 {
                     // We are flushing everything
-                    this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, finish);
+                    this.huffman.FlushBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, finish);
                     this.blockStart = this.strstart;
                     return false;
                 }
@@ -743,7 +750,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                 if (this.huffman.IsFull())
                 {
                     bool lastBlock = finish && (this.lookahead == 0);
-                    this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, lastBlock);
+                    this.huffman.FlushBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, lastBlock);
                     this.blockStart = this.strstart;
                     return !lastBlock;
                 }
@@ -771,7 +778,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     this.prevAvailable = false;
 
                     // We are flushing everything
-                    this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, finish);
+                    this.huffman.FlushBlock(this.window.Span, this.blockStart, this.strstart - this.blockStart, finish);
                     this.blockStart = this.strstart;
                     return false;
                 }
@@ -846,7 +853,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                     }
 
                     bool lastBlock = finish && (this.lookahead == 0) && !this.prevAvailable;
-                    this.huffman.FlushBlock(this.window, this.blockStart, len, lastBlock);
+                    this.huffman.FlushBlock(this.window.Span, this.blockStart, len, lastBlock);
                     this.blockStart += len;
                     return !lastBlock;
                 }

src/ImageSharp/Compression/Zlib/DeflaterHuffman.cs

@@ -41,11 +41,11 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         private Tree blTree;
 
         // Buffer for distances
-        private readonly IMemoryOwner<short> distanceManagedBuffer;
+        private readonly IMemoryOwner<short> distanceMemoryOwner;
         private readonly short* pinnedDistanceBuffer;
         private MemoryHandle distanceBufferHandle;
 
-        private readonly IMemoryOwner<short> literalManagedBuffer;
+        private readonly IMemoryOwner<short> literalMemoryOwner;
         private readonly short* pinnedLiteralBuffer;
         private MemoryHandle literalBufferHandle;
 
@@ -65,12 +65,12 @@ namespace SixLabors.ImageSharp.Compression.Zlib
             this.distTree = new Tree(memoryAllocator, DistanceNumber, 1, 15);
             this.blTree = new Tree(memoryAllocator, BitLengthNumber, 4, 7);
 
-            this.distanceManagedBuffer = memoryAllocator.Allocate<short>(BufferSize);
-            this.distanceBufferHandle = this.distanceManagedBuffer.Memory.Pin();
+            this.distanceMemoryOwner = memoryAllocator.Allocate<short>(BufferSize);
+            this.distanceBufferHandle = this.distanceMemoryOwner.Memory.Pin();
             this.pinnedDistanceBuffer = (short*)this.distanceBufferHandle.Pointer;
 
-            this.literalManagedBuffer = memoryAllocator.Allocate<short>(BufferSize);
-            this.literalBufferHandle = this.literalManagedBuffer.Memory.Pin();
+            this.literalMemoryOwner = memoryAllocator.Allocate<short>(BufferSize);
+            this.literalBufferHandle = this.literalMemoryOwner.Memory.Pin();
             this.pinnedLiteralBuffer = (short*)this.literalBufferHandle.Pointer;
         }
 
@@ -239,7 +239,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <param name="storedLength">Count of bytes to write</param>
         /// <param name="lastBlock">True if this is the last block</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void FlushStoredBlock(byte[] stored, int storedOffset, int storedLength, bool lastBlock)
+        public void FlushStoredBlock(ReadOnlySpan<byte> stored, int storedOffset, int storedLength, bool lastBlock)
         {
             this.Pending.WriteBits((DeflaterConstants.STORED_BLOCK << 1) + (lastBlock ? 1 : 0), 3);
             this.Pending.AlignToByte();
@@ -256,7 +256,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <param name="storedOffset">Index of first byte to flush</param>
         /// <param name="storedLength">Count of bytes to flush</param>
         /// <param name="lastBlock">True if this is the last block</param>
-        public void FlushBlock(byte[] stored, int storedOffset, int storedLength, bool lastBlock)
+        public void FlushBlock(ReadOnlySpan<byte> stored, int storedOffset, int storedLength, bool lastBlock)
         {
             this.literalTree.Frequencies[EofSymbol]++;
 
@@ -286,13 +286,13 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                 + this.extraBits;
 
             int static_len = this.extraBits;
-            ref byte staticLLengthRef = ref MemoryMarshal.GetReference<byte>(StaticLLength);
+            ref byte staticLLengthRef = ref MemoryMarshal.GetReference(StaticLLength);
             for (int i = 0; i < LiteralNumber; i++)
             {
                 static_len += this.literalTree.Frequencies[i] * Unsafe.Add(ref staticLLengthRef, i);
             }
 
-            ref byte staticDLengthRef = ref MemoryMarshal.GetReference<byte>(StaticDLength);
+            ref byte staticDLengthRef = ref MemoryMarshal.GetReference(StaticDLength);
             for (int i = 0; i < DistanceNumber; i++)
             {
                 static_len += this.distTree.Frequencies[i] * Unsafe.Add(ref staticDLengthRef, i);
@@ -419,9 +419,9 @@ namespace SixLabors.ImageSharp.Compression.Zlib
             {
                 this.Pending.Dispose();
                 this.distanceBufferHandle.Dispose();
-                this.distanceManagedBuffer.Dispose();
+                this.distanceMemoryOwner.Dispose();
                 this.literalBufferHandle.Dispose();
-                this.literalManagedBuffer.Dispose();
+                this.literalMemoryOwner.Dispose();
 
                 this.literalTree.Dispose();
                 this.blTree.Dispose();
@@ -484,7 +484,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
             private IMemoryOwner<short> frequenciesMemoryOwner;
             private MemoryHandle frequenciesMemoryHandle;
 
-            private IManagedByteBuffer lengthsMemoryOwner;
+            private IMemoryOwner<byte> lengthsMemoryOwner;
             private MemoryHandle lengthsMemoryHandle;
 
             public Tree(MemoryAllocator memoryAllocator, int elements, int minCodes, int maxLength)
@@ -498,7 +498,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
                 this.frequenciesMemoryHandle = this.frequenciesMemoryOwner.Memory.Pin();
                 this.Frequencies = (short*)this.frequenciesMemoryHandle.Pointer;
 
-                this.lengthsMemoryOwner = memoryAllocator.AllocateManagedByteBuffer(elements);
+                this.lengthsMemoryOwner = memoryAllocator.Allocate<byte>(elements);
                 this.lengthsMemoryHandle = this.lengthsMemoryOwner.Memory.Pin();
                 this.Length = (byte*)this.lengthsMemoryHandle.Pointer;
 

src/ImageSharp/Compression/Zlib/DeflaterOutputStream.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.IO;
 using SixLabors.ImageSharp.Memory;
 
@@ -14,8 +15,8 @@ namespace SixLabors.ImageSharp.Compression.Zlib
     internal sealed class DeflaterOutputStream : Stream
     {
         private const int BufferLength = 512;
-        private IManagedByteBuffer memoryOwner;
-        private readonly byte[] buffer;
+        private IMemoryOwner<byte> memoryOwner;
+        private readonly Memory<byte> buffer;
         private Deflater deflater;
         private readonly Stream rawStream;
         private bool isDisposed;
@@ -29,8 +30,8 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         public DeflaterOutputStream(MemoryAllocator memoryAllocator, Stream rawStream, int compressionLevel)
         {
             this.rawStream = rawStream;
-            this.memoryOwner = memoryAllocator.AllocateManagedByteBuffer(BufferLength);
-            this.buffer = this.memoryOwner.Array;
+            this.memoryOwner = memoryAllocator.Allocate<byte>(BufferLength);
+            this.buffer = this.memoryOwner.Memory;
             this.deflater = new Deflater(memoryAllocator, compressionLevel);
         }
 
@@ -49,15 +50,9 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <inheritdoc/>
         public override long Position
         {
-            get
-            {
-                return this.rawStream.Position;
-            }
+            get => this.rawStream.Position;
 
-            set
-            {
-                throw new NotSupportedException();
-            }
+            set => throw new NotSupportedException();
         }
 
         /// <inheritdoc/>
@@ -93,14 +88,14 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         {
             while (flushing || !this.deflater.IsNeedingInput)
             {
-                int deflateCount = this.deflater.Deflate(this.buffer, 0, BufferLength);
+                int deflateCount = this.deflater.Deflate(this.buffer.Span, 0, BufferLength);
 
                 if (deflateCount <= 0)
                 {
                     break;
                 }
 
-                this.rawStream.Write(this.buffer, 0, deflateCount);
+                this.rawStream.Write(this.buffer.Span.Slice(0, deflateCount));
             }
 
             if (!this.deflater.IsNeedingInput)
@@ -114,13 +109,13 @@ namespace SixLabors.ImageSharp.Compression.Zlib
             this.deflater.Finish();
             while (!this.deflater.IsFinished)
             {
-                int len = this.deflater.Deflate(this.buffer, 0, BufferLength);
+                int len = this.deflater.Deflate(this.buffer.Span, 0, BufferLength);
                 if (len <= 0)
                 {
                     break;
                 }
 
-                this.rawStream.Write(this.buffer, 0, len);
+                this.rawStream.Write(this.buffer.Span.Slice(0, len));
             }
 
             if (!this.deflater.IsFinished)

src/ImageSharp/Compression/Zlib/DeflaterPendingBuffer.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Compression.Zlib
@@ -13,9 +14,9 @@ namespace SixLabors.ImageSharp.Compression.Zlib
     /// </summary>
     internal sealed unsafe class DeflaterPendingBuffer : IDisposable
     {
-        private readonly byte[] buffer;
+        private readonly Memory<byte> buffer;
         private readonly byte* pinnedBuffer;
-        private IManagedByteBuffer bufferMemoryOwner;
+        private IMemoryOwner<byte> bufferMemoryOwner;
         private MemoryHandle bufferMemoryHandle;
 
         private int start;
@@ -29,9 +30,9 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <param name="memoryAllocator">The memory allocator to use for buffer allocations.</param>
         public DeflaterPendingBuffer(MemoryAllocator memoryAllocator)
         {
-            this.bufferMemoryOwner = memoryAllocator.AllocateManagedByteBuffer(DeflaterConstants.PENDING_BUF_SIZE);
-            this.buffer = this.bufferMemoryOwner.Array;
-            this.bufferMemoryHandle = this.bufferMemoryOwner.Memory.Pin();
+            this.bufferMemoryOwner = memoryAllocator.Allocate<byte>(DeflaterConstants.PENDING_BUF_SIZE);
+            this.buffer = this.bufferMemoryOwner.Memory;
+            this.bufferMemoryHandle = this.buffer.Pin();
             this.pinnedBuffer = (byte*)this.bufferMemoryHandle.Pointer;
         }
 
@@ -70,9 +71,13 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <param name="offset">The offset of first byte to write.</param>
         /// <param name="length">The number of bytes to write.</param>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void WriteBlock(byte[] block, int offset, int length)
+        public void WriteBlock(ReadOnlySpan<byte> block, int offset, int length)
         {
-            Unsafe.CopyBlockUnaligned(ref this.buffer[this.end], ref block[offset], unchecked((uint)length));
+            Unsafe.CopyBlockUnaligned(
+                ref this.buffer.Span[this.end],
+                ref MemoryMarshal.GetReference(block.Slice(offset)),
+                unchecked((uint)length));
+
             this.end += length;
         }
 
@@ -136,7 +141,7 @@ namespace SixLabors.ImageSharp.Compression.Zlib
         /// <param name="offset">The offset into output array.</param>
         /// <param name="length">The maximum number of bytes to store.</param>
         /// <returns>The number of bytes flushed.</returns>
-        public int Flush(byte[] output, int offset, int length)
+        public int Flush(Span<byte> output, int offset, int length)
         {
             if (this.BitCount >= 8)
             {
@@ -149,13 +154,19 @@ namespace SixLabors.ImageSharp.Compression.Zlib
             {
                 length = this.end - this.start;
 
-                Unsafe.CopyBlockUnaligned(ref output[offset], ref this.buffer[this.start], unchecked((uint)length));
+                Unsafe.CopyBlockUnaligned(
+                    ref output[offset],
+                    ref this.buffer.Span[this.start],
+                    unchecked((uint)length));
                 this.start = 0;
                 this.end = 0;
             }
             else
             {
-                Unsafe.CopyBlockUnaligned(ref output[offset], ref this.buffer[this.start], unchecked((uint)length));
+                Unsafe.CopyBlockUnaligned(
+                    ref output[offset],
+                    ref this.buffer.Span[this.start],
+                    unchecked((uint)length));
                 this.start += length;
             }
 

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -348,17 +348,16 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             where TPixel : unmanaged, IPixel<TPixel>
         {
             bool isL8 = typeof(TPixel) == typeof(L8);
-            using (IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.AllocateManagedByteBuffer(ColorPaletteSize8Bit, AllocationOptions.Clean))
+            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.Allocate<byte>(ColorPaletteSize8Bit, AllocationOptions.Clean);
+            Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
+
+            if (isL8)
             {
-                Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
-                if (isL8)
-                {
-                    this.Write8BitGray(stream, image, colorPalette);
-                }
-                else
-                {
-                    this.Write8BitColor(stream, image, colorPalette);
-                }
+                this.Write8BitGray(stream, image, colorPalette);
+            }
+            else
+            {
+                this.Write8BitColor(stream, image, colorPalette);
             }
         }
 
@@ -442,7 +441,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 MaxColors = 16
             });
             using IndexedImageFrame<TPixel> quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(image, image.Bounds());
-            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.AllocateManagedByteBuffer(ColorPaletteSize4Bit, AllocationOptions.Clean);
+            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.Allocate<byte>(ColorPaletteSize4Bit, AllocationOptions.Clean);
 
             Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
             ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
@@ -486,7 +485,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
                 MaxColors = 2
             });
             using IndexedImageFrame<TPixel> quantized = frameQuantizer.BuildPaletteAndQuantizeFrame(image, image.Bounds());
-            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.AllocateManagedByteBuffer(ColorPaletteSize1Bit, AllocationOptions.Clean);
+            using IMemoryOwner<byte> colorPaletteBuffer = this.memoryAllocator.Allocate<byte>(ColorPaletteSize1Bit, AllocationOptions.Clean);
 
             Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
             ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -928,9 +929,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         {
             int length = remaining;
 
-            using (IManagedByteBuffer huffmanData = this.Configuration.MemoryAllocator.AllocateManagedByteBuffer(256, AllocationOptions.Clean))
+            using (IMemoryOwner<byte> huffmanData = this.Configuration.MemoryAllocator.Allocate<byte>(256, AllocationOptions.Clean))
             {
-                ref byte huffmanDataRef = ref MemoryMarshal.GetReference(huffmanData.GetSpan());
+                Span<byte> huffmanDataSpan = huffmanData.GetSpan();
+                ref byte huffmanDataRef = ref MemoryMarshal.GetReference(huffmanDataSpan);
                 for (int i = 2; i < remaining;)
                 {
                     byte huffmanTableSpec = (byte)stream.ReadByte();
@@ -949,11 +951,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                         JpegThrowHelper.ThrowInvalidImageContentException("Bad Huffman Table index.");
                     }
 
-                    stream.Read(huffmanData.Array, 0, 16);
+                    stream.Read(huffmanDataSpan, 0, 16);
 
-                    using (IManagedByteBuffer codeLengths = this.Configuration.MemoryAllocator.AllocateManagedByteBuffer(17, AllocationOptions.Clean))
+                    using (IMemoryOwner<byte> codeLengths = this.Configuration.MemoryAllocator.Allocate<byte>(17, AllocationOptions.Clean))
                     {
-                        ref byte codeLengthsRef = ref MemoryMarshal.GetReference(codeLengths.GetSpan());
+                        Span<byte> codeLengthsSpan = codeLengths.GetSpan();
+                        ref byte codeLengthsRef = ref MemoryMarshal.GetReference(codeLengthsSpan);
                         int codeLengthSum = 0;
 
                         for (int j = 1; j < 17; j++)
@@ -968,17 +971,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                             JpegThrowHelper.ThrowInvalidImageContentException("Huffman table has excessive length.");
                         }
 
-                        using (IManagedByteBuffer huffmanValues = this.Configuration.MemoryAllocator.AllocateManagedByteBuffer(256, AllocationOptions.Clean))
+                        using (IMemoryOwner<byte> huffmanValues = this.Configuration.MemoryAllocator.Allocate<byte>(256, AllocationOptions.Clean))
                         {
-                            stream.Read(huffmanValues.Array, 0, codeLengthSum);
+                            Span<byte> huffmanValuesSpan = huffmanValues.GetSpan();
+                            stream.Read(huffmanValuesSpan, 0, codeLengthSum);
 
                             i += 17 + codeLengthSum;
 
                             this.BuildHuffmanTable(
                                 tableType == 0 ? this.dcHuffmanTables : this.acHuffmanTables,
                                 tableIndex,
-                                codeLengths.GetSpan(),
-                                huffmanValues.GetSpan());
+                                codeLengthsSpan,
+                                huffmanValuesSpan);
                         }
                     }
                 }

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -393,8 +393,8 @@ namespace SixLabors.ImageSharp.Formats.Png
                 this.bytesPerSample = this.header.BitDepth / 8;
             }
 
-            this.previousScanline = this.memoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean);
-            this.scanline = this.Configuration.MemoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean);
+            this.previousScanline = this.memoryAllocator.Allocate<byte>(this.bytesPerScanline, AllocationOptions.Clean);
+            this.scanline = this.Configuration.MemoryAllocator.Allocate<byte>(this.bytesPerScanline, AllocationOptions.Clean);
         }
 
         /// <summary>

src/ImageSharp/Formats/Tiff/Writers/TiffBiColorWriter{TPixel}.cs

@@ -60,7 +60,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
             {
                 // Write uncompressed image.
                 int bytesPerStrip = this.BytesPerRow * height;
-                this.bitStrip ??= this.MemoryAllocator.AllocateManagedByteBuffer(bytesPerStrip);
+                this.bitStrip ??= this.MemoryAllocator.Allocate<byte>(bytesPerStrip);
                 this.pixelsAsGray ??= this.MemoryAllocator.Allocate<byte>(width);
                 Span<byte> pixelAsGraySpan = this.pixelsAsGray.GetSpan();
 

src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter{TPixel}.cs

@@ -89,7 +89,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
             else
             {
                 int stripPixels = width * height;
-                this.indexedPixelsBuffer ??= this.MemoryAllocator.AllocateManagedByteBuffer(stripPixels);
+                this.indexedPixelsBuffer ??= this.MemoryAllocator.Allocate<byte>(stripPixels);
                 Span<byte> indexedPixels = this.indexedPixelsBuffer.GetSpan();
                 int lastRow = y + height;
                 int indexedPixelsRowIdx = 0;
@@ -113,7 +113,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Writers
 
         private void AddColorMapTag()
         {
-            using IMemoryOwner<byte> colorPaletteBuffer = this.MemoryAllocator.AllocateManagedByteBuffer(this.colorPaletteBytes);
+            using IMemoryOwner<byte> colorPaletteBuffer = this.MemoryAllocator.Allocate<byte>(this.colorPaletteBytes);
             Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
 
             ReadOnlySpan<TPixel> quantizedColors = this.quantizedImage.Palette.Span;

src/ImageSharp/Memory/Allocators/MemoryAllocator.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Memory
         protected internal abstract int GetBufferCapacityInBytes();
 
         /// <summary>
-        /// Allocates an <see cref="IMemoryOwner{T}" />, holding a <see cref="System.Memory{T}"/> of length <paramref name="length"/>.
+        /// Allocates an <see cref="IMemoryOwner{T}" />, holding a <see cref="Memory{T}"/> of length <paramref name="length"/>.
         /// </summary>
         /// <typeparam name="T">Type of the data stored in the buffer.</typeparam>
         /// <param name="length">Size of the buffer to allocate.</param>

tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColorTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using SixLabors.ImageSharp.Formats.Tiff;
 using SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation;
@@ -242,19 +243,31 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff.PhotometricInterpretation
         [MemberData(nameof(Rgb4Data))]
         [MemberData(nameof(Rgb8Data))]
         [MemberData(nameof(Rgb484_Data))]
-        public void Decode_WritesPixelData(byte[][] inputData, TiffBitsPerSample bitsPerSample, int left, int top, int width, int height, Rgba32[][] expectedResult)
-        {
-            AssertDecode(expectedResult, pixels =>
+        public void Decode_WritesPixelData(
+            byte[][] inputData,
+            TiffBitsPerSample bitsPerSample,
+            int left,
+            int top,
+            int width,
+            int height,
+            Rgba32[][] expectedResult)
+            => AssertDecode(
+                expectedResult,
+                pixels =>
                 {
-                    var buffers = new IManagedByteBuffer[inputData.Length];
+                    var buffers = new IMemoryOwner<byte>[inputData.Length];
                     for (int i = 0; i < buffers.Length; i++)
                     {
-                        buffers[i] = Configuration.Default.MemoryAllocator.AllocateManagedByteBuffer(inputData[i].Length);
+                        buffers[i] = Configuration.Default.MemoryAllocator.Allocate<byte>(inputData[i].Length);
                         ((Span<byte>)inputData[i]).CopyTo(buffers[i].GetSpan());
                     }
 
                     new RgbPlanarTiffColor<Rgba32>(bitsPerSample).Decode(buffers, pixels, left, top, width, height);
+
+                    foreach (IMemoryOwner<byte> buffer in buffers)
+                    {
+                        buffer.Dispose();
+                    }
                 });
-        }
     }
 }