Allow ImageSharp to determine the best pixel format.

Author: JimBobSquarePants

src/ImageSharp.Web/FormattedImage.cs

@@ -26,17 +26,17 @@ public sealed class FormattedImage : IDisposable
         /// </summary>
         /// <param name="image">The image.</param>
         /// <param name="format">The format.</param>
-        internal FormattedImage(Image<Rgba32> image, IImageFormat format)
+        internal FormattedImage(Image image, IImageFormat format)
         {
             this.Image = image;
             this.imageFormatsManager = image.GetConfiguration().ImageFormatsManager;
             this.Format = format;
         }
 
         /// <summary>
-        /// Gets the image.
+        /// Gets the decoded image.
         /// </summary>
-        public Image<Rgba32> Image { get; private set; }
+        public Image Image { get; private set; }
 
         /// <summary>
         /// Gets or sets the format.
@@ -81,14 +81,42 @@ public IImageEncoder Encoder
         }
 
         /// <summary>
-        /// Loads the specified source.
+        /// Create a new instance of the <see cref="Image"/> class from the given stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="source">The source.</param>
+        /// <returns>The <see cref="FormattedImage"/>.</returns>
+        public static FormattedImage Load<TPixel>(Configuration configuration, Stream source)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            var image = Image.Load<TPixel>(configuration, source, out IImageFormat format);
+            return new FormattedImage(image, format);
+        }
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given stream.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         /// <param name="source">The source.</param>
         /// <returns>The <see cref="FormattedImage"/>.</returns>
         public static FormattedImage Load(Configuration configuration, Stream source)
         {
-            var image = ImageSharp.Image.Load<Rgba32>(configuration, source, out IImageFormat format);
+            var image = Image.Load(configuration, source, out IImageFormat format);
+            return new FormattedImage(image, format);
+        }
+
+        /// <summary>
+        /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="source">The source.</param>
+        /// <returns>A <see cref="Task{FormattedImage}"/> representing the asynchronous operation.</returns>
+        public static async Task<FormattedImage> LoadAsync<TPixel>(Configuration configuration, Stream source)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            (Image<TPixel> image, IImageFormat format) = await Image.LoadWithFormatAsync<TPixel>(configuration, source);
             return new FormattedImage(image, format);
         }
 
@@ -100,7 +128,7 @@ public static FormattedImage Load(Configuration configuration, Stream source)
         /// <returns>A <see cref="Task{FormattedImage}"/> representing the asynchronous operation.</returns>
         public static async Task<FormattedImage> LoadAsync(Configuration configuration, Stream source)
         {
-            (Image<Rgba32> image, IImageFormat format) = await ImageSharp.Image.LoadWithFormatAsync<Rgba32>(configuration, source);
+            (Image image, IImageFormat format) = await Image.LoadWithFormatAsync(configuration, source);
             return new FormattedImage(image, format);
         }
 
@@ -115,7 +143,7 @@ public static async Task<FormattedImage> LoadAsync(Configuration configuration,
         /// </summary>
         /// <param name="destination">The destination stream.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        public async Task SaveAsync(Stream destination) => await this.Image.SaveAsync(destination, this.encoder);
+        public Task SaveAsync(Stream destination) => this.Image.SaveAsync(destination, this.encoder);
 
         /// <summary>
         /// Performs application-defined tasks associated with freeing, releasing, or resetting

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -14,6 +14,7 @@
 using Microsoft.Extensions.Options;
 using Microsoft.IO;
 using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Web.Caching;
 using SixLabors.ImageSharp.Web.Commands;
 using SixLabors.ImageSharp.Web.Processors;
@@ -335,19 +336,43 @@ private async Task ProcessRequestAsync(
                                 }
                                 else
                                 {
-                                    using FormattedImage image = await FormattedImage.LoadAsync(this.options.Configuration, inStream);
-
-                                    image.Process(
-                                        this.logger,
-                                        this.processors,
-                                        commands,
-                                        this.commandParser,
-                                        this.parserCulture);
-
-                                    await this.options.OnBeforeSaveAsync.Invoke(image);
-
-                                    image.Save(outStream);
-                                    format = image.Format;
+                                    FormattedImage image = null;
+                                    try
+                                    {
+                                        // Now we ca finally process the image.
+                                        // We first sort the processor collection by command order then use that collection to determine whether the decoded image pixel format
+                                        // explicitly requires an alpha component in order to allow correct processing.
+                                        //
+                                        // The non-generic variant will decode to the correct pixel format based upon the encoded image metadata which can yield
+                                        // massive memory savings.
+                                        IReadOnlyList<(int Index, IImageWebProcessor Processor)> sortedProcessors = this.processors.OrderBySupportedCommands(commands);
+                                        bool requiresAlpha = sortedProcessors.RequiresAlphaComponent(commands, this.commandParser, this.parserCulture);
+
+                                        if (requiresAlpha)
+                                        {
+                                            image = await FormattedImage.LoadAsync<Rgba32>(this.options.Configuration, inStream);
+                                        }
+                                        else
+                                        {
+                                            image = await FormattedImage.LoadAsync(this.options.Configuration, inStream);
+                                        }
+
+                                        image.Process(
+                                            this.logger,
+                                            sortedProcessors,
+                                            commands,
+                                            this.commandParser,
+                                            this.parserCulture);
+
+                                        await this.options.OnBeforeSaveAsync.Invoke(image);
+
+                                        image.Save(outStream);
+                                        format = image.Format;
+                                    }
+                                    finally
+                                    {
+                                        image?.Dispose();
+                                    }
                                 }
                             }
 

src/ImageSharp.Web/Processors/BackgroundColorWebProcessor.cs

@@ -45,5 +45,8 @@ public FormattedImage Process(
 
             return image;
         }
+
+        /// <inheritdoc/>
+        public bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture) => true;
     }
 }

src/ImageSharp.Web/Processors/FormatWebProcessor.cs

@@ -64,5 +64,8 @@ public FormattedImage Process(
 
             return image;
         }
+
+        /// <inheritdoc/>
+        public bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture) => true;
     }
 }

src/ImageSharp.Web/Processors/IImageWebProcessor.cs

@@ -35,5 +35,17 @@ FormattedImage Process(
             CommandCollection commands,
             CommandParser parser,
             CultureInfo culture);
+
+        /// <summary>
+        /// Returns a value indicating whether the image to be processed should be decoded using a pixel format that supports
+        /// an alpha component for correct processing.
+        /// </summary>
+        /// <param name="commands">The ordered collection containing the processing commands.</param>
+        /// <param name="parser">The command parser use for parting commands.</param>
+        /// <param name="culture">
+        /// The <see cref="CultureInfo"/> to use as the current parsing culture.
+        /// </param>
+        /// <returns>The <see cref="bool"/> indicating whether an alpha component is required.</returns>
+        bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture);
     }
 }

src/ImageSharp.Web/Processors/QualityWebProcessor.cs

@@ -82,5 +82,8 @@ public FormattedImage Process(
 
             return image;
         }
+
+        /// <inheritdoc/>
+        public bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture) => false;
     }
 }

src/ImageSharp.Web/Processors/ResizeWebProcessor.cs

@@ -123,6 +123,13 @@ private static ResizeOptions GetResizeOptions(
             return options;
         }
 
+        /// <inheritdoc/>
+        public bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture)
+        {
+            ResizeMode mode = parser.ParseValue<ResizeMode>(commands.GetValueOrDefault(Mode), culture);
+            return mode is ResizeMode.Pad or ResizeMode.BoxPad;
+        }
+
         private static Size ParseSize(
             Image image,
             CommandCollection commands,

src/ImageSharp.Web/Processors/WebProcessingExtensions.cs

@@ -21,22 +21,22 @@ internal static class WebProcessingExtensions
         /// <param name="logger">The type used for performing logging.</param>
         /// <param name="processors">The collection of available processors.</param>
         /// <param name="commands">The parsed collection of processing commands.</param>
-        /// <param name="commandParser">The command parser use for parting commands.</param>
+        /// <param name="parser">The command parser use for parting commands.</param>
         /// <param name="culture">
         /// The <see cref="CultureInfo"/> to use as the current parsing culture.
         /// </param>
         /// <returns>The <see cref="FormattedImage"/>.</returns>
         public static FormattedImage Process(
             this FormattedImage source,
             ILogger logger,
-            IEnumerable<IImageWebProcessor> processors,
+            IReadOnlyList<(int Index, IImageWebProcessor Processor)> processors,
             CommandCollection commands,
-            CommandParser commandParser,
+            CommandParser parser,
             CultureInfo culture)
         {
-            foreach (IImageWebProcessor processor in processors.GetBySupportedCommands(commands))
+            foreach ((int Index, IImageWebProcessor Processor) processor in processors)
             {
-                source = processor.Process(source, logger, commands, commandParser, culture);
+                source = processor.Processor.Process(source, logger, commands, parser, culture);
             }
 
             return source;
@@ -50,10 +50,9 @@ public static FormattedImage Process(
         /// <returns>
         /// The sorted proccessors that supports any of the specified commands.
         /// </returns>
-        public static IEnumerable<IImageWebProcessor> GetBySupportedCommands(this IEnumerable<IImageWebProcessor> processors, CommandCollection commands)
+        public static IReadOnlyList<(int Index, IImageWebProcessor Processor)> OrderBySupportedCommands(this IEnumerable<IImageWebProcessor> processors, CommandCollection commands)
         {
-            var indexedProcessors = new List<(int Index, IImageWebProcessor Processor)>();
-
+            List<(int Index, IImageWebProcessor Processor)> indexedProcessors = new();
             foreach (IImageWebProcessor processor in processors)
             {
                 // Get index of first supported command
@@ -65,12 +64,7 @@ public static IEnumerable<IImageWebProcessor> GetBySupportedCommands(this IEnume
             }
 
             indexedProcessors.Sort((x, y) => x.Index.CompareTo(y.Index));
-
-            // Return sorted processors
-            foreach ((int _, IImageWebProcessor processor) in indexedProcessors)
-            {
-                yield return processor;
-            }
+            return indexedProcessors;
         }
 
         /// <summary>
@@ -93,5 +87,31 @@ public static bool IsSupportedCommand(this IImageWebProcessor processor, string
 
             return false;
         }
+
+        /// <summary>
+        /// Returns a value indicating whether the image to be processed should be decoded using a pixel format that supports
+        /// an alpha component for correct processing.
+        /// </summary>
+        /// <param name="processors">The collection of ordered processors.</param>
+        /// <param name="commands">The ordered collection containing the processing commands.</param>
+        /// <param name="parser">The command parser use for parting commands.</param>
+        /// <param name="culture">
+        /// The <see cref="CultureInfo"/> to use as the current parsing culture.
+        /// </param>
+        /// <returns>The <see cref="bool"/> indicating whether an alpha component is required.</returns>
+        public static bool RequiresAlphaComponent(
+            this IReadOnlyList<(int Index, IImageWebProcessor Processor)> processors,
+            CommandCollection commands,
+            CommandParser parser,
+            CultureInfo culture)
+        {
+            bool requiresAlpha = false;
+            foreach ((int Index, IImageWebProcessor Processor) processor in processors)
+            {
+                requiresAlpha |= processor.Processor.RequiresAlphaComponent(commands, parser, culture);
+            }
+
+            return requiresAlpha;
+        }
     }
 }

tests/ImageSharp.Web.Tests/DependencyInjection/MockWebProcessor.cs

@@ -21,5 +21,7 @@ public FormattedImage Process(
             CommandParser parser,
             CultureInfo culture)
             => image;
+
+        public bool RequiresAlphaComponent(CommandCollection commands, CommandParser parser, CultureInfo culture) => false;
     }
 }

tests/ImageSharp.Web.Tests/Processors/WebProcessingExtensionsTests.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System.Linq;
+using System.Collections.Generic;
 using SixLabors.ImageSharp.Web.Commands;
 using SixLabors.ImageSharp.Web.Processors;
 using SixLabors.ImageSharp.Web.Tests.DependencyInjection;
@@ -29,11 +29,11 @@ public void WebProcessingExtensions_GetBySupportedCommands()
                 new(ResizeWebProcessor.Height, null)
             };
 
-            IImageWebProcessor[] supportedProcessors = processors.GetBySupportedCommands(commands).ToArray();
+            IReadOnlyList<(int Index, IImageWebProcessor Processor)> supportedProcessors = processors.OrderBySupportedCommands(commands);
 
-            Assert.Equal(2, supportedProcessors.Length);
-            Assert.IsType<ResizeWebProcessor>(supportedProcessors[0]);
-            Assert.IsType<QualityWebProcessor>(supportedProcessors[1]);
+            Assert.Equal(2, supportedProcessors.Count);
+            Assert.IsType<ResizeWebProcessor>(supportedProcessors[0].Processor);
+            Assert.IsType<QualityWebProcessor>(supportedProcessors[1].Processor);
         }
 
         [Fact]
@@ -46,7 +46,7 @@ public void WebProcessingExtensions_GetBySupportedCommands_Empty()
 
             CommandCollection commands = new();
 
-            IImageWebProcessor[] supportedProcessors = processors.GetBySupportedCommands(commands).ToArray();
+            IReadOnlyList<(int Index, IImageWebProcessor Processor)> supportedProcessors = processors.OrderBySupportedCommands(commands);
 
             Assert.Empty(supportedProcessors);
         }