Added: ability to skip unneeded chunks for optimization mode

src/ImageSharp/Formats/Png/IPngEncoderOptions.cs

@@ -59,13 +59,20 @@ internal interface IPngEncoderOptions
         PngInterlaceMode? InterlaceMethod { get; }
 
         /// <summary>
-        /// Gets chunk filter method.
+        /// Gets a value indicating whether the metadata should be ignored when the image is being encoded.
+        /// When set to true, all ancillary chunks will be skipped.
+        /// </summary>
+        bool IgnoreMetadata { get; }
+
+        /// <summary>
+        /// Gets the chunk filter method. This allows to filter ancillary chunks.
         /// </summary>
         PngChunkFilter? ChunkFilter { get; }
 
         /// <summary>
-        /// Gets a value indicating whether fully transparent pixels should be converted to black pixels.
+        /// Gets a value indicating whether fully transparent pixels that may contain R, G, B values which are not 0,
+        /// should be converted to transparent black, which can yield in better compression in some cases.
         /// </summary>
-        bool MakeTransparentBlack { get; }
+        PngTransparentColorBehavior TransparentColorBehavior { get; }
     }
 }

src/ImageSharp/Formats/Png/PngChunkFilter.cs

@@ -37,7 +37,7 @@ public enum PngChunkFilter
         ExcludeTextChunks = 1 << 3,
 
         /// <summary>
-        /// All possible optimizations.
+        /// All ancillary chunks will be excluded.
         /// </summary>
         ExcludeAll = ~None
     }

src/ImageSharp/Formats/Png/PngEncoder.cs

@@ -34,23 +34,20 @@ public sealed class PngEncoder : IImageEncoder, IPngEncoderOptions
         /// <inheritdoc/>
         public IQuantizer Quantizer { get; set; }
 
-        /// <summary>
-        /// Gets or sets the transparency threshold.
-        /// </summary>
+        /// <inheritdoc/>
         public byte Threshold { get; set; } = byte.MaxValue;
 
         /// <inheritdoc/>
         public PngInterlaceMode? InterlaceMethod { get; set; }
 
-        /// <summary>
-        /// Gets or sets the chunk filter. This can be used to exclude some ancillary chunks from being written.
-        /// </summary>
+        /// <inheritdoc/>
         public PngChunkFilter? ChunkFilter { get; set; }
 
-        /// <summary>
-        /// Gets or sets a value indicating whether fully transparent pixels should be converted to black pixels.
-        /// </summary>
-        public bool MakeTransparentBlack { get; set; }
+        /// <inheritdoc/>
+        public bool IgnoreMetadata { get; set; }
+
+        /// <inheritdoc/>
+        public PngTransparentColorBehavior TransparentColorBehavior { get; set; }
 
         /// <summary>
         /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -145,10 +145,11 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             PngMetadata pngMetadata = metadata.GetFormatMetadata(PngFormat.Instance);
             PngEncoderOptionsHelpers.AdjustOptions<TPixel>(this.options, pngMetadata, out this.use16Bit, out this.bytesPerPixel);
             Image<TPixel> clonedImage = null;
-            if (this.options.MakeTransparentBlack)
+            bool clearTransparency = this.options.TransparentColorBehavior == PngTransparentColorBehavior.Clear;
+            if (clearTransparency)
             {
                 clonedImage = image.Clone();
-                MakeTransparentPixelsBlack(clonedImage);
+                ClearTransparentPixels(clonedImage);
             }
 
             IndexedImageFrame<TPixel> quantized = this.CreateQuantizedImage(image, clonedImage);
@@ -162,7 +163,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             this.WritePhysicalChunk(stream, metadata);
             this.WriteExifChunk(stream, metadata);
             this.WriteTextChunks(stream, pngMetadata);
-            this.WriteDataChunks(this.options.MakeTransparentBlack ? clonedImage : image, quantized, stream);
+            this.WriteDataChunks(clearTransparency ? clonedImage : image, quantized, stream);
             this.WriteEndChunk(stream);
 
             stream.Flush();
@@ -190,11 +191,11 @@ public void Dispose()
         }
 
         /// <summary>
-        /// Makes transparent pixels black.
+        /// Convert transparent pixels, to transparent black pixels, which can yield to better compression in some cases.
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="image">The cloned image where the transparent pixels will be changed.</param>
-        private static void MakeTransparentPixelsBlack<TPixel>(Image<TPixel> image)
+        private static void ClearTransparentPixels<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Rgba32 rgba32 = default;
@@ -207,7 +208,7 @@ private static void MakeTransparentPixelsBlack<TPixel>(Image<TPixel> image)
 
                     if (rgba32.A == 0)
                     {
-                        span[x].FromRgba32(Color.Black);
+                        span[x].FromRgba32(Color.Transparent);
                     }
                 }
             }
@@ -224,15 +225,15 @@ private IndexedImageFrame<TPixel> CreateQuantizedImage<TPixel>(Image<TPixel> ima
             where TPixel : unmanaged, IPixel<TPixel>
         {
             IndexedImageFrame<TPixel> quantized;
-            if (this.options.MakeTransparentBlack)
+            if (this.options.TransparentColorBehavior == PngTransparentColorBehavior.Clear)
             {
                 quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, clonedImage);
-                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, clonedImage, quantized);
+                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, quantized);
             }
             else
             {
                 quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, image);
-                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, image, quantized);
+                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, quantized);
             }
 
             return quantized;

src/ImageSharp/Formats/Png/PngEncoderOptions.cs

@@ -30,7 +30,8 @@ public PngEncoderOptions(IPngEncoderOptions source)
             this.Threshold = source.Threshold;
             this.InterlaceMethod = source.InterlaceMethod;
             this.ChunkFilter = source.ChunkFilter;
-            this.MakeTransparentBlack = source.MakeTransparentBlack;
+            this.IgnoreMetadata = source.IgnoreMetadata;
+            this.TransparentColorBehavior = source.TransparentColorBehavior;
         }
 
         /// <inheritdoc/>
@@ -60,12 +61,13 @@ public PngEncoderOptions(IPngEncoderOptions source)
         /// <inheritdoc/>
         public PngInterlaceMode? InterlaceMethod { get; set; }
 
-        /// <summary>
-        /// Gets or sets a the optimize method.
-        /// </summary>
+        /// <inheritdoc/>
         public PngChunkFilter? ChunkFilter { get; set; }
 
         /// <inheritdoc/>
-        public bool MakeTransparentBlack { get; set; }
+        public bool IgnoreMetadata { get; set; }
+
+        /// <inheritdoc/>
+        public PngTransparentColorBehavior TransparentColorBehavior { get; set; }
     }
 }

src/ImageSharp/Formats/Png/PngEncoderOptionsHelpers.cs

@@ -40,6 +40,11 @@ public static void AdjustOptions<TPixel>(
             use16Bit = options.BitDepth == PngBitDepth.Bit16;
             bytesPerPixel = CalculateBytesPerPixel(options.ColorType, use16Bit);
 
+            if (options.IgnoreMetadata)
+            {
+                options.ChunkFilter = PngChunkFilter.ExcludeAll;
+            }
+
             // Ensure we are not allowing impossible combinations.
             if (!PngConstants.ColorTypes.ContainsKey(options.ColorType.Value))
             {
@@ -89,11 +94,9 @@ public static IndexedImageFrame<TPixel> CreateQuantizedFrame<TPixel>(
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="options">The options.</param>
-        /// <param name="image">The image.</param>
         /// <param name="quantizedFrame">The quantized frame.</param>
         public static byte CalculateBitDepth<TPixel>(
             PngEncoderOptions options,
-            Image<TPixel> image,
             IndexedImageFrame<TPixel> quantizedFrame)
             where TPixel : unmanaged, IPixel<TPixel>
         {

src/ImageSharp/Formats/Png/PngTransparentColorBehavior.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the GNU Affero General Public License, Version 3.
+
+namespace SixLabors.ImageSharp.Formats.Png
+{
+    /// <summary>
+    /// Enum indicating how the transparency should be handled on encoding.
+    /// </summary>
+    public enum PngTransparentColorBehavior
+    {
+        /// <summary>
+        /// Converts fully transparent pixels that may contain R, G, B values which are not 0,
+        /// to transparent black, which can yield in better compression in some cases.
+        /// </summary>
+        Clear,
+
+        /// <summary>
+        /// The transparency will be kept as is.
+        /// </summary>
+        Preserve
+    }
+}

tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.Chunks.cs

@@ -144,6 +144,58 @@ public void Chunk_ComesBeforeIDat(object chunkTypeObj)
             }
         }
 
+        [Fact]
+        public void IgnoreMetadata_WillExcludeAllAncillaryChunks()
+        {
+            // arrange
+            var testFile = TestFile.Create(TestImages.Png.PngWithMetadata);
+            using Image<Rgba32> input = testFile.CreateRgba32Image();
+            using var memStream = new MemoryStream();
+            var encoder = new PngEncoder() { IgnoreMetadata = true, TextCompressionThreshold = 8 };
+            var expectedChunkTypes = new Dictionary<PngChunkType, bool>()
+            {
+                { PngChunkType.Header, false },
+                { PngChunkType.Palette, false },
+                { PngChunkType.Data, false },
+                { PngChunkType.End, false }
+            };
+            var excludedChunkTypes = new List<PngChunkType>()
+            {
+                PngChunkType.Gamma,
+                PngChunkType.Exif,
+                PngChunkType.Physical,
+                PngChunkType.Text,
+                PngChunkType.InternationalText,
+                PngChunkType.CompressedText,
+            };
+
+            // act
+            input.Save(memStream, encoder);
+
+            // assert
+            Assert.True(excludedChunkTypes.Count > 0);
+            memStream.Position = 0;
+            Span<byte> bytesSpan = memStream.ToArray().AsSpan(8); // Skip header.
+            while (bytesSpan.Length > 0)
+            {
+                int length = BinaryPrimitives.ReadInt32BigEndian(bytesSpan.Slice(0, 4));
+                var chunkType = (PngChunkType)BinaryPrimitives.ReadInt32BigEndian(bytesSpan.Slice(4, 4));
+                Assert.False(excludedChunkTypes.Contains(chunkType), $"{chunkType} chunk should have been excluded");
+                if (expectedChunkTypes.ContainsKey(chunkType))
+                {
+                    expectedChunkTypes[chunkType] = true;
+                }
+
+                bytesSpan = bytesSpan.Slice(4 + 4 + length + 4);
+            }
+
+            // all expected chunk types should have been seen at least once.
+            foreach (PngChunkType chunkType in expectedChunkTypes.Keys)
+            {
+                Assert.True(expectedChunkTypes[chunkType], $"We expect {chunkType} chunk to be present at least once");
+            }
+        }
+
         [Theory]
         [InlineData(PngChunkFilter.ExcludeGammaChunk)]
         [InlineData(PngChunkFilter.ExcludeExifChunk)]

tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs

@@ -392,17 +392,15 @@ public void Encode_PreserveBits(string imagePath, PngBitDepth pngBitDepth)
 
         [Theory]
         [InlineData(PngColorType.Palette)]
-        [InlineData(PngColorType.Rgb)]
         [InlineData(PngColorType.RgbWithAlpha)]
-        [InlineData(PngColorType.Grayscale)]
         [InlineData(PngColorType.GrayscaleWithAlpha)]
-        public void Encode_WithMakeTransparentBlackOption_Works(PngColorType colorType)
+        public void Encode_WithPngTransparentColorBehaviorClear_Works(PngColorType colorType)
         {
             // arrange
             var image = new Image<Rgba32>(50, 50);
             var encoder = new PngEncoder()
             {
-                MakeTransparentBlack = true,
+                TransparentColorBehavior = PngTransparentColorBehavior.Clear,
                 ColorType = colorType
             };
             Rgba32 rgba32 = Color.Blue;
@@ -442,7 +440,7 @@ public void Encode_WithMakeTransparentBlackOption_Works(PngColorType colorType)
 
                 if (y > 25)
                 {
-                    expectedColor = Color.Black;
+                    expectedColor = Color.Transparent;
                 }
 
                 for (int x = 0; x < actual.Width; x++)