Added HighBitDepth to the JpegWriteDefines.

Author: dlemstra

src/Magick.NET/Formats/Jpeg/JpegWriteDefines.cs

@@ -32,6 +32,11 @@ public sealed class JpegWriteDefines : IWriteDefines
     public MagickFormat Format
         => MagickFormat.Jpeg;
 
+    /// <summary>
+    /// Gets or sets a value indicating whether the pixels can be written in 12 or 16 bit instead of 8 bit (jpeg:high-bit-depth).
+    /// </summary>
+    public bool? HighBitDepth { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether optimize coding is enabled or disabled (jpeg:optimize-coding).
     /// </summary>
@@ -63,6 +68,9 @@ public IEnumerable<IDefine> Defines
             if (Extent.HasValue)
                 yield return new MagickDefine(Format, "extent", Extent.Value + "KB");
 
+            if (HighBitDepth.HasValue)
+                yield return new MagickDefine(Format, "high-bit-depth", HighBitDepth.Value);
+
             if (OptimizeCoding.HasValue)
                 yield return new MagickDefine(Format, "optimize-coding", OptimizeCoding.Value);
 

tests/Magick.NET.Tests/Formats/Jpeg/JpegWriteDefinesTests/TheConstructor.cs

@@ -20,6 +20,7 @@ public void ShouldNotSetAnyDefine()
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "arithmetic-coding"));
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "dct-method"));
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "extent"));
+            Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "high-bit-depth"));
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "optimize-coding"));
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "quality"));
             Assert.Null(image.Settings.GetDefine(MagickFormat.Jpeg, "q-table"));

tests/Magick.NET.Tests/Formats/Jpeg/JpegWriteDefinesTests/TheHighBitDepthProperty.cs

@@ -0,0 +1,137 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using ImageMagick;
+using ImageMagick.Formats;
+using Xunit;
+
+namespace Magick.NET.Tests;
+
+public partial class JpegWriteDefinesTests
+{
+    public class TheHighBitDepthProperty
+    {
+        [Fact]
+        public void ShouldSetTheDefine()
+        {
+            var defines = new JpegWriteDefines
+            {
+                HighBitDepth = true,
+            };
+
+            using var image = new MagickImage();
+            image.Settings.SetDefines(defines);
+
+            Assert.Equal("true", image.Settings.GetDefine(MagickFormat.Jpeg, "high-bit-depth"));
+        }
+
+        [Fact]
+        public void ShouldEncodeTheImageIn8bitWhenNotSet()
+        {
+            var defines = new JpegWriteDefines
+            {
+                HighBitDepth = false,
+            };
+
+            using var input = new MagickImage(Files.FujiFilmFinePixS1ProJPG);
+            input.Depth = 16;
+
+            using var memStream = new MemoryStream();
+            input.Write(memStream, defines);
+
+            memStream.Position = 0;
+            using var output = new MagickImage(memStream);
+            Assert.Equal(8u, output.Depth);
+        }
+
+        [Fact]
+        public void ShouldEncodeTheImageIn12bit()
+        {
+            var defines = new JpegWriteDefines
+            {
+                HighBitDepth = true,
+            };
+
+            using var input = new MagickImage(Files.FujiFilmFinePixS1ProJPG);
+            input.Depth = 11;
+
+            using var memStream = new MemoryStream();
+            input.Write(memStream, defines);
+
+            memStream.Position = 0;
+            using var output = new MagickImage(memStream);
+            Assert.Equal(12u, output.Depth);
+        }
+
+        [Theory]
+        [InlineData(2, 8)]
+        [InlineData(3, 8)]
+        [InlineData(4, 8)]
+        [InlineData(5, 8)]
+        [InlineData(6, 8)]
+        [InlineData(7, 8)]
+        [InlineData(8, 8)]
+        [InlineData(9, 12)]
+        [InlineData(10, 12)]
+        [InlineData(11, 12)]
+        [InlineData(12, 12)]
+        [InlineData(13, 12)]
+        [InlineData(14, 12)]
+        [InlineData(15, 12)]
+        [InlineData(16, 12)]
+        public void ShouldEncodeTheImageInTheCorrectBitDepthWhenNotCompressingLossless(uint depth, uint expectedDepth)
+        {
+            var defines = new JpegWriteDefines
+            {
+                HighBitDepth = true,
+            };
+
+            using var input = new MagickImage(Files.FujiFilmFinePixS1ProJPG);
+            input.Depth = depth;
+
+            using var memStream = new MemoryStream();
+            input.Write(memStream, defines);
+
+            memStream.Position = 0;
+            using var output = new MagickImage(memStream);
+            Assert.Equal(expectedDepth, output.Depth);
+        }
+
+        [Theory]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        [InlineData(7)]
+        [InlineData(8)]
+        [InlineData(9)]
+        [InlineData(10)]
+        [InlineData(11)]
+        [InlineData(12)]
+        [InlineData(13)]
+        [InlineData(14)]
+        [InlineData(15)]
+        [InlineData(16)]
+        public void ShouldEncodeTheImageInTheSpecifiedDepthWhenCompressingLossless(uint depth)
+        {
+            var defines = new JpegWriteDefines
+            {
+                HighBitDepth = true,
+            };
+
+            using var input = new MagickImage(Files.FujiFilmFinePixS1ProJPG);
+            input.Depth = depth;
+            input.Quality = 100;
+            input.Settings.Compression = CompressionMethod.LosslessJPEG;
+
+            using var memStream = new MemoryStream();
+            input.Write(memStream, defines);
+
+            memStream.Position = 0;
+            using var output = new MagickImage(memStream);
+            Assert.Equal(depth, output.Depth);
+        }
+    }
+}