Add Compression, PhotometricInterpretation and Predictor to TiffFrameMetadata

brianpopow · brianpopow · commit 11a4e2027b22 · 2021-05-21T19:08:41.000+02:00
diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
@@ -14,17 +14,15 @@ namespace SixLabors.ImageSharp.Formats.Tiff
     /// </summary>
     internal static class TiffDecoderOptionsParser
     {
-        private const TiffPredictor DefaultPredictor = TiffPredictor.None;
-
         private const TiffPlanarConfiguration DefaultPlanarConfiguration = TiffPlanarConfiguration.Chunky;
 
         /// <summary>
         /// Determines the TIFF compression and color types, and reads any associated parameters.
         /// </summary>
         /// <param name="options">The options.</param>
         /// <param name="exifProfile">The exif profile of the frame to decode.</param>
-        /// <param name="entries">The IFD entries container to read the image format information for.</param>
-        public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata entries)
+        /// <param name="frameMetadata">The IFD entries container to read the image format information for current frame.</param>
+        public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata frameMetadata)
         {
             if (exifProfile.GetValue(ExifTag.TileOffsets)?.Value != null)
             {
@@ -42,8 +40,7 @@ public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exif
                 TiffThrowHelper.ThrowNotSupported("The lower-order bits of the byte FillOrder is not supported.");
             }
 
-            TiffPredictor predictor = (TiffPredictor?)exifProfile.GetValue(ExifTag.Predictor)?.Value ?? DefaultPredictor;
-            if (predictor == TiffPredictor.FloatingPoint)
+            if (frameMetadata.Predictor == TiffPredictor.FloatingPoint)
             {
                 TiffThrowHelper.ThrowNotSupported("TIFF images with FloatingPoint horizontal predictor are not supported.");
             }
@@ -68,14 +65,13 @@ public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exif
             VerifyRequiredFieldsArePresent(exifProfile);
 
             options.PlanarConfiguration = (TiffPlanarConfiguration?)exifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value ?? DefaultPlanarConfiguration;
-            options.Predictor = predictor;
-            options.PhotometricInterpretation = exifProfile.GetValue(ExifTag.PhotometricInterpretation) != null ?
-                (TiffPhotometricInterpretation)exifProfile.GetValue(ExifTag.PhotometricInterpretation).Value : TiffPhotometricInterpretation.BlackIsZero;
-            options.BitsPerPixel = entries.BitsPerPixel != null ? (int)entries.BitsPerPixel.Value : (int)TiffBitsPerPixel.Bit24;
-            options.BitsPerSample = GetBitsPerSample(entries.BitsPerPixel);
-
-            ParseColorType(options, exifProfile);
-            ParseCompression(options, exifProfile);
+            options.Predictor = frameMetadata.Predictor ?? TiffFrameMetadata.DefaultPredictor;
+            options.PhotometricInterpretation = frameMetadata.PhotometricInterpretation ?? TiffFrameMetadata.DefaultPhotometricInterpretation;
+            options.BitsPerPixel = frameMetadata.BitsPerPixel != null ? (int)frameMetadata.BitsPerPixel.Value : (int)TiffFrameMetadata.DefaultBitsPerPixel;
+            options.BitsPerSample = GetBitsPerSample(frameMetadata.BitsPerPixel);
+
+            options.ParseColorType(exifProfile);
+            options.ParseCompression(frameMetadata.Compression, exifProfile);
         }
 
         private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile)
@@ -222,9 +218,8 @@ private static void ParseColorType(this TiffDecoderCore options, ExifProfile exi
             }
         }
 
-        private static void ParseCompression(this TiffDecoderCore options, ExifProfile exifProfile)
+        private static void ParseCompression(this TiffDecoderCore options, TiffCompression? compression, ExifProfile exifProfile)
         {
-            TiffCompression compression = exifProfile.GetValue(ExifTag.Compression) != null ? (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value : TiffCompression.None;
             switch (compression)
             {
                 case TiffCompression.None:
diff --git a/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs b/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
@@ -111,19 +111,12 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                 : rootFramePhotometricInterpretation;
 
             ImageFrameMetadata rootFrameMetaData = image.Frames.RootFrame.Metadata;
-            ExifProfile rootFrameExifProfile = image.Frames.RootFrame.Metadata.ExifProfile;
-            TiffBitsPerPixel? rootFrameBitsPerPixel = rootFrameMetaData.GetTiffMetadata().BitsPerPixel;
+            TiffFrameMetadata rootFrameTiffMetaData = rootFrameMetaData.GetTiffMetadata();
+            TiffBitsPerPixel? rootFrameBitsPerPixel = rootFrameTiffMetaData.BitsPerPixel;
 
             // If the user has not chosen a predictor or compression, set the values from the decoded image, if present.
-            if (!this.HorizontalPredictor.HasValue && rootFrameExifProfile?.GetValue(ExifTag.Predictor) != null)
-            {
-                this.HorizontalPredictor = (TiffPredictor)rootFrameExifProfile?.GetValue(ExifTag.Predictor).Value;
-            }
-
-            if (!this.CompressionType.HasValue && rootFrameExifProfile?.GetValue(ExifTag.Compression) != null)
-            {
-                this.CompressionType = (TiffCompression)rootFrameExifProfile?.GetValue(ExifTag.Compression).Value;
-            }
+            this.HorizontalPredictor ??= rootFrameTiffMetaData.Predictor;
+            this.CompressionType ??= rootFrameTiffMetaData.Compression;
 
             this.SetBitsPerPixel(rootFrameBitsPerPixel, image.PixelType.BitsPerPixel, photometricInterpretation);
             this.SetPhotometricInterpretation(photometricInterpretation);
diff --git a/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs b/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Formats.Tiff.Constants;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 
 namespace SixLabors.ImageSharp.Formats.Tiff
@@ -10,6 +11,26 @@ namespace SixLabors.ImageSharp.Formats.Tiff
     /// </summary>
     public class TiffFrameMetadata : IDeepCloneable
     {
+        /// <summary>
+        /// The default predictor is None.
+        /// </summary>
+        public const TiffPredictor DefaultPredictor = TiffPredictor.None;
+
+        /// <summary>
+        /// The default bits per pixel is Bit24.
+        /// </summary>
+        public const TiffBitsPerPixel DefaultBitsPerPixel = TiffBitsPerPixel.Bit24;
+
+        /// <summary>
+        /// The default compression is None.
+        /// </summary>
+        public const TiffCompression DefaultCompression = TiffCompression.None;
+
+        /// <summary>
+        /// The default photometric interpretation is BlackIsZero.
+        /// </summary>
+        public const TiffPhotometricInterpretation DefaultPhotometricInterpretation = TiffPhotometricInterpretation.BlackIsZero;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="TiffFrameMetadata"/> class.
         /// </summary>
@@ -28,6 +49,21 @@ public TiffFrameMetadata()
         /// </summary>
         public TiffBitsPerPixel? BitsPerPixel { get; set; }
 
+        /// <summary>
+        /// Gets or sets the compression scheme used on the image data.
+        /// </summary>
+        public TiffCompression? Compression { get; set; }
+
+        /// <summary>
+        /// Gets or sets the color space of the image data.
+        /// </summary>
+        public TiffPhotometricInterpretation? PhotometricInterpretation { get; set; }
+
+        /// <summary>
+        /// Gets or sets a mathematical operator that is applied to the image data before an encoding scheme is applied.
+        /// </summary>
+        public TiffPredictor? Predictor { get; set; }
+
         /// <summary>
         /// Returns a new <see cref="TiffFrameMetadata"/> instance parsed from the given Exif profile.
         /// </summary>
@@ -52,6 +88,13 @@ internal static void Parse(TiffFrameMetadata meta, ExifProfile profile)
 
             ushort[] bitsPerSample = profile.GetValue(ExifTag.BitsPerSample)?.Value;
             meta.BitsPerPixel = BitsPerPixelFromBitsPerSample(bitsPerSample);
+            meta.Compression = (TiffCompression?)profile.GetValue(ExifTag.Compression)?.Value ?? DefaultCompression;
+            meta.PhotometricInterpretation = (TiffPhotometricInterpretation?)profile.GetValue(ExifTag.PhotometricInterpretation)?.Value ?? DefaultPhotometricInterpretation;
+            meta.Predictor = (TiffPredictor?)profile.GetValue(ExifTag.Predictor)?.Value ?? DefaultPredictor;
+
+            profile.RemoveValue(ExifTag.Compression);
+            profile.RemoveValue(ExifTag.PhotometricInterpretation);
+            profile.RemoveValue(ExifTag.Predictor);
         }
 
         /// <summary>
@@ -63,7 +106,7 @@ private static TiffBitsPerPixel BitsPerPixelFromBitsPerSample(ushort[] bitsPerSa
         {
             if (bitsPerSample == null)
             {
-                return TiffBitsPerPixel.Bit24;
+                return DefaultBitsPerPixel;
             }
 
             int bitsPerPixel = 0;
@@ -76,6 +119,17 @@ private static TiffBitsPerPixel BitsPerPixelFromBitsPerSample(ushort[] bitsPerSa
         }
 
         /// <inheritdoc/>
-        public IDeepCloneable DeepClone() => new TiffFrameMetadata(this);
+        public IDeepCloneable DeepClone()
+        {
+            var clone = new TiffFrameMetadata
+            {
+                BitsPerPixel = this.BitsPerPixel,
+                Compression = this.Compression,
+                PhotometricInterpretation = this.PhotometricInterpretation,
+                Predictor = this.Predictor
+            };
+
+            return clone;
+        }
     }
 }
diff --git a/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs b/src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
@@ -167,7 +167,7 @@ public IExifValue<TValueType> GetValue<TValueType>(ExifTag<TValueType> tag)
         /// </summary>
         /// <param name="tag">The tag of the EXIF value.</param>
         /// <returns>
-        /// The <see cref="bool"/>.
+        /// True, if the value was removed, otherwise false.
         /// </returns>
         public bool RemoveValue(ExifTag tag)
         {
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
@@ -48,15 +48,14 @@ public void EncoderOptions_SetPhotometricInterpretation_Works(TiffPhotometricInt
             // assert
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
-            var frameMetaData = TiffFrameMetadata.Parse(exifProfile);
+            TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
-            Assert.Equal(TiffCompression.None, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
+            Assert.Equal(TiffCompression.None, frameMetaData.Compression);
         }
 
         [Theory]
         [InlineData(TiffBitsPerPixel.Bit24)]
-        [InlineData(TiffBitsPerPixel.Bit8)]
+        [InlineData(TiffBitsPerPixel.Bit8)] 
         [InlineData(TiffBitsPerPixel.Bit4)]
         [InlineData(TiffBitsPerPixel.Bit1)]
         public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel)
@@ -73,10 +72,9 @@ public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel)
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
 
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
             TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel);
-            Assert.Equal(TiffCompression.None, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
+            Assert.Equal(TiffCompression.None, frameMetaData.Compression);
         }
 
         [Theory]
@@ -112,10 +110,9 @@ public void EncoderOptions_SetPhotometricInterpretationAndCompression_Works(Tiff
             // assert
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
             TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel);
-            Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
+            Assert.Equal(expectedCompression, rootFrameMetaData.Compression);
         }
 
         [Theory]
@@ -151,7 +148,7 @@ public void TiffEncoder_PreservesBitsPerPixel_WhenInputIsL8()
             var tiffEncoder = new TiffEncoder();
             using Image input = new Image<L8>(10, 10);
             using var memStream = new MemoryStream();
-            var expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
+            TiffBitsPerPixel expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
 
             // act
             input.Save(memStream, tiffEncoder);
@@ -183,8 +180,7 @@ public void TiffEncoder_PreservesCompression<TPixel>(TestImageProvider<TPixel> p
             // assert
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
-            Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
+            Assert.Equal(expectedCompression, output.Frames.RootFrame.Metadata.GetTiffMetadata().Compression);
         }
 
         [Theory]
@@ -206,8 +202,8 @@ public void TiffEncoder_PreservesPredictor<TPixel>(TestImageProvider<TPixel> pro
             // assert
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
-            Assert.Equal(expectedPredictor, (TiffPredictor)exifProfile.GetValue(ExifTag.Predictor).Value);
+            TiffFrameMetadata frameMetadata = output.Frames.RootFrame.Metadata.GetTiffMetadata();
+            Assert.Equal(expectedPredictor, frameMetadata.Predictor);
         }
 
         [Theory]
@@ -229,10 +225,9 @@ public void TiffEncoder_EncodesWithCorrectBiColorModeCompression<TPixel>(TestIma
             // assert
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
-            ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
-            var frameMetaData = TiffFrameMetadata.Parse(exifProfile);
+            TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel);
-            Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
+            Assert.Equal(expectedCompression, frameMetaData.Compression);
         }
 
         [Theory]
@@ -402,9 +397,8 @@ private static void TestStripLength<TPixel>(TestImageProvider<TPixel> provider,
             var tiffEncoder = new TiffEncoder() { PhotometricInterpretation = photometricInterpretation, Compression = compression };
             using Image<TPixel> input = provider.GetImage();
             using var memStream = new MemoryStream();
-            ExifProfile exifProfileInput = input.Frames.RootFrame.Metadata.ExifProfile;
-            var inputCompression = (TiffCompression)exifProfileInput.GetValue(ExifTag.Compression).Value;
-            var inputMeta = TiffFrameMetadata.Parse(exifProfileInput);
+            TiffFrameMetadata inputMeta = input.Frames.RootFrame.Metadata.GetTiffMetadata();
+            TiffCompression inputCompression = inputMeta.Compression ?? TiffCompression.None;
 
             // act
             input.Save(memStream, tiffEncoder);
@@ -413,7 +407,7 @@ private static void TestStripLength<TPixel>(TestImageProvider<TPixel> provider,
             memStream.Position = 0;
             using var output = Image.Load<Rgba32>(Configuration, memStream);
             ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile;
-            var outputMeta = TiffFrameMetadata.Parse(exifProfileOutput);
+            TiffFrameMetadata outputMeta = output.Frames.RootFrame.Metadata.GetTiffMetadata();
             ImageFrame<Rgba32> rootFrame = output.Frames.RootFrame;
 
             Number rowsPerStrip = exifProfileOutput.GetValue(ExifTag.RowsPerStrip) != null ? exifProfileOutput.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity;
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs

Original file line number	Diff line number	Diff line change
`@@ -14,17 +14,15 @@ namespace SixLabors.ImageSharp.Formats.Tiff`
`14`	`14`	`/// </summary>`
`15`	`15`	`internal static class TiffDecoderOptionsParser`
`16`	`16`	`{`
`17`		`- private const TiffPredictor DefaultPredictor = TiffPredictor.None;`
`18`		`-`
`19`	`17`	`private const TiffPlanarConfiguration DefaultPlanarConfiguration = TiffPlanarConfiguration.Chunky;`
`20`	`18`
`21`	`19`	`/// <summary>`
`22`	`20`	`/// Determines the TIFF compression and color types, and reads any associated parameters.`
`23`	`21`	`/// </summary>`
`24`	`22`	`/// <param name="options">The options.</param>`
`25`	`23`	`/// <param name="exifProfile">The exif profile of the frame to decode.</param>`
`26`		`- /// <param name="entries">The IFD entries container to read the image format information for.</param>`
`27`		`- public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata entries)`
	`24`	`+ /// <param name="frameMetadata">The IFD entries container to read the image format information for current frame.</param>`
	`25`	`+ public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata frameMetadata)`
`28`	`26`	`{`
`29`	`27`	`if (exifProfile.GetValue(ExifTag.TileOffsets)?.Value != null)`
`30`	`28`	`{`
`@@ -42,8 +40,7 @@ public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exif`
`42`	`40`	`TiffThrowHelper.ThrowNotSupported("The lower-order bits of the byte FillOrder is not supported.");`
`43`	`41`	`}`
`44`	`42`
`45`		`- TiffPredictor predictor = (TiffPredictor?)exifProfile.GetValue(ExifTag.Predictor)?.Value ?? DefaultPredictor;`
`46`		`- if (predictor == TiffPredictor.FloatingPoint)`
	`43`	`+ if (frameMetadata.Predictor == TiffPredictor.FloatingPoint)`
`47`	`44`	`{`
`48`	`45`	`TiffThrowHelper.ThrowNotSupported("TIFF images with FloatingPoint horizontal predictor are not supported.");`
`49`	`46`	`}`
`@@ -68,14 +65,13 @@ public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exif`
`68`	`65`	`VerifyRequiredFieldsArePresent(exifProfile);`
`69`	`66`
`70`	`67`	`options.PlanarConfiguration = (TiffPlanarConfiguration?)exifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value ?? DefaultPlanarConfiguration;`
`71`		`- options.Predictor = predictor;`
`72`		`- options.PhotometricInterpretation = exifProfile.GetValue(ExifTag.PhotometricInterpretation) != null ?`
`73`		`- (TiffPhotometricInterpretation)exifProfile.GetValue(ExifTag.PhotometricInterpretation).Value : TiffPhotometricInterpretation.BlackIsZero;`
`74`		`- options.BitsPerPixel = entries.BitsPerPixel != null ? (int)entries.BitsPerPixel.Value : (int)TiffBitsPerPixel.Bit24;`
`75`		`- options.BitsPerSample = GetBitsPerSample(entries.BitsPerPixel);`
`76`		`-`
`77`		`- ParseColorType(options, exifProfile);`
`78`		`- ParseCompression(options, exifProfile);`
	`68`	`+ options.Predictor = frameMetadata.Predictor ?? TiffFrameMetadata.DefaultPredictor;`
	`69`	`+ options.PhotometricInterpretation = frameMetadata.PhotometricInterpretation ?? TiffFrameMetadata.DefaultPhotometricInterpretation;`
	`70`	`+ options.BitsPerPixel = frameMetadata.BitsPerPixel != null ? (int)frameMetadata.BitsPerPixel.Value : (int)TiffFrameMetadata.DefaultBitsPerPixel;`
	`71`	`+ options.BitsPerSample = GetBitsPerSample(frameMetadata.BitsPerPixel);`
	`72`	`+`
	`73`	`+ options.ParseColorType(exifProfile);`
	`74`	`+ options.ParseCompression(frameMetadata.Compression, exifProfile);`
`79`	`75`	`}`
`80`	`76`
`81`	`77`	`private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile)`
`@@ -222,9 +218,8 @@ private static void ParseColorType(this TiffDecoderCore options, ExifProfile exi`
`222`	`218`	`}`
`223`	`219`	`}`
`224`	`220`
`225`		`- private static void ParseCompression(this TiffDecoderCore options, ExifProfile exifProfile)`
	`221`	`+ private static void ParseCompression(this TiffDecoderCore options, TiffCompression? compression, ExifProfile exifProfile)`
`226`	`222`	`{`
`227`		`- TiffCompression compression = exifProfile.GetValue(ExifTag.Compression) != null ? (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value : TiffCompression.None;`
`228`	`223`	`switch (compression)`
`229`	`224`	`{`
`230`	`225`	`case TiffCompression.None:`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ public IExifValue<TValueType> GetValue<TValueType>(ExifTag<TValueType> tag)`
`167`	`167`	`/// </summary>`
`168`	`168`	`/// <param name="tag">The tag of the EXIF value.</param>`
`169`	`169`	`/// <returns>`
`170`		`- /// The <see cref="bool"/>.`
	`170`	`+ /// True, if the value was removed, otherwise false.`
`171`	`171`	`/// </returns>`
`172`	`172`	`public bool RemoveValue(ExifTag tag)`
`173`	`173`	`{`