Merge pull request #1019 from Sheyne/master

Allow inferring of some PngEncoderOptions

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -144,8 +144,8 @@ namespace SixLabors.ImageSharp.Formats.Png
             this.height = image.Height;
 
             ImageMetadata metadata = image.Metadata;
-            PngMetadata pngMetadata = metadata.GetFormatMetadata(PngFormat.Instance);
-            PngEncoderOptionsHelpers.AdjustOptions(this.options, pngMetadata, out this.use16Bit, out this.bytesPerPixel);
+            PngMetadata pngMetadata = metadata.GetPngMetadata();
+            PngEncoderOptionsHelpers.AdjustOptions<TPixel>(this.options, pngMetadata, out this.use16Bit, out this.bytesPerPixel);
             IQuantizedFrame<TPixel> quantized = PngEncoderOptionsHelpers.CreateQuantizedFrame(this.options, image);
             this.bitDepth = PngEncoderOptionsHelpers.CalculateBitDepth(this.options, image, quantized);
 

src/ImageSharp/Formats/Png/PngEncoderOptionsHelpers.cs

@@ -14,23 +14,28 @@ namespace SixLabors.ImageSharp.Formats.Png
     internal static class PngEncoderOptionsHelpers
     {
         /// <summary>
-        /// Adjusts the options.
+        /// Adjusts the options based upon the given metadata.
         /// </summary>
         /// <param name="options">The options.</param>
         /// <param name="pngMetadata">The PNG metadata.</param>
         /// <param name="use16Bit">if set to <c>true</c> [use16 bit].</param>
         /// <param name="bytesPerPixel">The bytes per pixel.</param>
-        public static void AdjustOptions(
+        public static void AdjustOptions<TPixel>(
             PngEncoderOptions options,
             PngMetadata pngMetadata,
             out bool use16Bit,
             out int bytesPerPixel)
+            where TPixel : struct, IPixel<TPixel>
         {
             // Always take the encoder options over the metadata values.
-            options.Gamma = options.Gamma ?? pngMetadata.Gamma;
-            options.ColorType = options.ColorType ?? pngMetadata.ColorType;
-            options.BitDepth = options.BitDepth ?? pngMetadata.BitDepth;
-            options.InterlaceMethod = options.InterlaceMethod ?? pngMetadata.InterlaceMethod;
+            options.Gamma ??= pngMetadata.Gamma;
+
+            // Use options, then check metadata, if nothing set there then we suggest
+            // a sensible default based upon the pixel format.
+            options.ColorType ??= pngMetadata.ColorType ?? SuggestColorType<TPixel>();
+            options.BitDepth ??= pngMetadata.BitDepth ?? SuggestBitDepth<TPixel>();
+
+            options.InterlaceMethod ??= pngMetadata.InterlaceMethod;
 
             use16Bit = options.BitDepth == PngBitDepth.Bit16;
             bytesPerPixel = CalculateBytesPerPixel(options.ColorType, use16Bit);
@@ -129,24 +134,68 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <returns>Bytes per pixel.</returns>
         private static int CalculateBytesPerPixel(PngColorType? pngColorType, bool use16Bit)
         {
-            switch (pngColorType)
+            return pngColorType switch
             {
-                case PngColorType.Grayscale:
-                    return use16Bit ? 2 : 1;
+                PngColorType.Grayscale => use16Bit ? 2 : 1,
+                PngColorType.GrayscaleWithAlpha => use16Bit ? 4 : 2,
+                PngColorType.Palette => 1,
+                PngColorType.Rgb => use16Bit ? 6 : 3,
 
-                case PngColorType.GrayscaleWithAlpha:
-                    return use16Bit ? 4 : 2;
-
-                case PngColorType.Palette:
-                    return 1;
+                // PngColorType.RgbWithAlpha
+                _ => use16Bit ? 8 : 4,
+            };
+        }
 
-                case PngColorType.Rgb:
-                    return use16Bit ? 6 : 3;
+        /// <summary>
+        /// Returns a suggested <see cref="PngColorType"/> for the given <typeparamref name="TPixel"/>
+        /// This is not exhaustive but covers many common pixel formats.
+        /// </summary>
+        private static PngColorType SuggestColorType<TPixel>()
+            where TPixel : struct, IPixel<TPixel>
+        {
+            return typeof(TPixel) switch
+            {
+                Type t when t == typeof(A8) => PngColorType.GrayscaleWithAlpha,
+                Type t when t == typeof(Argb32) => PngColorType.RgbWithAlpha,
+                Type t when t == typeof(Bgr24) => PngColorType.Rgb,
+                Type t when t == typeof(Bgra32) => PngColorType.RgbWithAlpha,
+                Type t when t == typeof(L8) => PngColorType.Grayscale,
+                Type t when t == typeof(L16) => PngColorType.Grayscale,
+                Type t when t == typeof(La16) => PngColorType.GrayscaleWithAlpha,
+                Type t when t == typeof(La32) => PngColorType.GrayscaleWithAlpha,
+                Type t when t == typeof(Rgb24) => PngColorType.Rgb,
+                Type t when t == typeof(Rgba32) => PngColorType.RgbWithAlpha,
+                Type t when t == typeof(Rgb48) => PngColorType.Rgb,
+                Type t when t == typeof(Rgba64) => PngColorType.RgbWithAlpha,
+                Type t when t == typeof(RgbaVector) => PngColorType.RgbWithAlpha,
+                _ => PngColorType.RgbWithAlpha
+            };
+        }
 
-                // PngColorType.RgbWithAlpha
-                default:
-                    return use16Bit ? 8 : 4;
-            }
+        /// <summary>
+        /// Returns a suggested <see cref="PngBitDepth"/> for the given <typeparamref name="TPixel"/>
+        /// This is not exhaustive but covers many common pixel formats.
+        /// </summary>
+        private static PngBitDepth SuggestBitDepth<TPixel>()
+            where TPixel : struct, IPixel<TPixel>
+        {
+            return typeof(TPixel) switch
+            {
+                Type t when t == typeof(A8) => PngBitDepth.Bit8,
+                Type t when t == typeof(Argb32) => PngBitDepth.Bit8,
+                Type t when t == typeof(Bgr24) => PngBitDepth.Bit8,
+                Type t when t == typeof(Bgra32) => PngBitDepth.Bit8,
+                Type t when t == typeof(L8) => PngBitDepth.Bit8,
+                Type t when t == typeof(L16) => PngBitDepth.Bit16,
+                Type t when t == typeof(La16) => PngBitDepth.Bit8,
+                Type t when t == typeof(La32) => PngBitDepth.Bit16,
+                Type t when t == typeof(Rgb24) => PngBitDepth.Bit8,
+                Type t when t == typeof(Rgba32) => PngBitDepth.Bit8,
+                Type t when t == typeof(Rgb48) => PngBitDepth.Bit16,
+                Type t when t == typeof(Rgba64) => PngBitDepth.Bit16,
+                Type t when t == typeof(RgbaVector) => PngBitDepth.Bit16,
+                _ => PngBitDepth.Bit8
+            };
         }
     }
 }

src/ImageSharp/Formats/Png/PngMetadata.cs

@@ -44,12 +44,12 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// Gets or sets the number of bits per sample or per palette index (not per pixel).
         /// Not all values are allowed for all <see cref="ColorType"/> values.
         /// </summary>
-        public PngBitDepth BitDepth { get; set; } = PngBitDepth.Bit8;
+        public PngBitDepth? BitDepth { get; set; }
 
         /// <summary>
         /// Gets or sets the color type.
         /// </summary>
-        public PngColorType ColorType { get; set; } = PngColorType.RgbWithAlpha;
+        public PngColorType? ColorType { get; set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether this instance should write an Adam7 interlaced image.

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

@@ -201,6 +201,54 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
             }
         }
 
+        [Theory]
+        [WithBlankImages(1, 1, PixelTypes.A8, PngColorType.GrayscaleWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Argb32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Bgr565, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Bgra4444, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Byte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.HalfSingle, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.HalfVector2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.HalfVector4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.NormalizedByte2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.NormalizedByte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.NormalizedShort4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Rg32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Rgba1010102, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Rgba32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.RgbaVector, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+        [WithBlankImages(1, 1, PixelTypes.Short2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Short4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Rgb24, PngColorType.Rgb, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Bgr24, PngColorType.Rgb, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Bgra32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.Rgb48, PngColorType.Rgb, PngBitDepth.Bit16)]
+        [WithBlankImages(1, 1, PixelTypes.Rgba64, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+        [WithBlankImages(1, 1, PixelTypes.Bgra5551, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.L8, PngColorType.Grayscale, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.L16, PngColorType.Grayscale, PngBitDepth.Bit16)]
+        [WithBlankImages(1, 1, PixelTypes.La16, PngColorType.GrayscaleWithAlpha, PngBitDepth.Bit8)]
+        [WithBlankImages(1, 1, PixelTypes.La32, PngColorType.GrayscaleWithAlpha, PngBitDepth.Bit16)]
+        public void InfersColorTypeAndBitDepth<TPixel>(TestImageProvider<TPixel> provider, PngColorType pngColorType, PngBitDepth pngBitDepth)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Stream stream = new MemoryStream())
+            {
+                var encoder = new PngEncoder();
+                encoder.Encode(provider.GetImage(), stream);
+
+                stream.Seek(0, SeekOrigin.Begin);
+
+                var decoder = new PngDecoder();
+
+                Image image = decoder.Decode(Configuration.Default, stream);
+
+                PngMetadata metadata = image.Metadata.GetPngMetadata();
+                Assert.Equal(pngColorType, metadata.ColorType);
+                Assert.Equal(pngBitDepth, metadata.BitDepth);
+            }
+        }
+
         [Theory]
         [WithFile(TestImages.Png.Palette8Bpp, nameof(PaletteLargeOnly), PixelTypes.Rgba32)]
         public void PaletteColorType_WuQuantizer<TPixel>(TestImageProvider<TPixel> provider, int paletteSize)

tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
@@ -62,9 +62,15 @@ namespace SixLabors.ImageSharp.Tests
 
         L8 = 1 << 23,
 
+        L16 = 1 << 24,
+
+        La16 = 1 << 25,
+
+        La32 = 1 << 26,
+
         // TODO: Add multi-flag entries by rules defined in PackedPixelConverterHelper
 
         // "All" is handled as a separate, individual case instead of using bitwise OR
         All = 30
     }
-}
+}