Merge pull request #1296 from SixLabors/af/cancellation

Cancellable codec API, and overloads for loading/saving

src/ImageSharp/Advanced/AdvancedImageExtensions.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
@@ -73,9 +74,10 @@ namespace SixLabors.ImageSharp.Advanced
         /// </summary>
         /// <param name="source">The source image.</param>
         /// <param name="visitor">The image visitor.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A  <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task AcceptVisitorAsync(this Image source, IImageVisitorAsync visitor)
+        public static Task AcceptVisitorAsync(this Image source, IImageVisitorAsync visitor, CancellationToken cancellationToken = default)
-            => source.AcceptAsync(visitor);
+            => source.AcceptAsync(visitor, cancellationToken);
 
         /// <summary>
         /// Gets the configuration for the image.

src/ImageSharp/Advanced/IImageVisitor.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -31,9 +32,10 @@ namespace SixLabors.ImageSharp.Advanced
         /// Provides a pixel-specific implementation for a given operation.
         /// </summary>
         /// <param name="image">The image.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <typeparam name="TPixel">The pixel type.</typeparam>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        Task VisitAsync<TPixel>(Image<TPixel> image)
+        Task VisitAsync<TPixel>(Image<TPixel> image, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>;
     }
 }

src/ImageSharp/Common/Exceptions/InvalidImageContentException.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp
 {
@@ -32,5 +33,10 @@ namespace SixLabors.ImageSharp
             : base(errorMessage, innerException)
         {
         }
+
+        internal InvalidImageContentException(Size size, InvalidMemoryOperationException memoryException)
+            : this($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {size.Width}x{size.Height}.", memoryException)
+        {
+        }
     }
 }

src/ImageSharp/Formats/Bmp/BmpDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -36,18 +37,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             Guard.NotNull(stream, nameof(stream));
 
             var decoder = new BmpDecoderCore(configuration, this);
-
+            return decoder.Decode<TPixel>(configuration, stream);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return decoder.Decode<TPixel>(bufferedStream);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                throw new InvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}. This error can happen for very large RLE bitmaps, which are not supported.", ex);
-            }
         }
 
         /// <inheritdoc />
@@ -55,46 +45,34 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             => this.Decode<Rgba32>(configuration, stream);
 
         /// <inheritdoc/>
-        public async Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
            where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(stream, nameof(stream));
 
             var decoder = new BmpDecoderCore(configuration, this);
-
+            return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return await decoder.DecodeAsync<TPixel>(bufferedStream).ConfigureAwait(false);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                throw new InvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}. This error can happen for very large RLE bitmaps, which are not supported.", ex);
-            }
         }
 
         /// <inheritdoc />
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream)
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            => await this.DecodeAsync<Rgba32>(configuration, stream).ConfigureAwait(false);
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            .ConfigureAwait(false);
 
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream)
         {
             Guard.NotNull(stream, nameof(stream));
 
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return new BmpDecoderCore(configuration, this).Identify(configuration, stream);
-            return new BmpDecoderCore(configuration, this).Identify(bufferedStream);
         }
 
         /// <inheritdoc/>
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
             Guard.NotNull(stream, nameof(stream));
 
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return new BmpDecoderCore(configuration, this).IdentifyAsync(configuration, stream, cancellationToken);
-            return new BmpDecoderCore(configuration, this).IdentifyAsync(bufferedStream);
         }
     }
 }

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -6,6 +6,7 @@ using System.Buffers;
 using System.Buffers.Binary;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -118,7 +119,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         public Size Dimensions => new Size(this.infoHeader.Width, this.infoHeader.Height);
 
         /// <inheritdoc />
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             try
@@ -197,7 +198,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <inheritdoc />
-        public IImageInfo Identify(BufferedReadStream stream)
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
             this.ReadImageHeaders(stream, out _, out _);
             return new ImageInfo(new PixelTypeInfo(this.infoHeader.BitsPerPixel), this.infoHeader.Width, this.infoHeader.Height, this.metadata);

src/ImageSharp/Formats/Bmp/BmpEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
@@ -42,11 +43,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         }
 
         /// <inheritdoc/>
-        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new BmpEncoderCore(this, image.GetMemoryAllocator());
-            return encoder.EncodeAsync(image, stream);
+            return encoder.EncodeAsync(image, stream, cancellationToken);
         }
     }
 }

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -5,6 +5,7 @@ using System;
 using System.Buffers;
 using System.IO;
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Common.Helpers;
@@ -19,7 +20,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Image encoder for writing an image to a stream as a Windows bitmap.
     /// </summary>
-    internal sealed class BmpEncoderCore
+    internal sealed class BmpEncoderCore : IImageEncoderInternals
     {
         /// <summary>
         /// The amount to pad each row by.
@@ -97,32 +98,9 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
-            if (stream.CanSeek)
-            {
-                this.Encode(image, stream);
-            }
-            else
-            {
-                using (var ms = new MemoryStream())
-                {
-                    this.Encode(image, ms);
-                    ms.Position = 0;
-                    await ms.CopyToAsync(stream).ConfigureAwait(false);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="ImageFrame{TPixel}"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
-        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
-        where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));

src/ImageSharp/Formats/Gif/GifDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -30,21 +31,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var decoder = new GifDecoderCore(configuration, this);
-
+            return decoder.Decode<TPixel>(configuration, stream);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return decoder.Decode<TPixel>(bufferedStream);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                GifThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
@@ -52,30 +39,17 @@ namespace SixLabors.ImageSharp.Formats.Gif
             => this.Decode<Rgba32>(configuration, stream);
 
         /// <inheritdoc/>
-        public async Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var decoder = new GifDecoderCore(configuration, this);
-
+            return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return await decoder.DecodeAsync<TPixel>(bufferedStream).ConfigureAwait(false);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                GifThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream)
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            => await this.DecodeAsync<Rgba32>(configuration, stream).ConfigureAwait(false);
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            .ConfigureAwait(false);
 
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream)
@@ -85,18 +59,16 @@ namespace SixLabors.ImageSharp.Formats.Gif
             var decoder = new GifDecoderCore(configuration, this);
 
             using var bufferedStream = new BufferedReadStream(configuration, stream);
-            return decoder.Identify(bufferedStream);
+            return decoder.Identify(bufferedStream, default);
         }
 
         /// <inheritdoc/>
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
             Guard.NotNull(stream, nameof(stream));
 
             var decoder = new GifDecoderCore(configuration, this);
-
+            return decoder.IdentifyAsync(configuration, stream, cancellationToken);
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
-            return decoder.IdentifyAsync(bufferedStream);
         }
     }
 }

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -6,6 +6,7 @@ using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -97,7 +98,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private MemoryAllocator MemoryAllocator => this.Configuration.MemoryAllocator;
 
         /// <inheritdoc />
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Image<TPixel> image = null;
@@ -158,7 +159,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         }
 
         /// <inheritdoc />
-        public IImageInfo Identify(BufferedReadStream stream)
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
             try
             {

src/ImageSharp/Formats/Gif/GifEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
@@ -41,11 +42,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
         }
 
         /// <inheritdoc/>
-        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new GifEncoderCore(image.GetConfiguration(), this);
-            return encoder.EncodeAsync(image, stream);
+            return encoder.EncodeAsync(image, stream, cancellationToken);
         }
     }
 }

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -6,6 +6,7 @@ using System.Buffers;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -18,7 +19,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// <summary>
     /// Implements the GIF encoding protocol.
     /// </summary>
-    internal sealed class GifEncoderCore
+    internal sealed class GifEncoderCore : IImageEncoderInternals
     {
         /// <summary>
         /// Used for allocating memory during processing operations.
@@ -75,25 +76,9 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
-        {
-            using (var ms = new MemoryStream())
-            {
-                this.Encode(image, ms);
-                ms.Position = 0;
-                await ms.CopyToAsync(stream).ConfigureAwait(false);
-            }
-        }
-
-        /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
-        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
-        where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));

src/ImageSharp/Formats/Gif/ImageExtensions.cs

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.IO;
-using System.Threading.Tasks;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats.Gif;
-
-namespace SixLabors.ImageSharp
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Image"/> type.
-    /// </summary>
-    public static partial class ImageExtensions
-    {
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsGif(this Image source, string path) => SaveAsGif(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsGifAsync(this Image source, string path) => SaveAsGifAsync(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsGif(this Image source, string path, GifEncoder encoder) =>
-            source.Save(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsGifAsync(this Image source, string path, GifEncoder encoder) =>
-            source.SaveAsync(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsGif(this Image source, Stream stream) => SaveAsGif(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsGifAsync(this Image source, Stream stream) => SaveAsGifAsync(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsGif(this Image source, Stream stream, GifEncoder encoder) =>
-            source.Save(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the gif format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsGifAsync(this Image source, Stream stream, GifEncoder encoder) =>
-            source.SaveAsync(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
-    }
-}

src/ImageSharp/Formats/IImageDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -38,9 +39,10 @@ namespace SixLabors.ImageSharp.Formats
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="configuration">The configuration for the image.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="Image{TPixel}"/>.</returns>
         // TODO: Document ImageFormatExceptions (https://github.com/SixLabors/ImageSharp/issues/1110)
-        Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>;
 
         /// <summary>
@@ -48,8 +50,9 @@ namespace SixLabors.ImageSharp.Formats
         /// </summary>
         /// <param name="configuration">The configuration for the image.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="Image"/>.</returns>
         // TODO: Document ImageFormatExceptions (https://github.com/SixLabors/ImageSharp/issues/1110)
-        Task<Image> DecodeAsync(Configuration configuration, Stream stream);
+        Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken);
     }
 }

src/ImageSharp/Formats/IImageDecoderInternals.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Threading;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -17,21 +18,36 @@ namespace SixLabors.ImageSharp.Formats
         /// </summary>
         Configuration Configuration { get; }
 
+        /// <summary>
+        /// Gets the dimensions of the image being decoded.
+        /// </summary>
+        Size Dimensions { get; }
+
         /// <summary>
         /// Decodes the image from the specified stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The stream, where the image should be decoded from. Cannot be null.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException"><paramref name="stream"/> is null.</exception>
         /// <returns>The decoded image.</returns>
-        Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        /// <remarks>
+        /// Cancellable synchronous method. In case of cancellation,
+        /// an <see cref="OperationCanceledException"/> shall be thrown which will be handled on the call site.
+        /// </remarks>
+        Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>;
 
         /// <summary>
         /// Reads the raw image information from the specified stream.
         /// </summary>
         /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="IImageInfo"/>.</returns>
-        IImageInfo Identify(BufferedReadStream stream);
+        /// <remarks>
+        /// Cancellable synchronous method. In case of cancellation,
+        /// an <see cref="OperationCanceledException"/> shall be thrown which will be handled on the call site.
+        /// </remarks>
+        IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken);
     }
 }

src/ImageSharp/Formats/IImageEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -27,8 +28,9 @@ namespace SixLabors.ImageSharp.Formats
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>;
     }
 }

src/ImageSharp/Formats/IImageEncoderInternals.cs

@@ -0,0 +1,25 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using System.Threading;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats
+{
+    /// <summary>
+    /// Abstraction for shared internals for ***DecoderCore implementations to be used with <see cref="ImageEncoderUtilities"/>.
+    /// </summary>
+    internal interface IImageEncoderInternals
+    {
+        /// <summary>
+        /// Encodes the image.
+        /// </summary>
+        /// <param name="image">The image.</param>
+        /// <param name="stream">The stream.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <typeparam name="TPixel">The pixel type.</typeparam>
+        void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>;
+    }
+}

src/ImageSharp/Formats/IImageInfoDetector.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace SixLabors.ImageSharp.Formats
@@ -24,7 +25,8 @@ namespace SixLabors.ImageSharp.Formats
         /// </summary>
         /// <param name="configuration">The configuration for the image.</param>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>The <see cref="PixelTypeInfo"/> object</returns>
-        Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream);
+        Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken);
     }
 }

src/ImageSharp/Formats/ImageDecoderUtilities.cs

@@ -2,8 +2,11 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats
@@ -14,21 +17,159 @@ namespace SixLabors.ImageSharp.Formats
         /// Reads the raw image information from the specified stream.
         /// </summary>
         /// <param name="decoder">The decoder.</param>
-        /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
+        /// /// <param name="configuration">The configuration for the image.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException"><paramref name="stream"/> is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task<IImageInfo> IdentifyAsync(this IImageDecoderInternals decoder, BufferedReadStream stream)
+        public static Task<IImageInfo> IdentifyAsync(
-            => Task.FromResult(decoder.Identify(stream));
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken)
+            => decoder.IdentifyAsync(configuration, stream, DefaultLargeImageExceptionFactory, cancellationToken);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream.
+        /// </summary>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="configuration">The configuration for the image.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="tooLargeImageExceptionFactory">Factory method to handle <see cref="InvalidMemoryOperationException"/> as <see cref="InvalidImageContentException"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="stream"/> is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task<IImageInfo> IdentifyAsync(
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream,
+            Func<InvalidMemoryOperationException, Size, InvalidImageContentException> tooLargeImageExceptionFactory,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+                IImageInfo imageInfo = decoder.Identify(bufferedReadStream, cancellationToken);
+                return Task.FromResult(imageInfo);
+            }
+            catch (InvalidMemoryOperationException ex)
+            {
+                InvalidImageContentException invalidImageContentException = tooLargeImageExceptionFactory(ex, decoder.Dimensions);
+                return Task.FromException<IImageInfo>(invalidImageContentException);
+            }
+            catch (OperationCanceledException)
+            {
+                return Task.FromCanceled<IImageInfo>(cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                return Task.FromException<IImageInfo>(ex);
+            }
+        }
+
+        /// <summary>
+        /// Decodes the image from the specified stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="configuration">The configuration for the image.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task<Image<TPixel>> DecodeAsync<TPixel>(
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel> =>
+            decoder.DecodeAsync<TPixel>(
+                configuration,
+                stream,
+                DefaultLargeImageExceptionFactory,
+                cancellationToken);
 
         /// <summary>
         /// Decodes the image from the specified stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="decoder">The decoder.</param>
-        /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
+        /// <param name="configuration">The configuration for the image.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+        /// <param name="largeImageExceptionFactory">Factory method to handle <see cref="InvalidMemoryOperationException"/> as <see cref="InvalidImageContentException"/>.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task<Image<TPixel>> DecodeAsync<TPixel>(this IImageDecoderInternals decoder, BufferedReadStream stream)
+        public static Task<Image<TPixel>> DecodeAsync<TPixel>(
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream,
+            Func<InvalidMemoryOperationException, Size, InvalidImageContentException> largeImageExceptionFactory,
+            CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
-            => Task.FromResult(decoder.Decode<TPixel>(stream));
+        {
+            try
+            {
+                using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+                Image<TPixel> image = decoder.Decode<TPixel>(bufferedReadStream, cancellationToken);
+                return Task.FromResult(image);
+            }
+            catch (InvalidMemoryOperationException ex)
+            {
+                InvalidImageContentException invalidImageContentException = largeImageExceptionFactory(ex, decoder.Dimensions);
+                return Task.FromException<Image<TPixel>>(invalidImageContentException);
+            }
+            catch (OperationCanceledException)
+            {
+                return Task.FromCanceled<Image<TPixel>>(cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                return Task.FromException<Image<TPixel>>(ex);
+            }
+        }
+
+        public static IImageInfo Identify(
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream)
+        {
+            using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+
+            try
+            {
+                return decoder.Identify(bufferedReadStream, default);
+            }
+            catch (InvalidMemoryOperationException ex)
+            {
+                throw new InvalidImageContentException(decoder.Dimensions, ex);
+            }
+        }
+
+        public static Image<TPixel> Decode<TPixel>(this IImageDecoderInternals decoder, Configuration configuration, Stream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => decoder.Decode<TPixel>(configuration, stream, DefaultLargeImageExceptionFactory);
+
+        public static Image<TPixel> Decode<TPixel>(
+            this IImageDecoderInternals decoder,
+            Configuration configuration,
+            Stream stream,
+            Func<InvalidMemoryOperationException, Size, InvalidImageContentException> largeImageExceptionFactory)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using var bufferedReadStream = new BufferedReadStream(configuration, stream);
+
+            try
+            {
+                return decoder.Decode<TPixel>(bufferedReadStream, default);
+            }
+            catch (InvalidMemoryOperationException ex)
+            {
+                throw largeImageExceptionFactory(ex, decoder.Dimensions);
+            }
+        }
+
+        private static InvalidImageContentException DefaultLargeImageExceptionFactory(
+            InvalidMemoryOperationException memoryOperationException,
+            Size dimensions) =>
+            new InvalidImageContentException(dimensions, memoryOperationException);
     }
 }

src/ImageSharp/Formats/ImageEncoderUtilities.cs

@@ -0,0 +1,61 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats
+{
+    internal static class ImageEncoderUtilities
+    {
+        public static async Task EncodeAsync<TPixel>(
+            this IImageEncoderInternals encoder,
+            Image<TPixel> image,
+            Stream stream,
+            CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Configuration configuration = image.GetConfiguration();
+            if (stream.CanSeek)
+            {
+                await DoEncodeAsync(stream).ConfigureAwait(false);
+            }
+            else
+            {
+                using var ms = new MemoryStream();
+                await DoEncodeAsync(ms);
+                ms.Position = 0;
+                await ms.CopyToAsync(stream, configuration.StreamProcessingBufferSize, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+
+            Task DoEncodeAsync(Stream innerStream)
+            {
+                try
+                {
+                    encoder.Encode(image, innerStream, cancellationToken);
+                    return Task.CompletedTask;
+                }
+                catch (OperationCanceledException)
+                {
+                    return Task.FromCanceled(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    return Task.FromException(ex);
+                }
+            }
+        }
+
+        public static void Encode<TPixel>(
+            this IImageEncoderInternals encoder,
+            Image<TPixel> image,
+            Stream stream)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => encoder.Encode(image, stream, default);
+    }
+}

src/ImageSharp/Formats/ImageExtensions.Save.cs

@@ -0,0 +1,539 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+// <auto-generated />
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Advanced;
+
+using SixLabors.ImageSharp.Formats.Bmp;
+using SixLabors.ImageSharp.Formats.Gif;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.Formats.Tga;
+
+namespace SixLabors.ImageSharp
+{
+    /// <summary>
+    /// Extension methods for the <see cref="Image"/> type.
+    /// </summary>
+    public static partial class ImageExtensions
+    {
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsBmp(this Image source, string path) => SaveAsBmp(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsBmpAsync(this Image source, string path) => SaveAsBmpAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsBmpAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsBmpAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsBmp(this Image source, string path, BmpEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsBmpAsync(this Image source, string path, BmpEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsBmp(this Image source, Stream stream)
+            => SaveAsBmp(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsBmpAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsBmpAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static void SaveAsBmp(this Image source, Stream stream, BmpEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Bmp format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsBmpAsync(this Image source, Stream stream, BmpEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsGif(this Image source, string path) => SaveAsGif(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsGifAsync(this Image source, string path) => SaveAsGifAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsGifAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsGifAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsGif(this Image source, string path, GifEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsGifAsync(this Image source, string path, GifEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsGif(this Image source, Stream stream)
+            => SaveAsGif(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsGifAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsGifAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static void SaveAsGif(this Image source, Stream stream, GifEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Gif format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsGifAsync(this Image source, Stream stream, GifEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsJpeg(this Image source, string path) => SaveAsJpeg(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsJpegAsync(this Image source, string path) => SaveAsJpegAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsJpegAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsJpegAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsJpeg(this Image source, string path, JpegEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsJpegAsync(this Image source, string path, JpegEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsJpeg(this Image source, Stream stream)
+            => SaveAsJpeg(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsJpegAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsJpegAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static void SaveAsJpeg(this Image source, Stream stream, JpegEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Jpeg format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsJpegAsync(this Image source, Stream stream, JpegEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsPng(this Image source, string path) => SaveAsPng(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPngAsync(this Image source, string path) => SaveAsPngAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPngAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsPngAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsPng(this Image source, string path, PngEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPngAsync(this Image source, string path, PngEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsPng(this Image source, Stream stream)
+            => SaveAsPng(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPngAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsPngAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static void SaveAsPng(this Image source, Stream stream, PngEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Png format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsPngAsync(this Image source, Stream stream, PngEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsTga(this Image source, string path) => SaveAsTga(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsTgaAsync(this Image source, string path) => SaveAsTgaAsync(source, path, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsTgaAsync(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAsTgaAsync(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        public static void SaveAsTga(this Image source, string path, TgaEncoder encoder) =>
+            source.Save(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsTgaAsync(this Image source, string path, TgaEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                path,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance),
+                cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        public static void SaveAsTga(this Image source, Stream stream)
+            => SaveAsTga(source, stream, null);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsTgaAsync(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAsTgaAsync(source, stream, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static void SaveAsTga(this Image source, Stream stream, TgaEncoder encoder)
+            => source.Save(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
+
+        /// <summary>
+        /// Saves the image to the given stream with the Tga format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAsTgaAsync(this Image source, Stream stream, TgaEncoder encoder, CancellationToken cancellationToken = default) =>
+            source.SaveAsync(
+                stream,
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance),
+                cancellationToken);
+
+    }
+}

src/ImageSharp/Formats/Bmp/ImageExtensions.cs → src/ImageSharp/Formats/ImageExtensions.Save.tt

@@ -1,10 +1,32 @@
+<#@ template language="C#" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+// <auto-generated />
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats.Bmp;
+
+<#
+    var formats = new []{
+        "Bmp",
+        "Gif",
+        "Jpeg",
+        "Png",
+        "Tga",
+    };
+
+    foreach (string fmt in formats)
+    {
+#>
+using SixLabors.ImageSharp.Formats.<#= fmt #>;
+<#
+
+    }
+#>
 
 namespace SixLabors.ImageSharp
 {
@@ -13,88 +35,115 @@ namespace SixLabors.ImageSharp
     /// </summary>
     public static partial class ImageExtensions
     {
+<#
+    foreach (string fmt in formats)
+    {
+#>
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="path">The file path to save the image to.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsBmp(this Image source, string path) => SaveAsBmp(source, path, null);
+        public static void SaveAs<#= fmt #>(this Image source, string path) => SaveAs<#= fmt #>(source, path, null);
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="path">The file path to save the image to.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsBmpAsync(this Image source, string path) => SaveAsBmpAsync(source, path, null);
+        public static Task SaveAs<#= fmt #>Async(this Image source, string path) => SaveAs<#= fmt #>Async(source, path, null);
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public static Task SaveAs<#= fmt #>Async(this Image source, string path, CancellationToken cancellationToken)
+            => SaveAs<#= fmt #>Async(source, path, null, cancellationToken);
+
+        /// <summary>
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="path">The file path to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsBmp(this Image source, string path, BmpEncoder encoder) =>
+        public static void SaveAs<#= fmt #>(this Image source, string path, <#= fmt #>Encoder encoder) =>
             source.Save(
                 path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(<#= fmt #>Format.Instance));
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="path">The file path to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsBmpAsync(this Image source, string path, BmpEncoder encoder) =>
+        public static Task SaveAs<#= fmt #>Async(this Image source, string path, <#= fmt #>Encoder encoder, CancellationToken cancellationToken = default) =>
             source.SaveAsync(
                 path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(<#= fmt #>Format.Instance),
+                cancellationToken);
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="stream">The stream to save the image to.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsBmp(this Image source, Stream stream) => SaveAsBmp(source, stream, null);
+        public static void SaveAs<#= fmt #>(this Image source, Stream stream)
+            => SaveAs<#= fmt #>(source, stream, null);
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="stream">The stream to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsBmpAsync(this Image source, Stream stream) => SaveAsBmpAsync(source, stream, null);
+        public static Task SaveAs<#= fmt #>Async(this Image source, Stream stream, CancellationToken cancellationToken = default)
+            => SaveAs<#= fmt #>Async(source, stream, null, cancellationToken);
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsBmp(this Image source, Stream stream, BmpEncoder encoder) =>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-            source.Save(
+        public static void SaveAs<#= fmt #>(this Image source, Stream stream, <#= fmt #>Encoder encoder)
+            => source.Save(
                 stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(<#= fmt #>Format.Instance));
 
         /// <summary>
-        /// Saves the image to the given stream with the bmp format.
+        /// Saves the image to the given stream with the <#= fmt #> format.
         /// </summary>
         /// <param name="source">The image this method extends.</param>
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsBmpAsync(this Image source, Stream stream, BmpEncoder encoder) =>
+        public static Task SaveAs<#= fmt #>Async(this Image source, Stream stream, <#= fmt #>Encoder encoder, CancellationToken cancellationToken = default) =>
             source.SaveAsync(
                 stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
+                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(<#= fmt #>Format.Instance),
+                cancellationToken);
+
+<#
+    }
+#>
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using SixLabors.ImageSharp.IO;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
@@ -50,6 +51,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
         private HuffmanScanBuffer scanBuffer;
 
+        private CancellationToken cancellationToken;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="HuffmanScanDecoder"/> class.
         /// </summary>
@@ -63,6 +66,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <param name="spectralEnd">The spectral selection end.</param>
         /// <param name="successiveHigh">The successive approximation bit high end.</param>
         /// <param name="successiveLow">The successive approximation bit low end.</param>
+        /// <param name="cancellationToken">The token to monitor cancellation.</param>
         public HuffmanScanDecoder(
             BufferedReadStream stream,
             JpegFrame frame,
@@ -73,7 +77,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int spectralStart,
             int spectralEnd,
             int successiveHigh,
-            int successiveLow)
+            int successiveLow,
+            CancellationToken cancellationToken)
         {
             this.dctZigZag = ZigZag.CreateUnzigTable();
             this.stream = stream;
@@ -89,6 +94,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             this.spectralEnd = spectralEnd;
             this.successiveHigh = successiveHigh;
             this.successiveLow = successiveLow;
+            this.cancellationToken = cancellationToken;
         }
 
         /// <summary>
@@ -96,6 +102,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         public void ParseEntropyCodedData()
         {
+            this.cancellationToken.ThrowIfCancellationRequested();
+
             if (!this.frame.Progressive)
             {
                 this.ParseBaselineData();
@@ -145,6 +153,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             for (int j = 0; j < mcusPerColumn; j++)
             {
+                this.cancellationToken.ThrowIfCancellationRequested();
+
                 for (int i = 0; i < mcusPerLine; i++)
                 {
                     // Scan an interleaved mcu... process components in order
@@ -210,6 +220,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);
                 ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
@@ -376,6 +387,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 for (int j = 0; j < h; j++)
                 {
+                    this.cancellationToken.ThrowIfCancellationRequested();
+
                     Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
                     ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
@@ -402,6 +415,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 for (int j = 0; j < h; j++)
                 {
+                    this.cancellationToken.ThrowIfCancellationRequested();
+
                     Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
                     ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Buffers;
 using System.Numerics;
+using System.Threading;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -111,7 +112,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         /// <typeparam name="TPixel">The pixel type</typeparam>
         /// <param name="destination">The destination image</param>
-        public void PostProcess<TPixel>(ImageFrame<TPixel> destination)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
+        public void PostProcess<TPixel>(ImageFrame<TPixel> destination, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             this.PixelRowCounter = 0;
@@ -123,6 +125,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             while (this.PixelRowCounter < this.RawJpeg.ImageSizeInPixels.Height)
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 this.DoPostProcessorStep(destination);
             }
         }

src/ImageSharp/Formats/Jpeg/ImageExtensions.cs

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.IO;
-using System.Threading.Tasks;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats.Jpeg;
-
-namespace SixLabors.ImageSharp
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Image"/> type.
-    /// </summary>
-    public static partial class ImageExtensions
-    {
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsJpeg(this Image source, string path) => SaveAsJpeg(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsJpegAsync(this Image source, string path) => SaveAsJpegAsync(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsJpeg(this Image source, string path, JpegEncoder encoder) =>
-            source.Save(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsJpegAsync(this Image source, string path, JpegEncoder encoder) =>
-            source.SaveAsync(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsJpeg(this Image source, Stream stream) => SaveAsJpeg(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsJpegAsync(this Image source, Stream stream) => SaveAsJpegAsync(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsJpeg(this Image source, Stream stream, JpegEncoder encoder) =>
-            source.Save(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the jpeg format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsJpegAsync(this Image source, Stream stream, JpegEncoder encoder) =>
-            source.SaveAsync(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
-    }
-}

src/ImageSharp/Formats/Jpeg/JpegDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -24,20 +25,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             Guard.NotNull(stream, nameof(stream));
 
             using var decoder = new JpegDecoderCore(configuration, this);
-            try
+            return decoder.Decode<TPixel>(configuration, stream);
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return decoder.Decode<TPixel>(bufferedStream);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                (int w, int h) = (decoder.ImageWidth, decoder.ImageHeight);
-
-                JpegThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {w}x{h}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
@@ -45,31 +33,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             => this.Decode<Rgba32>(configuration, stream);
 
         /// <inheritdoc/>
-        public async Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(stream, nameof(stream));
 
             using var decoder = new JpegDecoderCore(configuration, this);
-            try
+            return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken);
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return await decoder.DecodeAsync<TPixel>(bufferedStream).ConfigureAwait(false);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                (int w, int h) = (decoder.ImageWidth, decoder.ImageHeight);
-
-                JpegThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {w}x{h}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream)
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            => await this.DecodeAsync<Rgba32>(configuration, stream).ConfigureAwait(false);
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            .ConfigureAwait(false);
 
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream)
@@ -77,20 +53,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             Guard.NotNull(stream, nameof(stream));
 
             using var decoder = new JpegDecoderCore(configuration, this);
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return decoder.Identify(configuration, stream);
-
-            return decoder.Identify(bufferedStream);
         }
 
         /// <inheritdoc/>
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
             Guard.NotNull(stream, nameof(stream));
 
-            using var decoder = new JpegDecoderCore(configuration, this);
+            // The introduction of a local variable that refers to an object the implements
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            // IDisposable means you must use async/await, where the compiler generates the
-
+            // state machine and a continuation.
-            return decoder.IdentifyAsync(bufferedStream);
+            using (var decoder = new JpegDecoderCore(configuration, this))
+            {
+                return await decoder.IdentifyAsync(configuration, stream, cancellationToken)
+                    .ConfigureAwait(false);
+            }
         }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -5,6 +5,7 @@ using System;
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
@@ -117,6 +118,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <inheritdoc/>
         public Size ImageSizeInPixels { get; private set; }
 
+        /// <inheritdoc/>
+        Size IImageDecoderInternals.Dimensions => this.ImageSizeInPixels;
+
         /// <summary>
         /// Gets the number of MCU blocks in the image as <see cref="Size"/>.
         /// </summary>
@@ -205,21 +209,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         }
 
         /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            this.ParseStream(stream);
+            this.ParseStream(stream, cancellationToken: cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
             this.InitDerivedMetadataProperties();
-            return this.PostProcessIntoImage<TPixel>();
+            return this.PostProcessIntoImage<TPixel>(cancellationToken);
         }
 
         /// <inheritdoc/>
-        public IImageInfo Identify(BufferedReadStream stream)
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
-            this.ParseStream(stream, true);
+            this.ParseStream(stream, true, cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
@@ -233,7 +237,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <param name="stream">The input stream</param>
         /// <param name="metadataOnly">Whether to decode metadata only.</param>
-        public void ParseStream(BufferedReadStream stream, bool metadataOnly = false)
+        /// <param name="cancellationToken">The token to monitor cancellation.</param>
+        public void ParseStream(BufferedReadStream stream, bool metadataOnly = false, CancellationToken cancellationToken = default)
         {
             this.Metadata = new ImageMetadata();
 
@@ -263,6 +268,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             while (fileMarker.Marker != JpegConstants.Markers.EOI
                 || (fileMarker.Marker == JpegConstants.Markers.EOI && fileMarker.Invalid))
             {
+                cancellationToken.ThrowIfCancellationRequested();
+
                 if (!fileMarker.Invalid)
                 {
                     // Get the marker length
@@ -279,7 +286,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                         case JpegConstants.Markers.SOS:
                             if (!metadataOnly)
                             {
-                                this.ProcessStartOfScanMarker(stream);
+                                this.ProcessStartOfScanMarker(stream, cancellationToken);
                                 break;
                             }
                             else
@@ -996,8 +1003,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Processes the SOS (Start of scan marker).
         /// </summary>
-        /// <param name="stream">The input stream.</param>
+        private void ProcessStartOfScanMarker(BufferedReadStream stream, CancellationToken cancellationToken)
-        private void ProcessStartOfScanMarker(BufferedReadStream stream)
         {
             if (this.Frame is null)
             {
@@ -1048,7 +1054,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 spectralStart,
                 spectralEnd,
                 successiveApproximation >> 4,
-                successiveApproximation & 15);
+                successiveApproximation & 15,
+                cancellationToken);
 
             sd.ParseEntropyCodedData();
         }
@@ -1081,7 +1088,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        private Image<TPixel> PostProcessIntoImage<TPixel>()
+        private Image<TPixel> PostProcessIntoImage<TPixel>(CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             if (this.ImageWidth == 0 || this.ImageHeight == 0)
@@ -1097,7 +1104,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             using (var postProcessor = new JpegImagePostProcessor(this.Configuration, this))
             {
-                postProcessor.PostProcess(image.Frames.RootFrame);
+                postProcessor.PostProcess(image.Frames.RootFrame, cancellationToken);
             }
 
             return image;

src/ImageSharp/Formats/Jpeg/JpegEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -43,26 +44,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new JpegEncoderCore(this);
-
+            return encoder.EncodeAsync(image, stream, cancellationToken);
-            if (stream.CanSeek)
-            {
-                encoder.Encode(image, stream);
-            }
-            else
-            {
-                // this hack has to be be here because JpegEncoderCore is unsafe
-                using (var ms = new MemoryStream())
-                {
-                    encoder.Encode(image, ms);
-                    ms.Position = 0;
-                    await ms.CopyToAsync(stream).ConfigureAwait(false);
-                }
-            }
         }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -6,6 +6,7 @@ using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
@@ -23,7 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// <summary>
     /// Image encoder for writing an image to a stream as a jpeg.
     /// </summary>
-    internal sealed unsafe class JpegEncoderCore
+    internal sealed unsafe class JpegEncoderCore : IImageEncoderInternals
     {
         /// <summary>
         /// The number of quantization tables.
@@ -194,11 +195,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The image to write from.</param>
         /// <param name="stream">The stream to write to.</param>
-        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-        where TPixel : unmanaged, IPixel<TPixel>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
+            where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
+            cancellationToken.ThrowIfCancellationRequested();
 
             const ushort max = JpegConstants.MaxLength;
             if (image.Width >= max || image.Height >= max)
@@ -247,7 +250,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.WriteDefineHuffmanTables(componentCount);
 
             // Write the image data.
-            this.WriteStartOfScan(image);
+            this.WriteStartOfScan(image, cancellationToken);
 
             // Write the End Of Image marker.
             this.buffer[0] = JpegConstants.Markers.XFF;
@@ -396,7 +399,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
-        private void Encode444<TPixel>(Image<TPixel> pixels)
+        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        private void Encode444<TPixel>(Image<TPixel> pixels, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // TODO: Need a JpegScanEncoder<TPixel> class or struct that encapsulates the scan-encoding implementation. (Similar to JpegScanDecoder.)
@@ -418,6 +422,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             for (int y = 0; y < pixels.Height; y += 8)
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 var currentRows = new RowOctet<TPixel>(pixelBuffer, y);
 
                 for (int x = 0; x < pixels.Width; x += 8)
@@ -943,7 +948,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The pixel accessor providing access to the image pixels.</param>
-        private void WriteStartOfScan<TPixel>(Image<TPixel> image)
+        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        private void WriteStartOfScan<TPixel>(Image<TPixel> image, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // TODO: Need a JpegScanEncoder<TPixel> class or struct that encapsulates the scan-encoding implementation. (Similar to JpegScanDecoder.)
@@ -953,10 +959,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             switch (this.subsample)
             {
                 case JpegSubsample.Ratio444:
-                    this.Encode444(image);
+                    this.Encode444(image, cancellationToken);
                     break;
                 case JpegSubsample.Ratio420:
-                    this.Encode420(image);
+                    this.Encode420(image, cancellationToken);
                     break;
             }
 
@@ -970,7 +976,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
-        private void Encode420<TPixel>(Image<TPixel> pixels)
+        /// <param name="cancellationToken">The token to monitor for cancellation.</param>
+        private void Encode420<TPixel>(Image<TPixel> pixels, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // TODO: Need a JpegScanEncoder<TPixel> class or struct that encapsulates the scan-encoding implementation. (Similar to JpegScanDecoder.)
@@ -998,6 +1005,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             for (int y = 0; y < pixels.Height; y += 16)
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 for (int x = 0; x < pixels.Width; x += 16)
                 {
                     for (int i = 0; i < 4; i++)

src/ImageSharp/Formats/Png/ImageExtensions.cs

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.IO;
-using System.Threading.Tasks;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats.Png;
-
-namespace SixLabors.ImageSharp
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Image"/> type.
-    /// </summary>
-    public static partial class ImageExtensions
-    {
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsPng(this Image source, string path) => SaveAsPng(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsPngAsync(this Image source, string path) => SaveAsPngAsync(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsPng(this Image source, string path, PngEncoder encoder) =>
-            source.Save(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsPngAsync(this Image source, string path, PngEncoder encoder) =>
-            source.SaveAsync(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsPng(this Image source, Stream stream) => SaveAsPng(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsPngAsync(this Image source, Stream stream) => SaveAsPngAsync(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsPng(this Image source, Stream stream, PngEncoder encoder) =>
-            source.Save(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the png format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsPngAsync(this Image source, Stream stream, PngEncoder encoder) =>
-            source.SaveAsync(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
-    }
-}

src/ImageSharp/Formats/Png/PngDecoder.cs

@@ -2,9 +2,8 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
-using SixLabors.ImageSharp.IO;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Png
@@ -22,65 +21,37 @@ namespace SixLabors.ImageSharp.Formats.Png
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var decoder = new PngDecoderCore(configuration, this);
-
+            return decoder.Decode<TPixel>(configuration, stream);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return decoder.Decode<TPixel>(bufferedStream);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                PngThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
         public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream);
 
         /// <inheritdoc/>
-        public async Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var decoder = new PngDecoderCore(configuration, this);
-
+            return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return await decoder.DecodeAsync<TPixel>(bufferedStream).ConfigureAwait(false);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                PngThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<Rgba32>(configuration, stream).ConfigureAwait(false);
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            .ConfigureAwait(false);
 
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream)
         {
             var decoder = new PngDecoderCore(configuration, this);
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return decoder.Identify(configuration, stream);
-            return decoder.Identify(bufferedStream);
         }
 
         /// <inheritdoc/>
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
             var decoder = new PngDecoderCore(configuration, this);
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return decoder.IdentifyAsync(configuration, stream, cancellationToken);
-            return decoder.IdentifyAsync(bufferedStream);
         }
     }
 }

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -9,6 +9,8 @@ using System.IO.Compression;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats.Png.Chunks;
 using SixLabors.ImageSharp.Formats.Png.Filters;
 using SixLabors.ImageSharp.Formats.Png.Zlib;
@@ -131,7 +133,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         public Size Dimensions => new Size(this.header.Width, this.header.Height);
 
         /// <inheritdoc/>
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var metadata = new ImageMetadata();
@@ -223,7 +225,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         }
 
         /// <inheritdoc/>
-        public IImageInfo Identify(BufferedReadStream stream)
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
             var metadata = new ImageMetadata();
             PngMetadata pngMetadata = metadata.GetPngMetadata();

src/ImageSharp/Formats/Png/PngEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
@@ -71,13 +72,17 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            // The introduction of a local variable that refers to an object the implements
+            // IDisposable means you must use async/await, where the compiler generates the
+            // state machine and a continuation.
             using (var encoder = new PngEncoderCore(image.GetMemoryAllocator(), image.GetConfiguration(), new PngEncoderOptions(this)))
             {
-                await encoder.EncodeAsync(image, stream).ConfigureAwait(false);
+                await encoder.EncodeAsync(image, stream, cancellationToken).ConfigureAwait(false);
             }
         }
     }

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -7,6 +7,7 @@ using System.Buffers.Binary;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats.Png.Chunks;
@@ -21,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Png
     /// <summary>
     /// Performs the png encoding operation.
     /// </summary>
-    internal sealed class PngEncoderCore : IDisposable
+    internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
     {
         /// <summary>
         /// The maximum block size, defaults at 64k for uncompressed blocks.
@@ -127,31 +128,8 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-            where TPixel : unmanaged, IPixel<TPixel>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
-        {
-            if (stream.CanSeek)
-            {
-                this.Encode(image, stream);
-            }
-            else
-            {
-                using (var ms = new MemoryStream())
-                {
-                    this.Encode(image, ms);
-                    ms.Position = 0;
-                    await ms.CopyToAsync(stream).ConfigureAwait(false);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
-        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(image, nameof(image));

src/ImageSharp/Formats/Tga/ImageExtensions.cs

@@ -1,100 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.IO;
-using System.Threading.Tasks;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats.Tga;
-
-namespace SixLabors.ImageSharp
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Image"/> type.
-    /// </summary>
-    public static partial class ImageExtensions
-    {
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsTga(this Image source, string path) => SaveAsTga(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsTgaAsync(this Image source, string path) => SaveAsTgaAsync(source, path, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        public static void SaveAsTga(this Image source, string path, TgaEncoder encoder) =>
-            source.Save(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="path">The file path to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsTgaAsync(this Image source, string path, TgaEncoder encoder) =>
-            source.SaveAsync(
-                path,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsTga(this Image source, Stream stream) => SaveAsTga(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsTgaAsync(this Image source, Stream stream) => SaveAsTgaAsync(source, stream, null);
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        public static void SaveAsTga(this Image source, Stream stream, TgaEncoder encoder) =>
-            source.Save(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
-
-        /// <summary>
-        /// Saves the image to the given stream with the tga format.
-        /// </summary>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="stream">The stream to save the image to.</param>
-        /// <param name="encoder">The encoder to save the image with.</param>
-        /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsTgaAsync(this Image source, Stream stream, TgaEncoder encoder) =>
-            source.SaveAsync(
-                stream,
-                encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TgaFormat.Instance));
-    }
-}

src/ImageSharp/Formats/Tga/TgaDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -21,21 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
             Guard.NotNull(stream, nameof(stream));
 
             var decoder = new TgaDecoderCore(configuration, this);
-
+            return decoder.Decode<TPixel>(configuration, stream);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return decoder.Decode<TPixel>(bufferedStream);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                TgaThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
@@ -43,49 +30,34 @@ namespace SixLabors.ImageSharp.Formats.Tga
             => this.Decode<Rgba32>(configuration, stream);
 
         /// <inheritdoc/>
-        public async Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(stream, nameof(stream));
 
             var decoder = new TgaDecoderCore(configuration, this);
-
+            return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken);
-            try
-            {
-                using var bufferedStream = new BufferedReadStream(configuration, stream);
-                return await decoder.DecodeAsync<TPixel>(bufferedStream).ConfigureAwait(false);
-            }
-            catch (InvalidMemoryOperationException ex)
-            {
-                Size dims = decoder.Dimensions;
-
-                TgaThrowHelper.ThrowInvalidImageContentException($"Cannot decode image. Failed to allocate buffers for possibly degenerate dimensions: {dims.Width}x{dims.Height}.", ex);
-
-                // Not reachable, as the previous statement will throw a exception.
-                return null;
-            }
         }
 
         /// <inheritdoc />
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream)
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
-            => await this.DecodeAsync<Rgba32>(configuration, stream).ConfigureAwait(false);
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken)
+            .ConfigureAwait(false);
 
         /// <inheritdoc/>
         public IImageInfo Identify(Configuration configuration, Stream stream)
         {
             Guard.NotNull(stream, nameof(stream));
 
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return new TgaDecoderCore(configuration, this).Identify(configuration, stream);
-            return new TgaDecoderCore(configuration, this).Identify(bufferedStream);
         }
 
         /// <inheritdoc/>
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
             Guard.NotNull(stream, nameof(stream));
 
-            using var bufferedStream = new BufferedReadStream(configuration, stream);
+            return new TgaDecoderCore(configuration, this).IdentifyAsync(configuration, stream, cancellationToken);
-            return new TgaDecoderCore(configuration, this).IdentifyAsync(bufferedStream);
         }
     }
 }

src/ImageSharp/Formats/Tga/TgaDecoderCore.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
@@ -77,7 +78,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
         public Size Dimensions => new Size(this.fileHeader.Width, this.fileHeader.Height);
 
         /// <inheritdoc />
-        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream)
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             try
@@ -640,7 +641,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
         }
 
         /// <inheritdoc />
-        public IImageInfo Identify(BufferedReadStream stream)
+        public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
             this.ReadFileHeader(stream);
             return new ImageInfo(

src/ImageSharp/Formats/Tga/TgaEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
@@ -32,11 +33,11 @@ namespace SixLabors.ImageSharp.Formats.Tga
         }
 
         /// <inheritdoc/>
-        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new TgaEncoderCore(this, image.GetMemoryAllocator());
-            return encoder.EncodeAsync(image, stream);
+            return encoder.EncodeAsync(image, stream, cancellationToken);
         }
     }
 }

src/ImageSharp/Formats/Tga/TgaEncoderCore.cs

@@ -5,6 +5,7 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -16,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Tga
     /// <summary>
     /// Image encoder for writing an image to a stream as a truevision targa image.
     /// </summary>
-    internal sealed class TgaEncoderCore
+    internal sealed class TgaEncoderCore : IImageEncoderInternals
     {
         /// <summary>
         /// Used for allocating memory during processing operations.
@@ -61,31 +62,8 @@ namespace SixLabors.ImageSharp.Formats.Tga
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
         /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public async Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        /// <param name="cancellationToken">The token to request cancellation.</param>
-                where TPixel : unmanaged, IPixel<TPixel>
+        public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
-        {
-            if (stream.CanSeek)
-            {
-                this.Encode(image, stream);
-            }
-            else
-            {
-                using (var ms = new MemoryStream())
-                {
-                    this.Encode(image, ms);
-                    ms.Position = 0;
-                    await ms.CopyToAsync(stream).ConfigureAwait(false);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="ImageFrame{TPixel}"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
-        /// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
-        public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(image, nameof(image));

src/ImageSharp/Image.Decode.cs

@@ -4,6 +4,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
@@ -156,18 +157,24 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="stream">The stream.</param>
         /// <param name="config">the configuration.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task{ValueTuple}"/> representing the asynchronous operation.</returns>
-        private static async Task<(Image<TPixel> Image, IImageFormat Format)> DecodeAsync<TPixel>(Stream stream, Configuration config)
+        private static async Task<(Image<TPixel> Image, IImageFormat Format)> DecodeAsync<TPixel>(
+            Stream stream,
+            Configuration config,
+            CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            (IImageDecoder decoder, IImageFormat format) = await DiscoverDecoderAsync(stream, config).ConfigureAwait(false);
+            (IImageDecoder decoder, IImageFormat format) = await DiscoverDecoderAsync(stream, config)
+                .ConfigureAwait(false);
             if (decoder is null)
             {
                 return (null, null);
             }
 
-            Image<TPixel> img = await decoder.DecodeAsync<TPixel>(config, stream).ConfigureAwait(false);
+            Image<TPixel> img = await decoder.DecodeAsync<TPixel>(config, stream, cancellationToken)
+                .ConfigureAwait(false);
             return (img, format);
         }
 
@@ -183,7 +190,7 @@ namespace SixLabors.ImageSharp
             return (img, format);
         }
 
-        private static async Task<(Image Image, IImageFormat Format)> DecodeAsync(Stream stream, Configuration config)
+        private static async Task<(Image Image, IImageFormat Format)> DecodeAsync(Stream stream, Configuration config, CancellationToken cancellationToken)
         {
             (IImageDecoder decoder, IImageFormat format) = await DiscoverDecoderAsync(stream, config).ConfigureAwait(false);
             if (decoder is null)
@@ -191,7 +198,7 @@ namespace SixLabors.ImageSharp
                 return (null, null);
             }
 
-            Image img = await decoder.DecodeAsync(config, stream).ConfigureAwait(false);
+            Image img = await decoder.DecodeAsync(config, stream, cancellationToken).ConfigureAwait(false);
             return (img, format);
         }
 
@@ -221,11 +228,12 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="stream">The stream.</param>
         /// <param name="config">the configuration.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>
         /// A <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the
         /// <see cref="IImageInfo"/> property of the returned type set to null if a suitable detector
         /// is not found.</returns>
-        private static async Task<(IImageInfo ImageInfo, IImageFormat Format)> InternalIdentityAsync(Stream stream, Configuration config)
+        private static async Task<(IImageInfo ImageInfo, IImageFormat Format)> InternalIdentityAsync(Stream stream, Configuration config, CancellationToken cancellationToken)
         {
             (IImageDecoder decoder, IImageFormat format) = await DiscoverDecoderAsync(stream, config).ConfigureAwait(false);
 
@@ -239,7 +247,7 @@ namespace SixLabors.ImageSharp
                 return (null, format);
             }
 
-            IImageInfo info = await detector.IdentifyAsync(config, stream).ConfigureAwait(false);
+            IImageInfo info = await detector.IdentifyAsync(config, stream, cancellationToken).ConfigureAwait(false);
             return (info, format);
         }
     }

src/ImageSharp/Image.FromFile.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
@@ -80,15 +81,75 @@ namespace SixLabors.ImageSharp
         }
 
         /// <summary>
-        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// Reads the raw image information from the specified stream without fully decoding it.
         /// </summary>
-        /// <param name="path">The file path to the image.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
-        /// <exception cref="NotSupportedException">
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
-        /// Thrown if the stream is not readable nor seekable.
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
-        /// </exception>
+        /// <returns>
-        /// <returns>The <see cref="Image"/>.</returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
-        public static Image Load(string path)
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
-            => Load(Configuration.Default, path);
+        /// </returns>
+        public static Task<IImageInfo> IdentifyAsync(string filePath, CancellationToken cancellationToken = default)
+            => IdentifyAsync(Configuration.Default, filePath, cancellationToken);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static async Task<IImageInfo> IdentifyAsync(
+            Configuration configuration,
+            string filePath,
+            CancellationToken cancellationToken = default)
+        {
+            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, filePath, cancellationToken)
+                    .ConfigureAwait(false);
+            return res.ImageInfo;
+        }
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            string filePath,
+            CancellationToken cancellationToken = default)
+            => IdentifyWithFormatAsync(Configuration.Default, filePath, cancellationToken);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static async Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            Configuration configuration,
+            string filePath,
+            CancellationToken cancellationToken = default)
+        {
+            Guard.NotNull(configuration, nameof(configuration));
+            using Stream stream = configuration.FileSystem.OpenRead(filePath);
+            return await IdentifyWithFormatAsync(configuration, stream, cancellationToken)
+                .ConfigureAwait(false);
+        }
 
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
@@ -97,9 +158,9 @@ namespace SixLabors.ImageSharp
         /// <exception cref="NotSupportedException">
         /// Thrown if the stream is not readable nor seekable.
         /// </exception>
-        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        /// <returns>The <see cref="Image"/>.</returns>
-        public static Task<Image> LoadAsync(string path)
+        public static Image Load(string path)
-            => LoadAsync(Configuration.Default, path);
+            => Load(Configuration.Default, path);
 
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
@@ -131,18 +192,21 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration for the decoder.</param>
         /// <param name="path">The file path to the image.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The path is null.</exception>
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
-        public static async Task<Image> LoadAsync(Configuration configuration, string path)
+        public static async Task<Image> LoadAsync(
+            Configuration configuration,
+            string path,
+            CancellationToken cancellationToken = default)
         {
-            using (Stream stream = configuration.FileSystem.OpenRead(path))
+            using Stream stream = configuration.FileSystem.OpenRead(path);
-            {
+            (Image img, _) = await LoadWithFormatAsync(configuration, stream, cancellationToken)
-                (Image img, _) = await LoadWithFormatAsync(configuration, stream).ConfigureAwait(false);
+                .ConfigureAwait(false);
-                return img;
+            return img;
-            }
         }
 
         /// <summary>
@@ -168,27 +232,140 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image> LoadAsync(string path, CancellationToken cancellationToken = default)
+            => LoadAsync(Configuration.Default, path, cancellationToken);
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="decoder">The decoder.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image> LoadAsync(string path, IImageDecoder decoder)
+            => LoadAsync(Configuration.Default, path, decoder, default);
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="decoder">The decoder.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(string path, IImageDecoder decoder)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => LoadAsync<TPixel>(Configuration.Default, path, decoder, default);
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="configuration">The Configuration.</param>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="decoder">The decoder.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image> LoadAsync(
+            Configuration configuration,
+            string path,
+            IImageDecoder decoder,
+            CancellationToken cancellationToken = default)
+        {
+            Guard.NotNull(configuration, nameof(configuration));
+            Guard.NotNull(path, nameof(path));
+
+            using Stream stream = configuration.FileSystem.OpenRead(path);
+            return LoadAsync(configuration, stream, decoder, cancellationToken);
+        }
+
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
         /// </summary>
         /// <param name="configuration">The Configuration.</param>
         /// <param name="path">The file path to the image.</param>
         /// <param name="decoder">The decoder.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The path is null.</exception>
         /// <exception cref="ArgumentNullException">The decoder is null.</exception>
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
-        public static Task<Image> LoadAsync(Configuration configuration, string path, IImageDecoder decoder)
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(
+            Configuration configuration,
+            string path,
+            IImageDecoder decoder,
+            CancellationToken cancellationToken = default)
+            where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(configuration, nameof(configuration));
             Guard.NotNull(path, nameof(path));
 
-            using (Stream stream = configuration.FileSystem.OpenRead(path))
+            using Stream stream = configuration.FileSystem.OpenRead(path);
-            {
+            return LoadAsync<TPixel>(configuration, stream, decoder, cancellationToken);
-                return LoadAsync(configuration, stream, decoder);
+        }
-            }
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(string path)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => LoadAsync<TPixel>(Configuration.Default, path, default(CancellationToken));
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="configuration">The configuration for the decoder.</param>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static async Task<Image<TPixel>> LoadAsync<TPixel>(
+            Configuration configuration,
+            string path,
+            CancellationToken cancellationToken = default)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using Stream stream = configuration.FileSystem.OpenRead(path);
+            (Image<TPixel> img, _) = await LoadWithFormatAsync<TPixel>(configuration, stream, cancellationToken)
+                .ConfigureAwait(false);
+            return img;
         }
 
         /// <summary>

src/ImageSharp/Image.FromStream.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
@@ -62,7 +63,8 @@ namespace SixLabors.ImageSharp
             => WithSeekableStreamAsync(
                 configuration,
                 stream,
-                s => InternalDetectFormatAsync(s, configuration));
+                (s, _) => InternalDetectFormatAsync(s, configuration),
+                default);
 
         /// <summary>
         /// Reads the raw image information from the specified stream without fully decoding it.
@@ -125,6 +127,7 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         /// <param name="stream">The image stream to read the information from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
@@ -133,9 +136,12 @@ namespace SixLabors.ImageSharp
         /// A <see cref="Task{IImageInfo}"/> representing the asynchronous operation or null if
         /// a suitable detector is not found.
         /// </returns>
-        public static async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public static async Task<IImageInfo> IdentifyAsync(
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken = default)
         {
-            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, stream).ConfigureAwait(false);
+            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, stream, cancellationToken).ConfigureAwait(false);
             return res.ImageInfo;
         }
 
@@ -164,35 +170,43 @@ namespace SixLabors.ImageSharp
         /// Reads the raw image information from the specified stream without fully decoding it.
         /// </summary>
         /// <param name="stream">The image stream to read the information from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>
-        /// A <see cref="Task"/> representing the asynchronous operation or null if
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
-        /// a suitable detector is not found.
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
         /// </returns>
-        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(Stream stream)
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
-            => IdentifyWithFormatAsync(Configuration.Default, stream);
+            Stream stream,
+            CancellationToken cancellationToken = default)
+            => IdentifyWithFormatAsync(Configuration.Default, stream, cancellationToken);
 
         /// <summary>
         /// Reads the raw image information from the specified stream without fully decoding it.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         /// <param name="stream">The image stream to read the information from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>
-        /// The <see cref="Task{ValueTuple}"/> representing the asyncronous operation with the parameter type
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
         /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
         /// </returns>
-        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(Configuration configuration, Stream stream)
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken = default)
             => WithSeekableStreamAsync(
                 configuration,
                 stream,
-                s => InternalIdentityAsync(s, configuration ?? Configuration.Default));
+                (s, ct) => InternalIdentityAsync(s, configuration ?? Configuration.Default, ct),
+                cancellationToken);
 
         /// <summary>
         /// Decode a new instance of the <see cref="Image"/> class from the given stream.
@@ -302,6 +316,7 @@ namespace SixLabors.ImageSharp
         /// <param name="configuration">The configuration for the decoder.</param>
         /// <param name="stream">The stream containing image information.</param>
         /// <param name="decoder">The decoder.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="ArgumentNullException">The decoder is null.</exception>
@@ -309,13 +324,18 @@ namespace SixLabors.ImageSharp
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
-        public static Task<Image> LoadAsync(Configuration configuration, Stream stream, IImageDecoder decoder)
+        public static Task<Image> LoadAsync(
+            Configuration configuration,
+            Stream stream,
+            IImageDecoder decoder,
+            CancellationToken cancellationToken = default)
         {
             Guard.NotNull(decoder, nameof(decoder));
             return WithSeekableStreamAsync(
                 configuration,
                 stream,
-                s => decoder.DecodeAsync(configuration, s));
+                (s, ct) => decoder.DecodeAsync(configuration, s, ct),
+                cancellationToken);
         }
 
         /// <summary>
@@ -336,15 +356,17 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration for the decoder.</param>
         /// <param name="stream">The stream containing image information.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
-        public static async Task<Image> LoadAsync(Configuration configuration, Stream stream)
+        public static async Task<Image> LoadAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken = default)
         {
-            (Image Image, IImageFormat Format) fmt = await LoadWithFormatAsync(configuration, stream).ConfigureAwait(false);
+            (Image Image, IImageFormat Format) fmt = await LoadWithFormatAsync(configuration, stream, cancellationToken)
+                .ConfigureAwait(false);
             return fmt.Image;
         }
 
@@ -425,18 +447,20 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="stream">The stream containing image information.</param>
         /// <param name="decoder">The decoder.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task<Image<TPixel>> LoadAsync<TPixel>(Stream stream, IImageDecoder decoder)
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(Stream stream, IImageDecoder decoder, CancellationToken cancellationToken = default)
             where TPixel : unmanaged, IPixel<TPixel>
             => WithSeekableStreamAsync(
                 Configuration.Default,
                 stream,
-                s => decoder.DecodeAsync<TPixel>(Configuration.Default, s));
+                (s, ct) => decoder.DecodeAsync<TPixel>(Configuration.Default, s, ct),
+                cancellationToken);
 
         /// <summary>
         /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream.
@@ -461,6 +485,7 @@ namespace SixLabors.ImageSharp
         /// <param name="configuration">The Configuration.</param>
         /// <param name="stream">The stream containing image information.</param>
         /// <param name="decoder">The decoder.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
@@ -468,12 +493,17 @@ namespace SixLabors.ImageSharp
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, Stream stream, IImageDecoder decoder)
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(
+            Configuration configuration,
+            Stream stream,
+            IImageDecoder decoder,
+            CancellationToken cancellationToken = default)
             where TPixel : unmanaged, IPixel<TPixel>
             => WithSeekableStreamAsync(
                 configuration,
                 stream,
-                s => decoder.DecodeAsync<TPixel>(configuration, s));
+                (s, ct) => decoder.DecodeAsync<TPixel>(configuration, s, ct),
+                cancellationToken);
 
         /// <summary>
         /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream.
@@ -532,18 +562,23 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration options.</param>
         /// <param name="stream">The stream containing image information.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>A <see cref="Task{ValueTuple}"/> representing the asynchronous operation.</returns>
-        public static async Task<(Image Image, IImageFormat Format)> LoadWithFormatAsync(Configuration configuration, Stream stream)
+        public static async Task<(Image Image, IImageFormat Format)> LoadWithFormatAsync(
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken = default)
         {
             (Image Image, IImageFormat Format) data = await WithSeekableStreamAsync(
                     configuration,
                     stream,
-                    async s => await DecodeAsync(s, configuration).ConfigureAwait(false))
+                    async (s, ct) => await DecodeAsync(s, configuration, ct).ConfigureAwait(false),
+                    cancellationToken)
                 .ConfigureAwait(false);
 
             if (data.Image != null)
@@ -567,6 +602,7 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration options.</param>
         /// <param name="stream">The stream containing image information.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
@@ -574,14 +610,18 @@ namespace SixLabors.ImageSharp
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task{ValueTuple}"/> representing the asynchronous operation.</returns>
-        public static async Task<(Image<TPixel> Image, IImageFormat Format)> LoadWithFormatAsync<TPixel>(Configuration configuration, Stream stream)
+        public static async Task<(Image<TPixel> Image, IImageFormat Format)> LoadWithFormatAsync<TPixel>(
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken = default)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             (Image<TPixel> Image, IImageFormat Format) data =
                 await WithSeekableStreamAsync(
                     configuration,
                     stream,
-                    s => DecodeAsync<TPixel>(s, configuration))
+                    (s, ct) => DecodeAsync<TPixel>(s, configuration, ct),
+                    cancellationToken)
                 .ConfigureAwait(false);
 
             if (data.Image != null)
@@ -605,6 +645,7 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="configuration">The configuration options.</param>
         /// <param name="stream">The stream containing image information.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The configuration is null.</exception>
         /// <exception cref="ArgumentNullException">The stream is null.</exception>
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
@@ -612,10 +653,14 @@ namespace SixLabors.ImageSharp
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static async Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, Stream stream)
+        public static async Task<Image<TPixel>> LoadAsync<TPixel>(
+            Configuration configuration,
+            Stream stream,
+            CancellationToken cancellationToken = default)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            (Image<TPixel> img, _) = await LoadWithFormatAsync<TPixel>(configuration, stream).ConfigureAwait(false);
+            (Image<TPixel> img, _) = await LoadWithFormatAsync<TPixel>(configuration, stream, cancellationToken)
+                .ConfigureAwait(false);
             return img;
         }
 
@@ -700,11 +745,13 @@ namespace SixLabors.ImageSharp
         /// <param name="configuration">The configuration.</param>
         /// <param name="stream">The input stream.</param>
         /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The <see cref="Task{T}"/>.</returns>
         private static async Task<T> WithSeekableStreamAsync<T>(
             Configuration configuration,
             Stream stream,
-            Func<Stream, Task<T>> action)
+            Func<Stream, CancellationToken, Task<T>> action,
+            CancellationToken cancellationToken)
         {
             Guard.NotNull(configuration, nameof(configuration));
             Guard.NotNull(stream, nameof(stream));
@@ -725,14 +772,14 @@ namespace SixLabors.ImageSharp
                     stream.Position = 0;
                 }
 
-                return await action(stream).ConfigureAwait(false);
+                return await action(stream, cancellationToken).ConfigureAwait(false);
             }
 
             using MemoryStream memoryStream = configuration.MemoryAllocator.AllocateFixedCapacityMemoryStream(stream.Length);
-            await stream.CopyToAsync(memoryStream, configuration.StreamProcessingBufferSize).ConfigureAwait(false);
+            await stream.CopyToAsync(memoryStream, configuration.StreamProcessingBufferSize, cancellationToken).ConfigureAwait(false);
             memoryStream.Position = 0;
 
-            return await action(memoryStream).ConfigureAwait(false);
+            return await action(memoryStream, cancellationToken).ConfigureAwait(false);
         }
     }
 }

src/ImageSharp/Image.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats;
@@ -103,15 +104,16 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="stream">The stream to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">Thrown if the stream or encoder is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public Task SaveAsync(Stream stream, IImageEncoder encoder)
+        public Task SaveAsync(Stream stream, IImageEncoder encoder, CancellationToken cancellationToken = default)
         {
             Guard.NotNull(stream, nameof(stream));
             Guard.NotNull(encoder, nameof(encoder));
             this.EnsureNotDisposed();
 
-            return this.AcceptVisitorAsync(new EncodeVisitor(encoder, stream));
+            return this.AcceptVisitorAsync(new EncodeVisitor(encoder, stream), cancellationToken);
         }
 
         /// <summary>
@@ -162,7 +164,8 @@ namespace SixLabors.ImageSharp
         /// with the pixel type of the image.
         /// </summary>
         /// <param name="visitor">The visitor.</param>
-        internal abstract Task AcceptAsync(IImageVisitorAsync visitor);
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        internal abstract Task AcceptAsync(IImageVisitorAsync visitor, CancellationToken cancellationToken);
 
         private class EncodeVisitor : IImageVisitor, IImageVisitorAsync
         {
@@ -179,8 +182,8 @@ namespace SixLabors.ImageSharp
             public void Visit<TPixel>(Image<TPixel> image)
                 where TPixel : unmanaged, IPixel<TPixel> => this.encoder.Encode(image, this.stream);
 
-            public Task VisitAsync<TPixel>(Image<TPixel> image)
+            public Task VisitAsync<TPixel>(Image<TPixel> image, CancellationToken cancellationToken)
-                where TPixel : unmanaged, IPixel<TPixel> => this.encoder.EncodeAsync(image, this.stream);
+                where TPixel : unmanaged, IPixel<TPixel> => this.encoder.EncodeAsync(image, this.stream, cancellationToken);
         }
     }
 }

src/ImageSharp/ImageExtensions.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats;
@@ -30,10 +31,11 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="source">The source image.</param>
         /// <param name="path">The file path to save the image to.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The path is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static Task SaveAsync(this Image source, string path)
+        public static Task SaveAsync(this Image source, string path, CancellationToken cancellationToken = default)
-            => source.SaveAsync(path, source.DetectEncoder(path));
+            => source.SaveAsync(path, source.DetectEncoder(path), cancellationToken);
 
         /// <summary>
         /// Writes the image to the given stream using the currently loaded image format.
@@ -59,17 +61,20 @@ namespace SixLabors.ImageSharp
         /// <param name="source">The source image.</param>
         /// <param name="path">The file path to save the image to.</param>
         /// <param name="encoder">The encoder to save the image with.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <exception cref="ArgumentNullException">The path is null.</exception>
         /// <exception cref="ArgumentNullException">The encoder is null.</exception>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public static async Task SaveAsync(this Image source, string path, IImageEncoder encoder)
+        public static async Task SaveAsync(
+            this Image source,
+            string path,
+            IImageEncoder encoder,
+            CancellationToken cancellationToken = default)
         {
             Guard.NotNull(path, nameof(path));
             Guard.NotNull(encoder, nameof(encoder));
-            using (Stream fs = source.GetConfiguration().FileSystem.Create(path))
+            using Stream fs = source.GetConfiguration().FileSystem.Create(path);
-            {
+            await source.SaveAsync(fs, encoder, cancellationToken).ConfigureAwait(false);
-                await source.SaveAsync(fs, encoder).ConfigureAwait(false);
-            }
         }
 
         /// <summary>

src/ImageSharp/ImageSharp.csproj

@@ -23,7 +23,7 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" />
     <PackageReference Include="MinVer" PrivateAssets="All" />
   </ItemGroup>
-  
+
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.1' ">
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" />
   </ItemGroup>
@@ -41,7 +41,7 @@
     <PackageReference Include="System.ValueTuple" />
   </ItemGroup>
 
-  <ItemGroup>  
+  <ItemGroup>
     <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -132,6 +132,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>PorterDuffFunctions.Generated.tt</DependentUpon>
     </Compile>
+    <Compile Update="Formats\ImageExtensions.Save.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>ImageExtensions.Save.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>
@@ -207,6 +212,10 @@
       <LastGenOutput>DefaultPixelBlenders.Generated.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
+    <None Update="Formats\ImageExtensions.Save.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>ImageExtensions.Save.cs</LastGenOutput>
+    </None>
   </ItemGroup>
 
   <ItemGroup>

src/ImageSharp/Image{TPixel}.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats;
@@ -290,11 +291,11 @@ namespace SixLabors.ImageSharp
         }
 
         /// <inheritdoc />
-        internal override Task AcceptAsync(IImageVisitorAsync visitor)
+        internal override Task AcceptAsync(IImageVisitorAsync visitor, CancellationToken cancellationToken)
         {
             this.EnsureNotDisposed();
 
-            return visitor.VisitAsync(this);
+            return visitor.VisitAsync(this, cancellationToken);
         }
 
         /// <summary>

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs

@@ -4,6 +4,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.DotNet.RemoteExecutor;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.IO;
@@ -103,7 +105,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [Theory]
         [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgba32)]
         [WithFile(TestImages.Jpeg.Progressive.Festzug, PixelTypes.Rgba32)]
-        public void DegenerateMemoryRequest_ShouldTranslateTo_ImageFormatException<TPixel>(TestImageProvider<TPixel> provider)
+        public void Decode_DegenerateMemoryRequest_ShouldTranslateTo_ImageFormatException<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             provider.LimitAllocatorBufferCapacity().InBytesSqrt(10);
@@ -112,6 +114,60 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             Assert.IsType<InvalidMemoryOperationException>(ex.InnerException);
         }
 
+        [Theory]
+        [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgba32)]
+        [WithFile(TestImages.Jpeg.Progressive.Festzug, PixelTypes.Rgba32)]
+        public async Task DecodeAsnc_DegenerateMemoryRequest_ShouldTranslateTo_ImageFormatException<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            provider.LimitAllocatorBufferCapacity().InBytesSqrt(10);
+            InvalidImageContentException ex = await Assert.ThrowsAsync<InvalidImageContentException>(() => provider.GetImageAsync(JpegDecoder));
+            this.Output.WriteLine(ex.Message);
+            Assert.IsType<InvalidMemoryOperationException>(ex.InnerException);
+        }
+
+        [Theory]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg420Small, 0)]
+        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 1)]
+        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 10)]
+        [InlineData(TestImages.Jpeg.Issues.ExifGetString750Transform, 30)]
+        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 1)]
+        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 10)]
+        [InlineData(TestImages.Jpeg.Issues.BadRstProgressive518, 30)]
+        public async Task Decode_IsCancellable(string fileName, int cancellationDelayMs)
+        {
+            // Decoding these huge files took 300ms on i7-8650U in 2020. 30ms should be safe for cancellation delay.
+            string hugeFile = Path.Combine(
+                TestEnvironment.InputImagesDirectoryFullPath,
+                fileName);
+
+            var cts = new CancellationTokenSource();
+            if (cancellationDelayMs == 0)
+            {
+                cts.Cancel();
+            }
+            else
+            {
+                cts.CancelAfter(cancellationDelayMs);
+            }
+
+            await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync(hugeFile, cts.Token));
+        }
+
+        [Theory(Skip = "Identify is too fast, doesn't work reliably.")]
+        [InlineData(TestImages.Jpeg.Baseline.Exif)]
+        [InlineData(TestImages.Jpeg.Progressive.Bad.ExifUndefType)]
+        public async Task Identify_IsCancellable(string fileName)
+        {
+            string file = Path.Combine(
+                TestEnvironment.InputImagesDirectoryFullPath,
+                fileName);
+
+            var cts = new CancellationTokenSource();
+            cts.CancelAfter(TimeSpan.FromTicks(1));
+            await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(file, cts.Token));
+        }
+
         // DEBUG ONLY!
         // The PDF.js output should be saved by "tests\ImageSharp.Tests\Formats\Jpg\pdfjs\jpeg-converter.htm"
         // into "\tests\Images\ActualOutput\JpegDecoderTests\"

tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs

@@ -1,8 +1,11 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
@@ -284,5 +287,30 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             IccProfile values = input.Metadata.IccProfile;
             Assert.Equal(values.Entries, actual.Entries);
         }
+
+        [Theory]
+        [InlineData(JpegSubsample.Ratio420, 0)]
+        [InlineData(JpegSubsample.Ratio420, 3)]
+        [InlineData(JpegSubsample.Ratio420, 10)]
+        [InlineData(JpegSubsample.Ratio444, 0)]
+        [InlineData(JpegSubsample.Ratio444, 3)]
+        [InlineData(JpegSubsample.Ratio444, 10)]
+        public async Task Encode_IsCancellable(JpegSubsample subsample, int cancellationDelayMs)
+        {
+            using var image = new Image<Rgba32>(5000, 5000);
+            using MemoryStream stream = new MemoryStream();
+            var cts = new CancellationTokenSource();
+            if (cancellationDelayMs == 0)
+            {
+                cts.Cancel();
+            }
+            else
+            {
+                cts.CancelAfter(cancellationDelayMs);
+            }
+
+            var encoder = new JpegEncoder() { Subsample = subsample };
+            await Assert.ThrowsAsync<TaskCanceledException>(() => image.SaveAsync(stream, encoder, cts.Token));
+        }
     }
 }

tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs

@@ -71,7 +71,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             using (var pp = new JpegImagePostProcessor(Configuration.Default, decoder))
             using (var image = new Image<Rgba32>(decoder.ImageWidth, decoder.ImageHeight))
             {
-                pp.PostProcess(image.Frames.RootFrame);
+                pp.PostProcess(image.Frames.RootFrame, default);
 
                 image.DebugSave(provider);
 

tests/ImageSharp.Tests/Image/ImageTests.Decode_Cancellation.cs

@@ -0,0 +1,130 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.PixelFormats;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests
+{
+    public partial class ImageTests
+    {
+        public class Decode_Cancellation : ImageLoadTestBase
+        {
+            private bool isTestStreamSeekable;
+            private readonly SemaphoreSlim notifyWaitPositionReachedSemaphore = new SemaphoreSlim(0);
+            private readonly SemaphoreSlim continueSemaphore = new SemaphoreSlim(0);
+            private readonly CancellationTokenSource cts = new CancellationTokenSource();
+
+            public Decode_Cancellation()
+            {
+                this.TopLevelConfiguration.StreamProcessingBufferSize = 128;
+            }
+
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task LoadAsync_Specific_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync<Rgb24>(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task LoadAsync_Agnostic_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task LoadAsync_Agnostic_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task LoadAsync_Specific_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync<Rgb24>(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task IdentifyAsync_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyAsync_CustomConfiguration_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task IdentifyWithFormatAsync_CustomConfiguration_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_CustomConfiguration_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_DefaultConfiguration_Stream()
+            {
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.DataStream, this.cts.Token));
+            }
+
+            private async Task DoCancel()
+            {
+                // wait until we reach the middle of the steam
+                await this.notifyWaitPositionReachedSemaphore.WaitAsync();
+
+                // set the cancellation
+                this.cts.Cancel();
+
+                // continue processing the stream
+                this.continueSemaphore.Release();
+            }
+
+            protected override Stream CreateStream() => this.TestFormat.CreateAsyncSamaphoreStream(this.notifyWaitPositionReachedSemaphore, this.continueSemaphore, this.isTestStreamSeekable);
+        }
+    }
+}

tests/ImageSharp.Tests/Image/ImageTests.DetectFormat.cs

@@ -24,8 +24,6 @@ namespace SixLabors.ImageSharp.Tests
 
             private ReadOnlySpan<byte> ActualImageSpan => this.ActualImageBytes.AsSpan();
 
-            private byte[] ByteArray => this.DataStream.ToArray();
-
             private IImageFormat LocalImageFormat => this.localImageFormatMock.Object;
 
             private static readonly IImageFormat ExpectedGlobalFormat =

tests/ImageSharp.Tests/Image/ImageTests.Identify.cs

@@ -19,9 +19,9 @@ namespace SixLabors.ImageSharp.Tests
         {
             private static readonly string ActualImagePath = TestFile.GetInputFileFullPath(TestImages.Bmp.F);
 
-            private byte[] ActualImageBytes => TestFile.Create(TestImages.Bmp.F).Bytes;
+            private static readonly Size ExpectedImageSize = new Size(108, 202);
 
-            private byte[] ByteArray => this.DataStream.ToArray();
+            private byte[] ActualImageBytes => TestFile.Create(TestImages.Bmp.F).Bytes;
 
             private IImageInfo LocalImageInfo => this.localImageInfoMock.Object;
 
@@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests
             {
                 IImageInfo info = Image.Identify(this.ActualImageBytes, out IImageFormat type);
 
-                Assert.NotNull(info);
+                Assert.Equal(ExpectedImageSize, info.Size());
                 Assert.Equal(ExpectedGlobalFormat, type);
             }
 
@@ -133,13 +133,45 @@ namespace SixLabors.ImageSharp.Tests
                 using (var stream = new MemoryStream(this.ActualImageBytes))
                 {
                     var asyncStream = new AsyncStreamWrapper(stream, () => false);
-                    (IImageInfo ImageInfo, IImageFormat Format) info = await Image.IdentifyWithFormatAsync(asyncStream);
+                    (IImageInfo ImageInfo, IImageFormat Format) res = await Image.IdentifyWithFormatAsync(asyncStream);
 
-                    Assert.NotNull(info.ImageInfo);
+                    Assert.Equal(ExpectedImageSize, res.ImageInfo.Size());
-                    Assert.Equal(ExpectedGlobalFormat, info.Format);
+                    Assert.Equal(ExpectedGlobalFormat, res.Format);
                 }
             }
 
+            [Fact]
+            public async Task FromPathAsync_CustomConfiguration()
+            {
+                IImageInfo info = await Image.IdentifyAsync(this.LocalConfiguration, this.MockFilePath);
+                Assert.Equal(this.LocalImageInfo, info);
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_FromPath_CustomConfiguration()
+            {
+                (IImageInfo ImageInfo, IImageFormat Format) info = await Image.IdentifyWithFormatAsync(this.LocalConfiguration, this.MockFilePath);
+                Assert.NotNull(info.ImageInfo);
+                Assert.Equal(this.LocalImageFormat, info.Format);
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_FromPath_GlobalConfiguration()
+            {
+                (IImageInfo ImageInfo, IImageFormat Format) res = await Image.IdentifyWithFormatAsync(ActualImagePath);
+
+                Assert.Equal(ExpectedImageSize, res.ImageInfo.Size());
+                Assert.Equal(ExpectedGlobalFormat, res.Format);
+            }
+
+            [Fact]
+            public async Task FromPathAsync_GlobalConfiguration()
+            {
+                IImageInfo info = await Image.IdentifyAsync(ActualImagePath);
+
+                Assert.Equal(ExpectedImageSize, info.Size());
+            }
+
             [Fact]
             public async Task FromStreamAsync_CustomConfiguration()
             {

tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs

@@ -3,7 +3,7 @@
 
 using System;
 using System.IO;
-
+using System.Threading;
 using Moq;
 
 using SixLabors.ImageSharp.Formats;
@@ -16,6 +16,8 @@ namespace SixLabors.ImageSharp.Tests
     {
         public abstract class ImageLoadTestBase : IDisposable
         {
+            private Lazy<Stream> dataStreamLazy;
+
             protected Image<Rgba32> localStreamReturnImageRgba32;
 
             protected Image<Bgra4444> localStreamReturnImageAgnostic;
@@ -46,10 +48,12 @@ namespace SixLabors.ImageSharp.Tests
 
             public byte[] Marker { get; }
 
-            public MemoryStream DataStream { get; }
+            public Stream DataStream => this.dataStreamLazy.Value;
 
             public byte[] DecodedData { get; private set; }
 
+            protected byte[] ByteArray => ((MemoryStream)this.DataStream).ToArray();
+
             protected ImageLoadTestBase()
             {
                 this.localStreamReturnImageRgba32 = new Image<Rgba32>(1, 1);
@@ -60,10 +64,9 @@ namespace SixLabors.ImageSharp.Tests
 
                 var detector = new Mock<IImageInfoDetector>();
                 detector.Setup(x => x.Identify(It.IsAny<Configuration>(), It.IsAny<Stream>())).Returns(this.localImageInfoMock.Object);
-                detector.Setup(x => x.IdentifyAsync(It.IsAny<Configuration>(), It.IsAny<Stream>())).ReturnsAsync(this.localImageInfoMock.Object);
+                detector.Setup(x => x.IdentifyAsync(It.IsAny<Configuration>(), It.IsAny<Stream>(), It.IsAny<CancellationToken>())).ReturnsAsync(this.localImageInfoMock.Object);
-                this.localDecoder = detector.As<IImageDecoder>();
-                this.localMimeTypeDetector = new MockImageFormatDetector(this.localImageFormatMock.Object);
 
+                this.localDecoder = detector.As<IImageDecoder>();
                 this.localDecoder.Setup(x => x.Decode<Rgba32>(It.IsAny<Configuration>(), It.IsAny<Stream>()))
                     .Callback<Configuration, Stream>((c, s) =>
                         {
@@ -86,6 +89,8 @@ namespace SixLabors.ImageSharp.Tests
                         })
                     .Returns(this.localStreamReturnImageAgnostic);
 
+                this.localMimeTypeDetector = new MockImageFormatDetector(this.localImageFormatMock.Object);
+
                 this.LocalConfiguration = new Configuration();
                 this.LocalConfiguration.ImageFormatsManager.AddImageFormatDetector(this.localMimeTypeDetector);
                 this.LocalConfiguration.ImageFormatsManager.SetDecoder(this.localImageFormatMock.Object, this.localDecoder.Object);
@@ -93,10 +98,12 @@ namespace SixLabors.ImageSharp.Tests
                 this.TopLevelConfiguration = new Configuration(this.TestFormat);
 
                 this.Marker = Guid.NewGuid().ToByteArray();
-                this.DataStream = this.TestFormat.CreateStream(this.Marker);
 
-                this.LocalFileSystemMock.Setup(x => x.OpenRead(this.MockFilePath)).Returns(this.DataStream);
+                this.dataStreamLazy = new Lazy<Stream>(this.CreateStream);
-                this.topLevelFileSystem.AddFile(this.MockFilePath, this.DataStream);
+                Stream StreamFactory() => this.DataStream;
+
+                this.LocalFileSystemMock.Setup(x => x.OpenRead(this.MockFilePath)).Returns(StreamFactory);
+                this.topLevelFileSystem.AddFile(this.MockFilePath, StreamFactory);
                 this.LocalConfiguration.FileSystem = this.LocalFileSystemMock.Object;
                 this.TopLevelConfiguration.FileSystem = this.topLevelFileSystem;
             }
@@ -107,6 +114,8 @@ namespace SixLabors.ImageSharp.Tests
                 this.localStreamReturnImageRgba32?.Dispose();
                 this.localStreamReturnImageAgnostic?.Dispose();
             }
+
+            protected virtual Stream CreateStream() => this.TestFormat.CreateStream(this.Marker);
         }
     }
 }

tests/ImageSharp.Tests/Image/ImageTests.Load_FileSystemPath_UseDefaultConfiguration.cs

@@ -25,84 +25,80 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void Path_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path))
+                using var img = Image.Load<Rgba32>(this.Path);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
-                }
             }
 
             [Fact]
             public void Path_Agnostic()
             {
-                using (var img = Image.Load(this.Path))
+                using var img = Image.Load(this.Path);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
-                }
             }
 
             [Fact]
             public async Task Path_Agnostic_Async()
             {
-                using (var img = await Image.LoadAsync(this.Path))
+                using var img = await Image.LoadAsync(this.Path);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
+            }
-                }
+
+            [Fact]
+            public async Task Path_Specific_Async()
+            {
+                using var img = await Image.LoadAsync<Rgb24>(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Agnostic_Configuration_Async()
             {
-                using (var img = await Image.LoadAsync(Configuration.Default, this.Path))
+                using var img = await Image.LoadAsync(this.Path);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
-                }
             }
 
             [Fact]
             public void Path_Decoder_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path, new BmpDecoder()))
+                using var img = Image.Load<Rgba32>(this.Path, new BmpDecoder());
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
-                }
             }
 
             [Fact]
             public void Path_Decoder_Agnostic()
             {
-                using (var img = Image.Load(this.Path, new BmpDecoder()))
+                using var img = Image.Load(this.Path, new BmpDecoder());
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
-                }
             }
 
             [Fact]
             public async Task Path_Decoder_Agnostic_Async()
             {
-                using (var img = await Image.LoadAsync(Configuration.Default, this.Path, new BmpDecoder()))
+                using var img = await Image.LoadAsync(this.Path, new BmpDecoder());
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
+            }
-                }
+
+            [Fact]
+            public async Task Path_Decoder_Specific_Async()
+            {
+                using var img = await Image.LoadAsync<Rgb24>(this.Path, new BmpDecoder());
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public void Path_OutFormat_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path, out IImageFormat format))
+                using var img = Image.Load<Rgba32>(this.Path, out IImageFormat format);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
+                Assert.IsType<BmpFormat>(format);
-                    Assert.IsType<BmpFormat>(format);
-                }
             }
 
             [Fact]
             public void Path_OutFormat_Agnostic()
             {
-                using (var img = Image.Load(this.Path, out IImageFormat format))
+                using var img = Image.Load(this.Path, out IImageFormat format);
-                {
+                VerifyDecodedImage(img);
-                    VerifyDecodedImage(img);
+                Assert.IsType<BmpFormat>(format);
-                    Assert.IsType<BmpFormat>(format);
-                }
             }
 
             [Fact]
@@ -124,6 +120,20 @@ namespace SixLabors.ImageSharp.Tests
                             Image.Load<Rgba32>((string)null);
                         });
             }
+
+            [Fact]
+            public Task Async_WhenFileNotFound_Throws()
+            {
+                return Assert.ThrowsAsync<System.IO.FileNotFoundException>(
+                    () => Image.LoadAsync<Rgba32>(Guid.NewGuid().ToString()));
+            }
+
+            [Fact]
+            public Task Async_WhenPathIsNull_Throws()
+            {
+                return Assert.ThrowsAsync<ArgumentNullException>(
+                    () => Image.LoadAsync<Rgba32>((string)null));
+            }
         }
     }
 }

tests/ImageSharp.Tests/Image/ImageTests.Load_FromBytes_PassLocalConfiguration.cs

@@ -14,8 +14,6 @@ namespace SixLabors.ImageSharp.Tests
     {
         public class Load_FromBytes_PassLocalConfiguration : ImageLoadTestBase
         {
-            private byte[] ByteArray => this.DataStream.ToArray();
-
             private ReadOnlySpan<byte> ByteSpan => this.ByteArray.AsSpan();
 
             [Theory]

tests/ImageSharp.Tests/Image/ImageTests.SaveAsync.cs

@@ -3,9 +3,9 @@
 
 using System;
 using System.IO;
-
+using System.Threading;
 using Moq;
-
+using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Png;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
@@ -90,7 +90,7 @@ namespace SixLabors.ImageSharp.Tests
             [InlineData("test.bmp")]
             [InlineData("test.jpg")]
             [InlineData("test.gif")]
-            public async Task SaveNeverCallsSyncMethods(string filename)
+            public async Task SaveAsync_NeverCallsSyncMethods(string filename)
             {
                 using (var image = new Image<Rgba32>(5, 5))
                 {
@@ -102,6 +102,20 @@ namespace SixLabors.ImageSharp.Tests
                     }
                 }
             }
+
+            [Fact]
+            public async Task SaveAsync_WithNonSeekableStream_IsCancellable()
+            {
+                using var image = new Image<Rgba32>(4000, 4000);
+                var encoder = new PngEncoder() { CompressionLevel = PngCompressionLevel.BestCompression };
+                using var stream = new MemoryStream();
+                var asyncStream = new AsyncStreamWrapper(stream, () => false);
+                var cts = new CancellationTokenSource();
+                cts.CancelAfter(TimeSpan.FromTicks(1));
+
+                await Assert.ThrowsAnyAsync<TaskCanceledException>(() =>
+                    image.SaveAsync(asyncStream, encoder, cts.Token));
+            }
         }
     }
 }

tests/ImageSharp.Tests/ImageSharp.Tests.csproj

@@ -21,7 +21,7 @@
     <PackageReference Include="Magick.NET-Q16-AnyCPU" />
     <PackageReference Include="Microsoft.DotNet.RemoteExecutor" />
     <PackageReference Include="Moq" />
-    <PackageReference Include="SharpZipLib"  />
+    <PackageReference Include="SharpZipLib" />
     <PackageReference Include="System.Drawing.Common" />
   </ItemGroup>
 

tests/ImageSharp.Tests/TestFileSystem.cs

@@ -12,9 +12,9 @@ namespace SixLabors.ImageSharp.Tests
     /// </summary>
     public class TestFileSystem : ImageSharp.IO.IFileSystem
     {
-        private readonly Dictionary<string, Stream> fileSystem = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, Func<Stream>> fileSystem = new Dictionary<string, Func<Stream>>(StringComparer.OrdinalIgnoreCase);
 
-        public void AddFile(string path, Stream data)
+        public void AddFile(string path, Func<Stream> data)
         {
             lock (this.fileSystem)
             {
@@ -29,7 +29,7 @@ namespace SixLabors.ImageSharp.Tests
             {
                 if (this.fileSystem.ContainsKey(path))
                 {
-                    Stream stream = this.fileSystem[path];
+                    Stream stream = this.fileSystem[path]();
                     stream.Position = 0;
                     return stream;
                 }
@@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests
             {
                 if (this.fileSystem.ContainsKey(path))
                 {
-                    Stream stream = this.fileSystem[path];
+                    Stream stream = this.fileSystem[path]();
                     stream.Position = 0;
                     return stream;
                 }
@@ -54,4 +54,4 @@ namespace SixLabors.ImageSharp.Tests
             return File.OpenRead(path);
         }
     }
-}
+}

tests/ImageSharp.Tests/TestFormat.cs

@@ -6,9 +6,11 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Numerics;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 using Xunit;
 
 namespace SixLabors.ImageSharp.Tests
@@ -32,9 +34,9 @@ namespace SixLabors.ImageSharp.Tests
 
         public List<DecodeOperation> DecodeCalls { get; } = new List<DecodeOperation>();
 
-        public IImageEncoder Encoder { get; }
+        public TestEncoder Encoder { get; }
 
-        public IImageDecoder Decoder { get; }
+        public TestDecoder Decoder { get; }
 
         private byte[] header = Guid.NewGuid().ToByteArray();
 
@@ -52,6 +54,14 @@ namespace SixLabors.ImageSharp.Tests
             return ms;
         }
 
+        public Stream CreateAsyncSamaphoreStream(SemaphoreSlim notifyWaitPositionReachedSemaphore, SemaphoreSlim continueSemaphore, bool seeakable, int size = 1024, int waitAfterPosition = 512)
+        {
+            var buffer = new byte[size];
+            this.header.CopyTo(buffer, 0);
+            var semaphoreStream = new SemaphoreReadMemoryStream(buffer, waitAfterPosition, notifyWaitPositionReachedSemaphore, continueSemaphore);
+            return seeakable ? (Stream)semaphoreStream : new AsyncStreamWrapper(semaphoreStream, () => false);
+        }
+
         public void VerifySpecificDecodeCall<TPixel>(byte[] marker, Configuration config)
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -187,7 +197,7 @@ namespace SixLabors.ImageSharp.Tests
             }
         }
 
-        public class TestDecoder : IImageDecoder
+        public class TestDecoder : IImageDecoder, IImageInfoDetector
         {
             private TestFormat testFormat;
 
@@ -204,9 +214,17 @@ namespace SixLabors.ImageSharp.Tests
 
             public Image<TPixel> Decode<TPixel>(Configuration config, Stream stream)
                 where TPixel : unmanaged, IPixel<TPixel>
+                => this.DecodeImpl<TPixel>(config, stream, default).GetAwaiter().GetResult();
+
+            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration config, Stream stream, CancellationToken cancellationToken)
+                where TPixel : unmanaged, IPixel<TPixel>
+                => this.DecodeImpl<TPixel>(config, stream, cancellationToken);
+
+            private async Task<Image<TPixel>> DecodeImpl<TPixel>(Configuration config, Stream stream, CancellationToken cancellationToken)
+                where TPixel : unmanaged, IPixel<TPixel>
             {
                 var ms = new MemoryStream();
-                stream.CopyTo(ms);
+                await stream.CopyToAsync(ms, config.StreamProcessingBufferSize, cancellationToken);
                 var marker = ms.ToArray().Skip(this.testFormat.header.Length).ToArray();
                 this.testFormat.DecodeCalls.Add(new DecodeOperation
                 {
@@ -219,15 +237,18 @@ namespace SixLabors.ImageSharp.Tests
                 return this.testFormat.Sample<TPixel>();
             }
 
-            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration config, Stream stream)
-                where TPixel : unmanaged, IPixel<TPixel>
-                => Task.FromResult(this.Decode<TPixel>(config, stream));
-
             public bool IsSupportedFileFormat(Span<byte> header) => this.testFormat.IsSupportedFileFormat(header);
 
             public Image Decode(Configuration configuration, Stream stream) => this.Decode<TestPixelForAgnosticDecode>(configuration, stream);
 
-            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<TestPixelForAgnosticDecode>(configuration, stream);
+            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+                => await this.DecodeAsync<TestPixelForAgnosticDecode>(configuration, stream, cancellationToken);
+
+            public IImageInfo Identify(Configuration configuration, Stream stream) =>
+                this.IdentifyAsync(configuration, stream, default).GetAwaiter().GetResult();
+
+            public async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+                => await this.DecodeImpl<Rgba32>(configuration, stream, cancellationToken);
         }
 
         public class TestEncoder : ImageSharp.Formats.IImageEncoder
@@ -249,7 +270,7 @@ namespace SixLabors.ImageSharp.Tests
                 // TODO record this happened so we can verify it.
             }
 
-            public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+            public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
                where TPixel : unmanaged, IPixel<TPixel>
             {
                 // TODO record this happened so we can verify it.

tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs

@@ -4,8 +4,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
-
+using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -164,6 +165,15 @@ namespace SixLabors.ImageSharp.Tests
                 return cachedImage.Clone(this.Configuration);
             }
 
+            public override Task<Image<TPixel>> GetImageAsync(IImageDecoder decoder)
+            {
+                Guard.NotNull(decoder, nameof(decoder));
+
+                // Used in small subset of decoder tests, no caching.
+                string path = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.FilePath);
+                return Image.LoadAsync<TPixel>(this.Configuration, path, decoder);
+            }
+
             public override void Deserialize(IXunitSerializationInfo info)
             {
                 this.FilePath = info.GetValue<string>("path");

tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Reflection;
+using System.Threading.Tasks;
 using Castle.Core.Internal;
 
 using SixLabors.ImageSharp.Formats;
@@ -97,6 +98,11 @@ namespace SixLabors.ImageSharp.Tests
             throw new NotSupportedException($"Decoder specific GetImage() is not supported with {this.GetType().Name}!");
         }
 
+        public virtual Task<Image<TPixel>> GetImageAsync(IImageDecoder decoder)
+        {
+            throw new NotSupportedException($"Decoder specific GetImageAsync() is not supported with {this.GetType().Name}!");
+        }
+
         /// <summary>
         /// Returns an <see cref="Image{TPixel}"/> instance to the test case with the necessary traits.
         /// </summary>

tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs

@@ -4,6 +4,7 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 using ImageMagick;
 using SixLabors.ImageSharp.Formats;
@@ -46,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
             }
         }
 
-        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
             => Task.FromResult(this.Decode<TPixel>(configuration, stream));
 
@@ -82,6 +83,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
 
         public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream);
 
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<Rgba32>(configuration, stream);
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken);
     }
 }

tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceDecoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
 using SixLabors.ImageSharp.Formats;
@@ -14,7 +15,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
     {
         public static SystemDrawingReferenceDecoder Instance { get; } = new SystemDrawingReferenceDecoder();
 
-        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+        public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
             => Task.FromResult(this.Decode<TPixel>(configuration, stream));
 
@@ -48,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
             }
         }
 
-        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             => Task.FromResult(this.Identify(configuration, stream));
 
         public IImageInfo Identify(Configuration configuration, Stream stream)
@@ -62,6 +63,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
 
         public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream);
 
-        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<Rgba32>(configuration, stream);
+        public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+            => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken);
     }
 }

tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/SystemDrawingReferenceEncoder.cs

@@ -3,6 +3,7 @@
 
 using System.Drawing.Imaging;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
@@ -31,7 +32,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
             }
         }
 
-        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream)
+        public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using (System.Drawing.Bitmap sdBitmap = SystemDrawingBridge.To32bppArgbSystemDrawingBitmap(image))

tests/ImageSharp.Tests/TestUtilities/SemaphoreReadMemoryStream.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SixLabors.ImageSharp.Tests.TestUtilities
+{
+    internal class SemaphoreReadMemoryStream : MemoryStream
+    {
+        private readonly SemaphoreSlim continueSemaphore;
+        private readonly SemaphoreSlim notifyWaitPositionReachedSemaphore;
+        private int pauseDone;
+        private readonly long waitPosition;
+
+        public SemaphoreReadMemoryStream(
+            byte[] buffer,
+            long waitPosition,
+            SemaphoreSlim notifyWaitPositionReachedSemaphore,
+            SemaphoreSlim continueSemaphore)
+            : base(buffer)
+        {
+            this.continueSemaphore = continueSemaphore;
+            this.notifyWaitPositionReachedSemaphore = notifyWaitPositionReachedSemaphore;
+            this.waitPosition = waitPosition;
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int read = base.Read(buffer, offset, count);
+            if (this.Position > this.waitPosition && this.TryPause())
+            {
+                this.notifyWaitPositionReachedSemaphore.Release();
+                this.continueSemaphore.Wait();
+            }
+
+            return read;
+        }
+
+        private bool TryPause() => Interlocked.CompareExchange(ref this.pauseDone, 1, 0) == 0;
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            int read = await base.ReadAsync(buffer, offset, count, cancellationToken);
+            if (this.Position > this.waitPosition && this.TryPause())
+            {
+                this.notifyWaitPositionReachedSemaphore.Release();
+                await this.continueSemaphore.WaitAsync();
+            }
+
+            return read;
+        }
+
+        public override int ReadByte()
+        {
+            if (this.Position + 1 > this.waitPosition && this.TryPause())
+            {
+                this.notifyWaitPositionReachedSemaphore.Release();
+                this.continueSemaphore.Wait();
+            }
+
+            int result = base.ReadByte();
+            return result;
+        }
+    }
+}

tests/ImageSharp.Tests/TestUtilities/Tests/SemaphoreReadMemoryStreamTests.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SixLabors.ImageSharp.Tests.TestUtilities;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests
+{
+    public class SemaphoreReadMemoryStreamTests
+    {
+        private readonly SemaphoreSlim continueSemaphore = new SemaphoreSlim(0);
+        private readonly SemaphoreSlim notifyWaitPositionReachedSemaphore = new SemaphoreSlim(0);
+        private readonly byte[] buffer = new byte[128];
+
+        [Fact]
+        public void Read_BeforeWaitLimit_ShouldFinish()
+        {
+            using Stream stream = this.CreateTestStream();
+            int read = stream.Read(this.buffer);
+            Assert.Equal(this.buffer.Length, read);
+        }
+
+        [Fact]
+        public async Task ReadAsync_BeforeWaitLimit_ShouldFinish()
+        {
+            using Stream stream = this.CreateTestStream();
+            int read = await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+            Assert.Equal(this.buffer.Length, read);
+        }
+
+        [Fact]
+        public async Task Read_AfterWaitLimit_ShouldPause()
+        {
+            using Stream stream = this.CreateTestStream();
+            stream.Read(this.buffer);
+            Assert.Equal(0, this.notifyWaitPositionReachedSemaphore.CurrentCount);
+
+            Task readTask = Task.Factory.StartNew(
+                () =>
+            {
+                stream.Read(this.buffer);
+                stream.Read(this.buffer);
+                stream.Read(this.buffer);
+                stream.Read(this.buffer);
+                stream.Read(this.buffer);
+            }, TaskCreationOptions.LongRunning);
+
+            await Task.Delay(5);
+            Assert.False(readTask.IsCompleted);
+            await this.notifyWaitPositionReachedSemaphore.WaitAsync();
+            await Task.Delay(5);
+            Assert.False(readTask.IsCompleted);
+            this.continueSemaphore.Release();
+            await readTask;
+        }
+
+        [Fact]
+        public async Task ReadAsync_AfterWaitLimit_ShouldPause()
+        {
+            using Stream stream = this.CreateTestStream();
+            await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+
+            Task readTask = Task.Factory.StartNew(
+                async () =>
+                {
+                    await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+                    await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+                    await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+                    await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+                    await stream.ReadAsync(this.buffer, 0, this.buffer.Length);
+                }, TaskCreationOptions.LongRunning);
+            await Task.Delay(5);
+            Assert.False(readTask.IsCompleted);
+            await this.notifyWaitPositionReachedSemaphore.WaitAsync();
+            await Task.Delay(5);
+            Assert.False(readTask.IsCompleted);
+            this.continueSemaphore.Release();
+            await readTask;
+        }
+
+        private Stream CreateTestStream(int size = 1024, int waitAfterPosition = 256)
+        {
+            byte[] buffer = new byte[size];
+            return new SemaphoreReadMemoryStream(buffer, waitAfterPosition, this.notifyWaitPositionReachedSemaphore, this.continueSemaphore);
+        }
+    }
+}

tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats;
@@ -371,7 +372,7 @@ namespace SixLabors.ImageSharp.Tests
                 return new Image<TPixel>(42, 42);
             }
 
-            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
                 where TPixel : unmanaged, IPixel<TPixel>
             {
                 InvocationCountsAsync[this.callerName]++;
@@ -391,7 +392,8 @@ namespace SixLabors.ImageSharp.Tests
 
             public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream);
 
-            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<Rgba32>(configuration, stream);
+            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+                => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken);
         }
 
         private class TestDecoderWithParameters : IImageDecoder
@@ -425,7 +427,7 @@ namespace SixLabors.ImageSharp.Tests
                 return new Image<TPixel>(42, 42);
             }
 
-            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream)
+            public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
                 where TPixel : unmanaged, IPixel<TPixel>
             {
                 InvocationCountsAsync[this.callerName]++;
@@ -445,7 +447,8 @@ namespace SixLabors.ImageSharp.Tests
 
             public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream);
 
-            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream) => await this.DecodeAsync<Rgba32>(configuration, stream);
+            public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+                => await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken);
         }
     }
 }