Merge pull request #1686 from IldarKhayrutdinov/encode-multiframe

Encode multi-frame Tiff format

Author: brianpopow

src/ImageSharp/Common/Helpers/ExifResolutionValues.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Common.Helpers
+{
+    internal readonly struct ExifResolutionValues
+    {
+        public ExifResolutionValues(ushort resolutionUnit, double? horizontalResolution, double? verticalResolution)
+        {
+            this.ResolutionUnit = resolutionUnit;
+            this.HorizontalResolution = horizontalResolution;
+            this.VerticalResolution = verticalResolution;
+        }
+
+        public ushort ResolutionUnit { get; }
+
+        public double? HorizontalResolution { get; }
+
+        public double? VerticalResolution { get; }
+    }
+}

src/ImageSharp/Common/Helpers/UnitConverter.cs

@@ -98,14 +98,14 @@ public static PixelResolutionUnit ExifProfileToResolutionUnit(ExifProfile profil
         }
 
         /// <summary>
-        /// Sets the exif profile resolution values.
+        /// Gets the exif profile resolution values.
         /// </summary>
-        /// <param name="exifProfile">The exif profile.</param>
         /// <param name="unit">The resolution unit.</param>
         /// <param name="horizontal">The horizontal resolution value.</param>
         /// <param name="vertical">The vertical resolution value.</param>
+        /// <returns><see cref="ExifResolutionValues"/></returns>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public static void SetResolutionValues(ExifProfile exifProfile, PixelResolutionUnit unit, double horizontal, double vertical)
+        public static ExifResolutionValues GetExifResolutionValues(PixelResolutionUnit unit, double horizontal, double vertical)
         {
             switch (unit)
             {
@@ -115,9 +115,9 @@ public static void SetResolutionValues(ExifProfile exifProfile, PixelResolutionU
                     break;
                 case PixelResolutionUnit.PixelsPerMeter:
                     {
-                        unit = PixelResolutionUnit.PixelsPerCentimeter;
-                        horizontal = UnitConverter.MeterToCm(horizontal);
-                        vertical = UnitConverter.MeterToCm(vertical);
+                    unit = PixelResolutionUnit.PixelsPerCentimeter;
+                    horizontal = MeterToCm(horizontal);
+                    vertical = MeterToCm(vertical);
                     }
 
                     break;
@@ -126,18 +126,13 @@ public static void SetResolutionValues(ExifProfile exifProfile, PixelResolutionU
                     break;
             }
 
-            exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)(unit + 1));
-
+            ushort exifUnit = (ushort)(unit + 1);
             if (unit == PixelResolutionUnit.AspectRatio)
             {
-                exifProfile.RemoveValue(ExifTag.XResolution);
-                exifProfile.RemoveValue(ExifTag.YResolution);
-            }
-            else
-            {
-                exifProfile.SetValue(ExifTag.XResolution, new Rational(horizontal));
-                exifProfile.SetValue(ExifTag.YResolution, new Rational(vertical));
+                return new ExifResolutionValues(exifUnit, null, null);
             }
+
+            return new ExifResolutionValues(exifUnit, horizontal, vertical);
         }
     }
 }

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -74,6 +74,8 @@ internal sealed class TiffEncoderCore : IImageEncoderInternals
         /// </summary>
         private const TiffPhotometricInterpretation DefaultPhotometricInterpretation = TiffPhotometricInterpretation.Rgb;
 
+        private readonly List<(long, uint)> frameMarkers = new List<(long, uint)>();
+
         /// <summary>
         /// Initializes a new instance of the <see cref="TiffEncoderCore"/> class.
         /// </summary>
@@ -147,13 +149,25 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
             // Make sure, the Encoder options makes sense in combination with each other.
             this.SanitizeAndSetEncoderOptions(bitsPerPixel, image.PixelType.BitsPerPixel, photometricInterpretation, compression, predictor);
 
-            using (var writer = new TiffStreamWriter(stream))
+            using var writer = new TiffStreamWriter(stream);
+            long ifdMarker = this.WriteHeader(writer);
+
+            Image<TPixel> metadataImage = image;
+            foreach (ImageFrame<TPixel> frame in image.Frames)
             {
-                long firstIfdMarker = this.WriteHeader(writer);
+                var subfileType = (TiffNewSubfileType)(frame.Metadata.ExifProfile?.GetValue(ExifTag.SubfileType)?.Value ?? (int)TiffNewSubfileType.FullImage);
 
-                // TODO: multiframing is not supported
-                this.WriteImage(writer, image, firstIfdMarker);
+                ifdMarker = this.WriteFrame(writer, frame, image.Metadata, metadataImage, ifdMarker);
+                metadataImage = null;
+            }
+
+            long currentOffset = writer.BaseStream.Position;
+            foreach ((long, uint) marker in this.frameMarkers)
+            {
+                writer.WriteMarkerFast(marker.Item1, marker.Item2);
             }
+
+            writer.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
         }
 
         /// <summary>
@@ -174,41 +188,56 @@ public long WriteHeader(TiffStreamWriter writer)
         /// Writes all data required to define an image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="writer">The <see cref="BinaryWriter"/> to write data to.</param>
-        /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
+        /// <param name="writer">The <see cref="BinaryWriter" /> to write data to.</param>
+        /// <param name="frame">The tiff frame.</param>
+        /// <param name="imageMetadata">The image metadata (resolution values for each frame).</param>
+        /// <param name="image">The image (common metadata for root frame).</param>
         /// <param name="ifdOffset">The marker to write this IFD offset.</param>
-        private void WriteImage<TPixel>(TiffStreamWriter writer, Image<TPixel> image, long ifdOffset)
+        /// <returns>
+        /// The next IFD offset value.
+        /// </returns>
+        private long WriteFrame<TPixel>(
+            TiffStreamWriter writer,
+            ImageFrame<TPixel> frame,
+            ImageMetadata imageMetadata,
+            Image<TPixel> image,
+            long ifdOffset)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            var entriesCollector = new TiffEncoderEntriesCollector();
-
             using TiffBaseCompressor compressor = TiffCompressorFactory.Create(
                 this.CompressionType ?? TiffCompression.None,
                 writer.BaseStream,
                 this.memoryAllocator,
-                image.Width,
+                frame.Width,
                 (int)this.BitsPerPixel,
                 this.compressionLevel,
                 this.HorizontalPredictor == TiffPredictor.Horizontal ? this.HorizontalPredictor.Value : TiffPredictor.None);
 
+            var entriesCollector = new TiffEncoderEntriesCollector();
             using TiffBaseColorWriter<TPixel> colorWriter = TiffColorWriterFactory.Create(
                 this.PhotometricInterpretation,
-                image.Frames.RootFrame,
+                frame,
                 this.quantizer,
                 this.memoryAllocator,
                 this.configuration,
                 entriesCollector,
                 (int)this.BitsPerPixel);
 
-            int rowsPerStrip = this.CalcRowsPerStrip(image.Frames.RootFrame.Height, colorWriter.BytesPerRow);
+            int rowsPerStrip = this.CalcRowsPerStrip(frame.Height, colorWriter.BytesPerRow);
 
             colorWriter.Write(compressor, rowsPerStrip);
 
+            if (image != null)
+            {
+                entriesCollector.ProcessMetadata(image);
+            }
+
+            entriesCollector.ProcessFrameInfo(frame, imageMetadata);
             entriesCollector.ProcessImageFormat(this);
-            entriesCollector.ProcessGeneral(image);
 
-            writer.WriteMarker(ifdOffset, (uint)writer.Position);
-            long nextIfdMarker = this.WriteIfd(writer, entriesCollector.Entries);
+            this.frameMarkers.Add((ifdOffset, (uint)writer.Position));
+
+            return this.WriteIfd(writer, entriesCollector.Entries);
         }
 
         /// <summary>
@@ -272,7 +301,7 @@ private long WriteIfd(TiffStreamWriter writer, List<IExifValue> entries)
                 }
                 else
                 {
-                    var raw = new byte[length];
+                    byte[] raw = new byte[length];
                     int sz = ExifWriter.WriteValue(entry, raw, 0);
                     DebugGuard.IsTrue(sz == raw.Length, "Incorrect number of bytes written");
                     largeDataBlocks.Add(raw);