Added: ability to skip unneeded chunks for optimization mode

src/ImageSharp/Formats/Png/IPngEncoderOptions.cs

@@ -57,5 +57,15 @@ internal interface IPngEncoderOptions
         /// Gets a value indicating whether this instance should write an Adam7 interlaced image.
         /// </summary>
         PngInterlaceMode? InterlaceMethod { get; }
+
+        /// <summary>
+        /// Gets the optimize method.
+        /// </summary>
+        PngChunkFilter? ChunkFilter { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether fully transparent pixels should be converted to black pixels.
+        /// </summary>
+        bool MakeTransparentBlack { get; }
     }
 }

src/ImageSharp/Formats/Png/PngChunkFilter.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Png
+{
+    /// <summary>
+    /// Provides enumeration of available PNG optimization methods.
+    /// </summary>
+    [Flags]
+    public enum PngChunkFilter
+    {
+        /// <summary>
+        /// With the None filter, all chunks will be written.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Excludes the physical dimension information chunk from encoding.
+        /// </summary>
+        ExcludePhysicalChunk = 1 << 0,
+
+        /// <summary>
+        /// Excludes the gamma information chunk from encoding.
+        /// </summary>
+        ExcludeGammaChunk = 1 << 1,
+
+        /// <summary>
+        /// Excludes the eXIf chunk from encoding.
+        /// </summary>
+        ExcludeExifChunk = 1 << 2,
+
+        /// <summary>
+        /// Excludes the tTXt, iTXt or zTXt chunk from encoding.
+        /// </summary>
+        ExcludeTextChunks = 1 << 3,
+
+        /// <summary>
+        /// All possible optimizations.
+        /// </summary>
+        ExcludeAll = ExcludePhysicalChunk | ExcludeGammaChunk | ExcludeExifChunk | ExcludeTextChunks
+    }
+}

src/ImageSharp/Formats/Png/PngEncoder.cs

@@ -42,6 +42,16 @@ public sealed class PngEncoder : IImageEncoder, IPngEncoderOptions
         /// <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>
+        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; }
+
         /// <summary>
         /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
         /// </summary>

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -7,7 +7,7 @@
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Advanced;
+
 using SixLabors.ImageSharp.Formats.Png.Chunks;
 using SixLabors.ImageSharp.Formats.Png.Filters;
 using SixLabors.ImageSharp.Formats.Png.Zlib;
@@ -141,10 +141,17 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             this.height = image.Height;
 
             ImageMetadata metadata = image.Metadata;
-            PngMetadata pngMetadata = metadata.GetPngMetadata();
+
+            PngMetadata pngMetadata = metadata.GetFormatMetadata(PngFormat.Instance);
             PngEncoderOptionsHelpers.AdjustOptions<TPixel>(this.options, pngMetadata, out this.use16Bit, out this.bytesPerPixel);
-            IndexedImageFrame<TPixel> quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, image);
-            this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, image, quantized);
+            Image<TPixel> clonedImage = null;
+            if (this.options.MakeTransparentBlack)
+            {
+                clonedImage = image.Clone();
+                MakeTransparentPixelsBlack(clonedImage);
+            }
+
+            IndexedImageFrame<TPixel> quantized = this.CreateQuantizedImage(image, clonedImage);
 
             stream.Write(PngConstants.HeaderBytes);
 
@@ -155,11 +162,13 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             this.WritePhysicalChunk(stream, metadata);
             this.WriteExifChunk(stream, metadata);
             this.WriteTextChunks(stream, pngMetadata);
-            this.WriteDataChunks(image.Frames.RootFrame, quantized, stream);
+            this.WriteDataChunks(this.options.MakeTransparentBlack ? clonedImage : image, quantized, stream);
             this.WriteEndChunk(stream);
+
             stream.Flush();
 
             quantized?.Dispose();
+            clonedImage?.Dispose();
         }
 
         /// <inheritdoc />
@@ -180,6 +189,55 @@ public void Dispose()
             this.filterBuffer = null;
         }
 
+        /// <summary>
+        /// Makes transparent pixels black.
+        /// </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)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Rgba32 rgba32 = default;
+            for (int y = 0; y < image.Height; y++)
+            {
+                Span<TPixel> span = image.GetPixelRowSpan(y);
+                for (int x = 0; x < image.Width; x++)
+                {
+                    span[x].ToRgba32(ref rgba32);
+
+                    if (rgba32.A == 0)
+                    {
+                        span[x].FromRgba32(Color.Black);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates the quantized image and sets calculates and sets the bit depth.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="image">The image to quantize.</param>
+        /// <param name="clonedImage">Cloned image with transparent pixels are changed to black.</param>
+        /// <returns>The quantized image.</returns>
+        private IndexedImageFrame<TPixel> CreateQuantizedImage<TPixel>(Image<TPixel> image, Image<TPixel> clonedImage)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            IndexedImageFrame<TPixel> quantized;
+            if (this.options.MakeTransparentBlack)
+            {
+                quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, clonedImage);
+                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, clonedImage, quantized);
+            }
+            else
+            {
+                quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, image);
+                this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, image, quantized);
+            }
+
+            return quantized;
+        }
+
         /// <summary>Collects a row of grayscale pixels.</summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="rowSpan">The image row span.</param>
@@ -602,6 +660,11 @@ private void WritePaletteChunk<TPixel>(Stream stream, IndexedImageFrame<TPixel>
         /// <param name="meta">The image metadata.</param>
         private void WritePhysicalChunk(Stream stream, ImageMetadata meta)
         {
+            if (((this.options.ChunkFilter ?? PngChunkFilter.None) & PngChunkFilter.ExcludePhysicalChunk) == PngChunkFilter.ExcludePhysicalChunk)
+            {
+                return;
+            }
+
             PhysicalChunkData.FromMetadata(meta).WriteTo(this.chunkDataBuffer);
 
             this.WriteChunk(stream, PngChunkType.Physical, this.chunkDataBuffer, 0, PhysicalChunkData.Size);
@@ -614,6 +677,11 @@ private void WritePhysicalChunk(Stream stream, ImageMetadata meta)
         /// <param name="meta">The image metadata.</param>
         private void WriteExifChunk(Stream stream, ImageMetadata meta)
         {
+            if (((this.options.ChunkFilter ?? PngChunkFilter.None) & PngChunkFilter.ExcludeExifChunk) == PngChunkFilter.ExcludeExifChunk)
+            {
+                return;
+            }
+
             if (meta.ExifProfile is null || meta.ExifProfile.Values.Count == 0)
             {
                 return;
@@ -631,6 +699,11 @@ private void WriteExifChunk(Stream stream, ImageMetadata meta)
         /// <param name="meta">The image metadata.</param>
         private void WriteTextChunks(Stream stream, PngMetadata meta)
         {
+            if (((this.options.ChunkFilter ?? PngChunkFilter.None) & PngChunkFilter.ExcludeTextChunks) == PngChunkFilter.ExcludeTextChunks)
+            {
+                return;
+            }
+
             const int MaxLatinCode = 255;
             for (int i = 0; i < meta.TextData.Count; i++)
             {
@@ -723,6 +796,11 @@ private byte[] GetCompressedTextBytes(byte[] textBytes)
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
         private void WriteGammaChunk(Stream stream)
         {
+            if (((this.options.ChunkFilter ?? PngChunkFilter.None) & PngChunkFilter.ExcludeGammaChunk) == PngChunkFilter.ExcludeGammaChunk)
+            {
+                return;
+            }
+
             if (this.options.Gamma > 0)
             {
                 // 4-byte unsigned integer of gamma * 100,000.
@@ -792,7 +870,7 @@ private void WriteTransparencyChunk(Stream stream, PngMetadata pngMetadata)
         /// <param name="pixels">The image.</param>
         /// <param name="quantized">The quantized pixel data. Can be null.</param>
         /// <param name="stream">The stream.</param>
-        private void WriteDataChunks<TPixel>(ImageFrame<TPixel> pixels, IndexedImageFrame<TPixel> quantized, Stream stream)
+        private void WriteDataChunks<TPixel>(Image<TPixel> pixels, IndexedImageFrame<TPixel> quantized, Stream stream)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             byte[] buffer;
@@ -890,8 +968,8 @@ private void AllocateExtBuffers()
         /// <param name="pixels">The pixels.</param>
         /// <param name="quantized">The quantized pixels span.</param>
         /// <param name="deflateStream">The deflate stream.</param>
-        private void EncodePixels<TPixel>(ImageFrame<TPixel> pixels, IndexedImageFrame<TPixel> quantized, ZlibDeflateStream deflateStream)
-        where TPixel : unmanaged, IPixel<TPixel>
+        private void EncodePixels<TPixel>(Image<TPixel> pixels, IndexedImageFrame<TPixel> quantized, ZlibDeflateStream deflateStream)
+            where TPixel : unmanaged, IPixel<TPixel>
         {
             int bytesPerScanline = this.CalculateScanlineLength(this.width);
             int resultLength = bytesPerScanline + 1;
@@ -914,7 +992,7 @@ private void EncodePixels<TPixel>(ImageFrame<TPixel> pixels, IndexedImageFrame<T
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="pixels">The pixels.</param>
         /// <param name="deflateStream">The deflate stream.</param>
-        private void EncodeAdam7Pixels<TPixel>(ImageFrame<TPixel> pixels, ZlibDeflateStream deflateStream)
+        private void EncodeAdam7Pixels<TPixel>(Image<TPixel> pixels, ZlibDeflateStream deflateStream)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = pixels.Width;

src/ImageSharp/Formats/Png/PngEncoderOptions.cs

@@ -29,6 +29,8 @@ public PngEncoderOptions(IPngEncoderOptions source)
             this.Quantizer = source.Quantizer;
             this.Threshold = source.Threshold;
             this.InterlaceMethod = source.InterlaceMethod;
+            this.ChunkFilter = source.ChunkFilter;
+            this.MakeTransparentBlack = source.MakeTransparentBlack;
         }
 
         /// <inheritdoc/>
@@ -57,5 +59,13 @@ public PngEncoderOptions(IPngEncoderOptions source)
 
         /// <inheritdoc/>
         public PngInterlaceMode? InterlaceMethod { get; set; }
+
+        /// <summary>
+        /// Gets or sets a the optimize method.
+        /// </summary>
+        public PngChunkFilter? ChunkFilter { get; set; }
+
+        /// <inheritdoc/>
+        public bool MakeTransparentBlack { get; set; }
     }
 }