Memory allocation allocation tracker test helper

src/Directory.Build.props

@@ -27,6 +27,7 @@
     <InternalsVisibleTo Include="ImageSharp.Benchmarks" Key="$(SixLaborsPublicKey)" />
     <InternalsVisibleTo Include="ImageSharp.Tests.ProfilingSandbox" Key="$(SixLaborsPublicKey)" />
     <InternalsVisibleTo Include="SixLabors.ImageSharp.Tests" Key="$(SixLaborsPublicKey)" />
+    <InternalsVisibleTo Include="SixLabors.ImageSharp.Drawing.Tests" Key="$(SixLaborsPublicKey)" />
   </ItemGroup>
 
 </Project>

src/ImageSharp/Diagnostics/MemoryDiagnostics.cs

@@ -15,8 +15,10 @@ namespace SixLabors.ImageSharp.Diagnostics
     /// </summary>
     public static class MemoryDiagnostics
     {
-        private static int totalUndisposedAllocationCount;
+        internal static readonly InteralMemoryDiagnostics Default = new();
+        private static AsyncLocal<InteralMemoryDiagnostics> localInstance = null;
 
+        // the async local end up out of scope during finalizers so putting into thte internal class is useless
         private static UndisposedAllocationDelegate undisposedAllocation;
         private static int undisposedAllocationSubscriptionCounter;
         private static readonly object SyncRoot = new();
@@ -47,18 +49,42 @@ public static event UndisposedAllocationDelegate UndisposedAllocation
             }
         }
 
+        internal static InteralMemoryDiagnostics Current
+        {
+            get
+            {
+                if (localInstance != null && localInstance.Value != null)
+                {
+                    return localInstance.Value;
+                }
+
+                return Default;
+            }
+
+            set
+            {
+                if (localInstance == null)
+                {
+                    lock (SyncRoot)
+                    {
+                        localInstance ??= new AsyncLocal<InteralMemoryDiagnostics>();
+                    }
+                }
+
+                localInstance.Value = value;
+            }
+        }
+
         /// <summary>
         /// Gets a value indicating the total number of memory resource objects leaked to the finalizer.
         /// </summary>
-        public static int TotalUndisposedAllocationCount => totalUndisposedAllocationCount;
+        public static int TotalUndisposedAllocationCount => Current.TotalUndisposedAllocationCount;
 
         internal static bool UndisposedAllocationSubscribed => Volatile.Read(ref undisposedAllocationSubscriptionCounter) > 0;
 
-        internal static void IncrementTotalUndisposedAllocationCount() =>
-            Interlocked.Increment(ref totalUndisposedAllocationCount);
+        internal static void IncrementTotalUndisposedAllocationCount() => Current.IncrementTotalUndisposedAllocationCount();
 
-        internal static void DecrementTotalUndisposedAllocationCount() =>
-            Interlocked.Decrement(ref totalUndisposedAllocationCount);
+        internal static void DecrementTotalUndisposedAllocationCount() => Current.DecrementTotalUndisposedAllocationCount();
 
         internal static void RaiseUndisposedMemoryResource(string allocationStackTrace)
         {
@@ -79,5 +105,21 @@ internal static void RaiseUndisposedMemoryResource(string allocationStackTrace)
                 allocationStackTrace);
 #endif
         }
+
+        internal class InteralMemoryDiagnostics
+        {
+            private int totalUndisposedAllocationCount;
+
+            /// <summary>
+            /// Gets a value indicating the total number of memory resource objects leaked to the finalizer.
+            /// </summary>
+            public int TotalUndisposedAllocationCount => this.totalUndisposedAllocationCount;
+
+            internal void IncrementTotalUndisposedAllocationCount() =>
+                Interlocked.Increment(ref this.totalUndisposedAllocationCount);
+
+            internal void DecrementTotalUndisposedAllocationCount() =>
+                Interlocked.Decrement(ref this.totalUndisposedAllocationCount);
+        }
     }
 }

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -122,11 +122,12 @@ public BmpDecoderCore(Configuration configuration, IBmpDecoderOptions options)
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            Image<TPixel> image = null;
             try
             {
                 int bytesPerColorMapEntry = this.ReadImageHeaders(stream, out bool inverted, out byte[] palette);
 
-                var image = new Image<TPixel>(this.Configuration, this.infoHeader.Width, this.infoHeader.Height, this.metadata);
+                image = new Image<TPixel>(this.Configuration, this.infoHeader.Width, this.infoHeader.Height, this.metadata);
 
                 Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
 
@@ -193,8 +194,14 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
             }
             catch (IndexOutOfRangeException e)
             {
+                image?.Dispose();
                 throw new ImageFormatException("Bitmap does not have a valid format.", e);
             }
+            catch
+            {
+                image?.Dispose();
+                throw;
+            }
         }
 
         /// <inheritdoc />

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs

@@ -95,7 +95,9 @@ public Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
                 }
             }
 
-            return this.pixelBuffer;
+            var buffer = this.pixelBuffer;
+            this.pixelBuffer = null;
+            return buffer;
         }
 
         /// <inheritdoc/>
@@ -210,6 +212,7 @@ public void Dispose()
 
             this.rgbBuffer?.Dispose();
             this.paddedProxyPixelRow?.Dispose();
+            this.pixelBuffer?.Dispose();
         }
     }
 }

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -227,10 +227,16 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
 
                 return image;
             }
+            catch
+            {
+                image?.Dispose();
+                throw;
+            }
             finally
             {
                 this.scanline?.Dispose();
                 this.previousScanline?.Dispose();
+                this.nextChunk?.Data?.Dispose();
             }
         }
 
@@ -472,6 +478,8 @@ private void InitializeImage<TPixel>(ImageMetadata metadata, out Image<TPixel> i
                 this.bytesPerSample = this.header.BitDepth / 8;
             }
 
+            this.previousScanline?.Dispose();
+            this.scanline?.Dispose();
             this.previousScanline = this.memoryAllocator.Allocate<byte>(this.bytesPerScanline, AllocationOptions.Clean);
             this.scanline = this.Configuration.MemoryAllocator.Allocate<byte>(this.bytesPerScanline, AllocationOptions.Clean);
         }
@@ -1359,6 +1367,7 @@ private int ReadNextDataChunk()
             {
                 if (chunk.Type == PngChunkType.Data)
                 {
+                    chunk.Data?.Dispose();
                     return chunk.Length;
                 }
 
@@ -1453,6 +1462,9 @@ private void ValidateChunk(in PngChunk chunk)
                 if (validCrc != inputCrc)
                 {
                     string chunkTypeName = Encoding.ASCII.GetString(chunkType);
+
+                    // ensure when throwing we dispose the data back to the memory allocator
+                    chunk.Data?.Dispose();
                     PngThrowHelper.ThrowInvalidChunkCrc(chunkTypeName);
                 }
             }

src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs

@@ -65,7 +65,8 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, int
                         jpegDecoder.ParseStream(stream, scanDecoderGray, CancellationToken.None);
 
                         // TODO: Should we pass through the CancellationToken from the tiff decoder?
-                        CopyImageBytesToBuffer(buffer, spectralConverterGray.GetPixelBuffer(CancellationToken.None));
+                        using var decompressedBuffer = spectralConverterGray.GetPixelBuffer(CancellationToken.None);
+                        CopyImageBytesToBuffer(buffer, decompressedBuffer);
                         break;
                     }
 
@@ -81,7 +82,8 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, int
                         jpegDecoder.ParseStream(stream, scanDecoder, CancellationToken.None);
 
                         // TODO: Should we pass through the CancellationToken from the tiff decoder?
-                        CopyImageBytesToBuffer(buffer, spectralConverter.GetPixelBuffer(CancellationToken.None));
+                        using var decompressedBuffer = spectralConverter.GetPixelBuffer(CancellationToken.None);
+                        CopyImageBytesToBuffer(buffer, decompressedBuffer);
                         break;
                     }
 

src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs

@@ -157,40 +157,52 @@ public TiffDecoderCore(Configuration configuration, ITiffDecoderOptions options)
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            this.inputStream = stream;
-            var reader = new DirectoryReader(stream, this.Configuration.MemoryAllocator);
-
-            IEnumerable<ExifProfile> directories = reader.Read();
-            this.byteOrder = reader.ByteOrder;
-            this.isBigTiff = reader.IsBigTiff;
-
             var frames = new List<ImageFrame<TPixel>>();
-            foreach (ExifProfile ifd in directories)
+            try
             {
-                cancellationToken.ThrowIfCancellationRequested();
-                ImageFrame<TPixel> frame = this.DecodeFrame<TPixel>(ifd, cancellationToken);
-                frames.Add(frame);
+                this.inputStream = stream;
+                var reader = new DirectoryReader(stream, this.Configuration.MemoryAllocator);
+
+                IEnumerable<ExifProfile> directories = reader.Read();
+                this.byteOrder = reader.ByteOrder;
+                this.isBigTiff = reader.IsBigTiff;
 
-                if (this.decodingMode is FrameDecodingMode.First)
+                foreach (ExifProfile ifd in directories)
                 {
-                    break;
+                    cancellationToken.ThrowIfCancellationRequested();
+                    ImageFrame<TPixel> frame = this.DecodeFrame<TPixel>(ifd, cancellationToken);
+                    frames.Add(frame);
+
+                    if (this.decodingMode is FrameDecodingMode.First)
+                    {
+                        break;
+                    }
                 }
-            }
 
-            ImageMetadata metadata = TiffDecoderMetadataCreator.Create(frames, this.ignoreMetadata, reader.ByteOrder, reader.IsBigTiff);
+                ImageMetadata metadata = TiffDecoderMetadataCreator.Create(frames, this.ignoreMetadata, reader.ByteOrder, reader.IsBigTiff);
 
-            // TODO: Tiff frames can have different sizes.
-            ImageFrame<TPixel> root = frames[0];
-            this.Dimensions = root.Size();
-            foreach (ImageFrame<TPixel> frame in frames)
-            {
-                if (frame.Size() != root.Size())
+                // TODO: Tiff frames can have different sizes.
+                ImageFrame<TPixel> root = frames[0];
+                this.Dimensions = root.Size();
+                foreach (ImageFrame<TPixel> frame in frames)
                 {
-                    TiffThrowHelper.ThrowNotSupported("Images with different sizes are not supported");
+                    if (frame.Size() != root.Size())
+                    {
+                        TiffThrowHelper.ThrowNotSupported("Images with different sizes are not supported");
+                    }
                 }
+
+                return new Image<TPixel>(this.Configuration, metadata, frames);
             }
+            catch
+            {
+                foreach (ImageFrame<TPixel> f in frames)
+                {
+                    f.Dispose();
+                }
 
-            return new Image<TPixel>(this.Configuration, metadata, frames);
+                throw;
+            }
         }
 
         /// <inheritdoc/>
@@ -240,8 +252,8 @@ private ImageFrame<TPixel> DecodeFrame<TPixel>(ExifProfile tags, CancellationTok
             var stripOffsetsArray = (Array)tags.GetValueInternal(ExifTag.StripOffsets).GetValue();
             var stripByteCountsArray = (Array)tags.GetValueInternal(ExifTag.StripByteCounts).GetValue();
 
-            IMemoryOwner<ulong> stripOffsetsMemory = this.ConvertNumbers(stripOffsetsArray, out Span<ulong> stripOffsets);
-            IMemoryOwner<ulong> stripByteCountsMemory = this.ConvertNumbers(stripByteCountsArray, out Span<ulong> stripByteCounts);
+            using IMemoryOwner<ulong> stripOffsetsMemory = this.ConvertNumbers(stripOffsetsArray, out Span<ulong> stripOffsets);
+            using IMemoryOwner<ulong> stripByteCountsMemory = this.ConvertNumbers(stripByteCountsArray, out Span<ulong> stripByteCounts);
 
             if (this.PlanarConfiguration == TiffPlanarConfiguration.Planar)
             {
@@ -262,8 +274,6 @@ private ImageFrame<TPixel> DecodeFrame<TPixel>(ExifProfile tags, CancellationTok
                     cancellationToken);
             }
 
-            stripOffsetsMemory?.Dispose();
-            stripByteCountsMemory?.Dispose();
             return frame;
         }
 

src/ImageSharp/Formats/Webp/WebpDecoderCore.cs

@@ -82,38 +82,47 @@ public WebpDecoderCore(Configuration configuration, IWebpDecoderOptions options)
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            this.Metadata = new ImageMetadata();
-            this.currentStream = stream;
+            Image<TPixel> image = null;
+            try
+            {
+                this.Metadata = new ImageMetadata();
+                this.currentStream = stream;
 
-            uint fileSize = this.ReadImageHeader();
+                uint fileSize = this.ReadImageHeader();
 
-            using (this.webImageInfo = this.ReadVp8Info())
-            {
-                if (this.webImageInfo.Features is { Animation: true })
+                using (this.webImageInfo = this.ReadVp8Info())
                 {
-                    WebpThrowHelper.ThrowNotSupportedException("Animations are not supported");
-                }
+                    if (this.webImageInfo.Features is { Animation: true })
+                    {
+                        WebpThrowHelper.ThrowNotSupportedException("Animations are not supported");
+                    }
 
-                var image = new Image<TPixel>(this.Configuration, (int)this.webImageInfo.Width, (int)this.webImageInfo.Height, this.Metadata);
-                Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
-                if (this.webImageInfo.IsLossless)
-                {
-                    var losslessDecoder = new WebpLosslessDecoder(this.webImageInfo.Vp8LBitReader, this.memoryAllocator, this.Configuration);
-                    losslessDecoder.Decode(pixels, image.Width, image.Height);
-                }
-                else
-                {
-                    var lossyDecoder = new WebpLossyDecoder(this.webImageInfo.Vp8BitReader, this.memoryAllocator, this.Configuration);
-                    lossyDecoder.Decode(pixels, image.Width, image.Height, this.webImageInfo);
-                }
+                    image = new Image<TPixel>(this.Configuration, (int)this.webImageInfo.Width, (int)this.webImageInfo.Height, this.Metadata);
+                    Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
+                    if (this.webImageInfo.IsLossless)
+                    {
+                        var losslessDecoder = new WebpLosslessDecoder(this.webImageInfo.Vp8LBitReader, this.memoryAllocator, this.Configuration);
+                        losslessDecoder.Decode(pixels, image.Width, image.Height);
+                    }
+                    else
+                    {
+                        var lossyDecoder = new WebpLossyDecoder(this.webImageInfo.Vp8BitReader, this.memoryAllocator, this.Configuration);
+                        lossyDecoder.Decode(pixels, image.Width, image.Height, this.webImageInfo);
+                    }
 
-                // There can be optional chunks after the image data, like EXIF and XMP.
-                if (this.webImageInfo.Features != null)
-                {
-                    this.ParseOptionalChunks(this.webImageInfo.Features);
-                }
+                    // There can be optional chunks after the image data, like EXIF and XMP.
+                    if (this.webImageInfo.Features != null)
+                    {
+                        this.ParseOptionalChunks(this.webImageInfo.Features);
+                    }
 
-                return image;
+                    return image;
+                }
+            }
+            catch
+            {
+                image?.Dispose();
+                throw;
             }
         }
 

tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs

@@ -20,6 +20,7 @@
 namespace SixLabors.ImageSharp.Tests.Formats.Bmp
 {
     [Trait("Format", "Bmp")]
+    [ValidateDisposedMemoryAllocations]
     public class BmpDecoderTests
     {
         public const PixelTypes CommonNonDefaultPixelTypes = PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.RgbaVector;

tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs

@@ -18,6 +18,7 @@
 namespace SixLabors.ImageSharp.Tests.Formats.Gif
 {
     [Trait("Format", "Gif")]
+    [ValidateDisposedMemoryAllocations]
     public class GifDecoderTests
     {
         private const PixelTypes TestPixelTypes = PixelTypes.Rgba32 | PixelTypes.RgbaVector | PixelTypes.Argb32;