@ -3,6 +3,7 @@
using System.Buffers ; using System.Buffers ;
using System.Runtime.CompilerServices ; using System.Runtime.CompilerServices ;
using System.Runtime.InteropServices ;
using SixLabors.ImageSharp.Memory ; using SixLabors.ImageSharp.Memory ;
namespace SixLabors.ImageSharp.IO ; namespace SixLabors.ImageSharp.IO ;
@ -14,42 +15,19 @@ namespace SixLabors.ImageSharp.IO;
/// </summary>
/// </summary>
internal sealed class ChunkedMemoryStream : Stream internal sealed class ChunkedMemoryStream : Stream
{ {
// The memory allocator.
private readonly MemoryChunkBuffer memoryChunkBuffer ;
private readonly MemoryAllocator allocator ; private long length ;
private long position ;
// Data
private int bufferIndex ;
private MemoryChunk ? memoryChunk ; private int chunkIndex ;
// The total number of allocated chunks
private int chunkCount ;
// The length of the largest contiguous buffer that can be handled by the allocator.
private readonly int allocatorCapacity ;
// Has the stream been disposed.
private bool isDisposed ; private bool isDisposed ;
// Current chunk to write to
private MemoryChunk ? writeChunk ;
// Offset into chunk to write to
private int writeOffset ;
// Current chunk to read from
private MemoryChunk ? readChunk ;
// Offset into chunk to read from
private int readOffset ;
/// <summary>
/// <summary>
/// Initializes a new instance of the <see cref="ChunkedMemoryStream"/> class.
/// Initializes a new instance of the <see cref="ChunkedMemoryStream"/> class.
/// </summary>
/// </summary>
/// <param name="allocator">The memory allocator.</param>
/// <param name="allocator">The memory allocator.</param>
public ChunkedMemoryStream ( MemoryAllocator allocator ) public ChunkedMemoryStream ( MemoryAllocator allocator )
{ = > this . memoryChunkBuffer = new ( allocator ) ;
this . allocatorCapacity = allocator . GetBufferCapacityInBytes ( ) ;
this . allocator = allocator ;
}
/// <inheritdoc/>
/// <inheritdoc/>
public override bool CanRead = > ! this . isDisposed ; public override bool CanRead = > ! this . isDisposed ;
@ -66,25 +44,7 @@ internal sealed class ChunkedMemoryStream : Stream
get get
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
return this . length ;
int length = 0 ;
MemoryChunk ? chunk = this . memoryChunk ;
while ( chunk ! = null )
{
MemoryChunk ? next = chunk . Next ;
if ( next ! = null )
{
length + = chunk . Length ;
}
else
{
length + = this . writeOffset ;
}
chunk = next ;
}
return length ;
} }
} }
@ -94,93 +54,35 @@ internal sealed class ChunkedMemoryStream : Stream
get get
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
return this . position ;
if ( this . readChunk is null )
{
return 0 ;
}
int pos = 0 ;
MemoryChunk ? chunk = this . memoryChunk ;
while ( chunk ! = this . readChunk & & chunk is not null )
{
pos + = chunk . Length ;
chunk = chunk . Next ;
}
pos + = this . readOffset ;
return pos ;
} }
set set
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
this . SetPosition ( value ) ;
if ( value < 0 )
{
ThrowArgumentOutOfRange ( nameof ( value ) ) ;
}
// Back up current position in case new position is out of range
MemoryChunk ? backupReadChunk = this . readChunk ;
int backupReadOffset = this . readOffset ;
this . readChunk = null ;
this . readOffset = 0 ;
int leftUntilAtPos = ( int ) value ;
MemoryChunk ? chunk = this . memoryChunk ;
while ( chunk ! = null )
{
if ( ( leftUntilAtPos < chunk . Length )
| | ( ( leftUntilAtPos = = chunk . Length )
& & ( chunk . Next is null ) ) )
{
// The desired position is in this chunk
this . readChunk = chunk ;
this . readOffset = leftUntilAtPos ;
break ;
}
leftUntilAtPos - = chunk . Length ;
chunk = chunk . Next ;
}
if ( this . readChunk is null )
{
// Position is out of range
this . readChunk = backupReadChunk ;
this . readOffset = backupReadOffset ;
}
} }
} }
/// <inheritdoc/>
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)] public override void Flush ( )
{
}
/// <inheritdoc/>
public override long Seek ( long offset , SeekOrigin origin ) public override long Seek ( long offset , SeekOrigin origin )
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
switch ( origin ) this . Position = origin switch
{ {
case SeekOrigin . Begin : SeekOrigin . Begin = > ( int ) offset ,
this . Position = offset ; SeekOrigin . Current = > ( int ) ( this . Position + offset ) ,
break ; SeekOrigin . End = > ( int ) ( this . Length + offset ) ,
_ = > throw new ArgumentOutOfRangeException ( nameof ( offset ) ) ,
case SeekOrigin . Current : } ;
this . Position + = offset ;
break ;
case SeekOrigin . End :
this . Position = this . Length + offset ;
break ;
default :
ThrowInvalidSeek ( ) ;
break ;
}
return this . P osition; return this . position ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
@ -188,39 +90,13 @@ internal sealed class ChunkedMemoryStream : Stream
= > throw new NotSupportedException ( ) ; = > throw new NotSupportedException ( ) ;
/// <inheritdoc/>
/// <inheritdoc/>
protected override void Dispose ( bool disposing ) public override int ReadByte ( )
{
if ( this . isDisposed )
{
return ;
}
try
{
this . isDisposed = true ;
if ( disposing )
{
ReleaseMemoryChunks ( this . memoryChunk ) ;
}
this . memoryChunk = null ;
this . writeChunk = null ;
this . readChunk = null ;
this . chunkCount = 0 ;
}
finally
{
base . Dispose ( disposing ) ;
}
}
/// <inheritdoc/>
public override void Flush ( )
{ {
Unsafe . SkipInit ( out byte b ) ;
return this . Read ( MemoryMarshal . CreateSpan ( ref b , 1 ) ) = = 1 ? b : - 1 ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int Read ( byte [ ] buffer , int offset , int count ) public override int Read ( byte [ ] buffer , int offset , int count )
{ {
Guard . NotNull ( buffer , nameof ( buffer ) ) ; Guard . NotNull ( buffer , nameof ( buffer ) ) ;
@ -230,111 +106,70 @@ internal sealed class ChunkedMemoryStream : Stream
const string bufferMessage = "Offset subtracted from the buffer length is less than count." ; const string bufferMessage = "Offset subtracted from the buffer length is less than count." ;
Guard . IsFalse ( buffer . Length - offset < count , nameof ( buffer ) , bufferMessage ) ; Guard . IsFalse ( buffer . Length - offset < count , nameof ( buffer ) , bufferMessage ) ;
return this . ReadImpl ( buffer . AsSpan ( offset , count ) ) ; return this . Read ( buffer . AsSpan ( offset , count ) ) ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)] public override int Read ( Span < byte > buffer )
public override int Read ( Span < byte > buffer ) = > this . ReadImpl ( buffer ) ;
private int ReadImpl ( Span < byte > buffer )
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
if ( this . readChunk is null ) int offset = 0 ;
{ int count = buffer . Length ;
if ( this . memoryChunk is null )
{
return 0 ;
}
this . readChunk = this . memoryChunk ; long remaining = this . length - this . position ;
this . readOffset = 0 ; if ( remaining < = 0 )
{
// Already at the end of the stream, nothing to read
return 0 ;
} }
IMemoryOwner < byte > chunkBuffer = this . readChunk . Buffer ; if ( remaining > count )
int chunkSize = this . readChunk . Length ;
if ( this . readChunk . Next is null )
{ {
chunkSize = this . writeOffse t; remaining = count ;
} }
// 'remaining' can be less than the provided buffer length.
int bytesToRead = ( int ) remaining ;
int bytesRead = 0 ; int bytesRead = 0 ;
int offset = 0 ; while ( bytesToRead > 0 & & this . bufferIndex ! = this . memoryChunkBuffer . Length )
int count = buffer . Length ;
while ( count > 0 )
{ {
if ( this . readOffset = = chunkSize ) bool moveToNextChunk = false ;
MemoryChunk chunk = this . memoryChunkBuffer [ this . bufferIndex ] ;
int n = bytesToRead ;
int remainingBytesInCurrentChunk = chunk . Length - this . chunkIndex ;
if ( n > = remainingBytesInCurrentChunk )
{ {
// Exit if no more chunks are currently available
n = remainingBytesInCurrentChunk ;
if ( this . readChunk . Next is null ) moveToNextChunk = true ;
{
break ;
}
this . readChunk = this . readChunk . Next ;
this . readOffset = 0 ;
chunkBuffer = this . readChunk . Buffer ;
chunkSize = this . readChunk . Length ;
if ( this . readChunk . Next is null )
{
chunkSize = this . writeOffset ;
}
} }
int readCount = Math . Min ( count , chunkSize - this . readOffset ) ; // Read n bytes from the current chunk
chunkBuffer . Slice ( this . readOffset , readCount ) . CopyTo ( buffer [ offset . . ] ) ; chunk . Buffer . Memory . Span . Slice ( this . chunkIndex , n ) . CopyTo ( buffer . Slice ( offset , n ) ) ;
offset + = readCount ; bytesToRead - = n ;
count - = readCount ; offset + = n ;
this . readOffset + = readCount ; bytesRead + = n ;
bytesRead + = readCount ;
}
return bytesRead ;
}
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int ReadByte ( )
{
this . EnsureNotDisposed ( ) ;
if ( this . readChunk is null ) if ( moveToNextChunk )
{
if ( this . memoryChunk is null )
{ {
return 0 ; this . chunkIndex = 0 ;
this . bufferIndex + + ;
} }
else
this . readChunk = this . memoryChunk ;
this . readOffset = 0 ;
}
IMemoryOwner < byte > chunkBuffer = this . readChunk . Buffer ;
int chunkSize = this . readChunk . Length ;
if ( this . readChunk . Next is null )
{
chunkSize = this . writeOffset ;
}
if ( this . readOffset = = chunkSize )
{
// Exit if no more chunks are currently available
if ( this . readChunk . Next is null )
{ {
return - 1 ; this . chunkIndex + = n ;
} }
this . readChunk = this . readChunk . Next ;
this . readOffset = 0 ;
chunkBuffer = this . readChunk . Buffer ;
} }
return chunkBuffer . GetSpan ( ) [ this . readOffset + + ] ; this . position + = bytesRead ;
return bytesRead ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)] public override void WriteByte ( byte value )
= > this . Write ( MemoryMarshal . CreateSpan ( ref value , 1 ) ) ;
/// <inheritdoc/>
public override void Write ( byte [ ] buffer , int offset , int count ) public override void Write ( byte [ ] buffer , int offset , int count )
{ {
Guard . NotNull ( buffer , nameof ( buffer ) ) ; Guard . NotNull ( buffer , nameof ( buffer ) ) ;
@ -344,157 +179,198 @@ internal sealed class ChunkedMemoryStream : Stream
const string bufferMessage = "Offset subtracted from the buffer length is less than count." ; const string bufferMessage = "Offset subtracted from the buffer length is less than count." ;
Guard . IsFalse ( buffer . Length - offset < count , nameof ( buffer ) , bufferMessage ) ; Guard . IsFalse ( buffer . Length - offset < count , nameof ( buffer ) , bufferMessage ) ;
this . WriteImpl ( buffer . AsSpan ( offset , count ) ) ; this . Write ( buffer . AsSpan ( offset , count ) ) ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
[MethodImpl(MethodImplOptions.AggressiveInlining)] public override void Write ( ReadOnlySpan < byte > buffer )
public override void Write ( ReadOnlySpan < byte > buffer ) = > this . WriteImpl ( buffer ) ;
private void WriteImpl ( ReadOnlySpan < byte > buffer )
{ {
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
if ( this . memoryChunk is null ) int offset = 0 ;
int count = buffer . Length ;
long remaining = this . memoryChunkBuffer . Length - this . position ;
// Ensure we have enough capacity to write the data.
while ( remaining < count )
{ {
this . memoryChunk = this . AllocateMemoryChunk ( ) ; this . memoryChunkBuffer . Expand ( ) ;
this . writeChunk = this . memoryChunk ; remaining = this . memoryChunkBuffer . Length - this . position ;
this . writeOffset = 0 ;
} }
Guard . NotNull ( this . writeChunk ) ; int bytesToWrite = count ;
int bytesWritten = 0 ;
Span < byte > chunkBuffer = this . writeChunk . Buffer . GetSpan ( ) ; while ( bytesToWrite > 0 & & this . bufferIndex ! = this . memoryChunkBuffer . Length )
int chunkSize = this . writeChunk . Length ;
int count = buffer . Length ;
int offset = 0 ;
while ( count > 0 )
{ {
if ( this . writeOffset = = chunkSize ) bool moveToNextChunk = false ;
MemoryChunk chunk = this . memoryChunkBuffer [ this . bufferIndex ] ;
int n = bytesToWrite ;
int remainingBytesInCurrentChunk = chunk . Length - this . chunkIndex ;
if ( n > = remainingBytesInCurrentChunk )
{ {
// Allocate a new chunk if the current one is full
n = remainingBytesInCurrentChunk ;
this . writeChunk . Next = this . AllocateMemoryChunk ( ) ; moveToNextChunk = true ;
this . writeChunk = this . writeChunk . Next ;
this . writeOffset = 0 ;
chunkBuffer = this . writeChunk . Buffer . GetSpan ( ) ;
chunkSize = this . writeChunk . Length ;
} }
int copyCount = Math . Min ( count , chunkSize - this . writeOffset ) ; // Write n bytes to the current chunk
buffer . Slice ( offset , copyCount ) . CopyTo ( chunkBuffer [ this . writeOffset . . ] ) ; buffer . Slice ( offset , n ) . CopyTo ( chunk . Buffer . Slice ( this . chunkIndex , n ) ) ;
bytesToWrite - = n ;
offset + = n ;
bytesWritten + = n ;
offset + = copyCount ; if ( moveToNextChunk )
count - = copyCount ; {
this . writeOffset + = copyCount ; this . chunkIndex = 0 ;
this . bufferIndex + + ;
}
else
{
this . chunkIndex + = n ;
}
} }
this . position + = bytesWritten ;
this . length + = bytesWritten ;
} }
/// <inheritdoc/>
/// <summary>
public override void WriteByte ( byte value ) /// Writes the entire contents of this memory stream to another stream.
/// </summary>
/// <param name="stream">The stream to write this memory stream to.</param>
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is <see langword="null"/>.</exception>
/// <exception cref="ObjectDisposedException">The current or target stream is closed.</exception>
public void WriteTo ( Stream stream )
{ {
Guard . NotNull ( stream , nameof ( stream ) ) ;
this . EnsureNotDisposed ( ) ; this . EnsureNotDisposed ( ) ;
if ( this . memoryChunk is null ) this . Position = 0 ;
long remaining = this . length - this . position ;
if ( remaining < = 0 )
{ {
this . memoryChunk = this . AllocateMemoryChunk ( ) ; // Already at the end of the stream, nothing to read
this . writeChunk = this . memoryChunk ; return ;
this . writeOffset = 0 ;
} }
Guard . NotNull ( this . writeChunk ) ; int bytesToRead = ( int ) remaining ;
int bytesRead = 0 ;
while ( bytesToRead > 0 & & this . bufferIndex ! = this . memoryChunkBuffer . Length )
{
bool moveToNextChunk = false ;
MemoryChunk chunk = this . memoryChunkBuffer [ this . bufferIndex ] ;
int n = bytesToRead ;
int remainingBytesInCurrentChunk = chunk . Length - this . chunkIndex ;
if ( n > = remainingBytesInCurrentChunk )
{
n = remainingBytesInCurrentChunk ;
moveToNextChunk = true ;
}
IMemoryOwner < byte > chunkBuffer = this . writeChunk . Buffer ; // Read n bytes from the current chunk
int chunkSize = this . writeChunk . Length ; stream . Write ( chunk . Buffer . Memory . Span . Slice ( this . chunkIndex , n ) ) ;
bytesToRead - = n ;
bytesRead + = n ;
if ( this . writeOffset = = chunkSize ) if ( moveToNextChunk )
{ {
// Allocate a new chunk if the current one is full
this . chunkIndex = 0 ;
this . writeChunk . Next = this . AllocateMemoryChunk ( ) ; this . bufferIndex + + ;
this . writeChunk = this . writeChunk . Next ; }
this . writeOffset = 0 ; else
chunkBuffer = this . writeChunk . Buffer ; {
this . chunkIndex + = n ;
}
} }
chunkBuffer . GetSpan ( ) [ this . writeOffset + + ] = value ; this . position + = bytesRead ;
} }
/// <summary>
/// <summary>
/// Copy entire buffer into an arra y.
/// Writes the stream contents to a byte array, regardless of the <see cref="Position"/> propert y.
/// </summary>
/// </summary>
/// <returns>The <see cref="T:byte[]"/>.</returns>
/// <returns>A new <see cref="T:byte[]"/>.</returns>
public byte [ ] ToArray ( ) public byte [ ] ToArray ( )
{ {
int length = ( int ) this . Length ; // This will throw if stream is closed
this . EnsureNotDisposed ( ) ;
byte [ ] copy = new byte [ this . Length ] ; long position = this . position ;
byte [ ] copy = new byte [ this . length ] ;
MemoryChunk ? backupReadChunk = this . readChunk ;
int backupReadOffset = this . readOffset ;
this . readChunk = this . memoryChunk ;
this . readOffset = 0 ;
this . Read ( copy , 0 , length ) ;
this . readChunk = backupReadChunk ;
this . readOffset = backupReadOffset ;
this . Position = 0 ;
_ = this . Read ( copy , 0 , copy . Length ) ;
this . Position = position ;
return copy ; return copy ;
} }
/// <summary>
/// <inheritdoc/>
/// Write remainder of this stream to another stream.
protected override void Dispose ( bool disposing )
/// </summary>
/// <param name="stream">The stream to write to.</param>
public void WriteTo ( Stream stream )
{ {
this . EnsureNotDisposed ( ) ; if ( this . isDisposed )
{
Guard . NotNull ( stream , nameof ( stream ) ) ; return ;
}
if ( this . readChunk is null ) try
{ {
if ( this . memoryChunk is null ) this . isDisposed = true ;
if ( disposing )
{ {
re turn ; this . memoryCh unkBuffe r . Dispose ( ) ;
} }
this . readChunk = this . memoryChunk ; this . bufferIndex = 0 ;
this . readOffset = 0 ; this . chunkIndex = 0 ;
this . position = 0 ;
this . length = 0 ;
}
finally
{
base . Dispose ( disposing ) ;
}
}
private void SetPosition ( long value )
{
long newPosition = value ;
if ( newPosition < 0 )
{
throw new ArgumentOutOfRangeException ( nameof ( value ) ) ;
} }
IMemoryOwner < byte > chunkBuffer = this . readChunk . Buffer ; this . position = newPosition ;
int chunkSize = this . readChunk . Length ;
if ( this . readChunk . Next is null ) // Find the current chunk & current chunk index
int currentChunkIndex = 0 ;
long offset = newPosition ;
// If the new position is greater than the length of the stream, set the position to the end of the stream
if ( offset > 0 & & offset > = this . memoryChunkBuffer . Length )
{ {
chunkSize = this . writeOffset ; this . bufferIndex = this . memoryChunkBuffer . ChunkCount - 1 ;
this . chunkIndex = this . memoryChunkBuffer [ this . bufferIndex ] . Length - 1 ;
return ;
} }
// Following code mirrors Read() logic (readChunk/readOffset should
// Loop through the current chunks, as we increment the chunk index, we subtract the length of the chunk
// point just past last byte of last chunk when done)
// from the offset. Once the offset is less than the length of the chunk, we have found the correct chunk.
// loop until end of chunks is found
while ( offset ! = 0 )
while ( true )
{ {
if ( this . readOffset = = chunkSize ) int chunkLength = this . memoryChunkBuffer [ currentChunkIndex ] . Length ;
if ( offset < chunkLength )
{ {
// Exit if no more chunks are currently available
// Found the correct chunk and the corresponding index
if ( this . readChunk . Next is null ) break ;
{
break ;
}
this . readChunk = this . readChunk . Next ;
this . readOffset = 0 ;
chunkBuffer = this . readChunk . Buffer ;
chunkSize = this . readChunk . Length ;
if ( this . readChunk . Next is null )
{
chunkSize = this . writeOffset ;
}
} }
int writeCount = chunkSize - this . readOffset ; offset - = chunkLength ;
stream . Write ( chunkBuffer . GetSpan ( ) , this . readOffset , writeCount ) ; currentChunkIndex + + ;
this . readOffset = chunkSize ;
} }
this . bufferIndex = currentChunkIndex ;
// Safe to cast here as we know the offset is less than the chunk length.
this . chunkIndex = ( int ) offset ;
} }
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
@ -507,48 +383,66 @@ internal sealed class ChunkedMemoryStream : Stream
} }
[MethodImpl(MethodImplOptions.NoInlining)] [MethodImpl(MethodImplOptions.NoInlining)]
private static void ThrowDisposed ( ) = > throw new ObjectDisposedException ( null , "The stream is closed." ) ; private static void ThrowDisposed ( ) = > throw new ObjectDisposedException ( nameof ( ChunkedMemoryStream ) , "The stream is closed." ) ;
[MethodImpl(MethodImplOptions.NoInlining)] private sealed class MemoryChunkBuffer : IDisposable
private static void ThrowArgumentOutOfRange ( string value ) = > throw new ArgumentOutOfRangeException ( value ) ; {
private readonly List < MemoryChunk > memoryChunks = new ( ) ;
private readonly MemoryAllocator allocator ;
private readonly int allocatorCapacity ;
private bool isDisposed ;
[MethodImpl(MethodImplOptions.NoInlining)] public MemoryChunkBuffer ( MemoryAllocator allocator )
private static void ThrowInvalidSeek ( ) = > throw new ArgumentException ( "Invalid seek origin." ) ; {
this . allocatorCapacity = allocator . GetBufferCapacityInBytes ( ) ;
this . allocator = allocator ;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)] public int ChunkCount = > this . memoryChunks . Count ;
private MemoryChunk AllocateMemoryChunk ( )
{
// Tweak our buffer sizes to take the minimum of the provided buffer sizes
// or the allocator buffer capacity which provides us with the largest
// available contiguous buffer size.
IMemoryOwner < byte > buffer = this . allocator . Allocate < byte > ( Math . Min ( this . allocatorCapacity , GetChunkSize ( this . chunkCount + + ) ) ) ;
return new MemoryChunk ( buffer ) public long Length { get ; private set ; }
public MemoryChunk this [ int index ] = > this . memoryChunks [ index ] ;
public void Expand ( )
{ {
Next = null , IMemoryOwner < byte > buffer =
Length = buffer . Length ( ) this . allocator . Allocate < byte > ( Math . Min ( this . allocatorCapacity , GetChunkSize ( this . ChunkCount ) ) ) ;
} ;
}
private static void ReleaseMemoryChunks ( MemoryChunk ? chunk ) MemoryChunk chunk = new ( buffer )
{ {
while ( chunk ! = null ) Length = buffer . Length ( )
} ;
this . memoryChunks . Add ( chunk ) ;
this . Length + = chunk . Length ;
}
public void Dispose ( )
{ {
chunk . Dispose ( ) ; if ( ! this . isDisposed )
chunk = chunk . Next ; {
foreach ( MemoryChunk chunk in this . memoryChunks )
{
chunk . Dispose ( ) ;
}
this . memoryChunks . Clear ( ) ;
this . Length = 0 ;
this . isDisposed = true ;
}
} }
}
[MethodImpl(MethodImplOptions.AggressiveInlining)] [MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetChunkSize ( int i ) private static int GetChunkSize ( int i )
{ {
// Increment chunks sizes with moderate speed, but without using too many buffers from the same ArrayPool bucket of the default MemoryAllocator.
// Increment chunks sizes with moderate speed, but without using too many buffers from the
// https://github.com/SixLabors/ImageSharp/pull/2006#issuecomment-1066244720
// same ArrayPool bucket of the default MemoryAllocator.
#pragma warning disable IDE1006 // Naming Styles
// https://github.com/SixLabors/ImageSharp/pull/2006#issuecomment-1066244720
const int _ 1 2 8 K = 1 < < 1 7 ; const int b 128K= 1 < < 1 7 ;
const int _ 4 M = 1 < < 2 2 ; const int b 4M= 1 < < 2 2 ;
return i < 1 6 ? _ 1 2 8 K * ( 1 < < ( int ) ( ( uint ) i / 4 ) ) : _ 4 M ; return i < 1 6 ? b 128K* ( 1 < < ( int ) ( ( uint ) i / 4 ) ) : b 4M;
#pragma warning restore IDE1006 // Naming Styles
}
} }
private sealed class MemoryChunk : IDisposable private sealed class MemoryChunk : IDisposable
@ -559,27 +453,15 @@ internal sealed class ChunkedMemoryStream : Stream
public IMemoryOwner < byte > Buffer { get ; } public IMemoryOwner < byte > Buffer { get ; }
public MemoryChunk ? Next { get ; set ; }
public int Length { get ; init ; } public int Length { get ; init ; }
private void Dispose ( bool disposing ) public void Dispose ( )
{ {
if ( ! this . isDisposed ) if ( ! this . isDisposed )
{ {
if ( disposing ) this . Buffer . Dispose ( ) ;
{
this . Buffer . Dispose ( ) ;
}
this . isDisposed = true ; this . isDisposed = true ;
} }
} }
public void Dispose ( )
{
this . Dispose ( disposing : true ) ;
GC . SuppressFinalize ( this ) ;
}
} }
} }
James Jackson-South
2 years ago