Tiff decoder now respects byte order for 16 bit gray images

Author: brianpopow

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero16TiffColor{TPixel}.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Formats.Tiff.Utils;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
+{
+    /// <summary>
+    /// Implements the 'BlackIsZero' photometric interpretation for 16-bit grayscale images.
+    /// </summary>
+    internal class BlackIsZero16TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        private readonly bool isBigEndian;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlackIsZero16TiffColor{TPixel}" /> class.
+        /// </summary>
+        /// <param name="isBigEndian">if set to <c>true</c> decodes the pixel data as big endian, otherwise as little endian.</param>
+        public BlackIsZero16TiffColor(bool isBigEndian) => this.isBigEndian = isBigEndian;
+
+        /// <inheritdoc/>
+        public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height)
+        {
+            var color = default(TPixel);
+
+            int offset = 0;
+
+            var l16 = default(L16);
+            for (int y = top; y < top + height; y++)
+            {
+                for (int x = left; x < left + width; x++)
+                {
+                    ushort intensity = TiffUtils.ConvertToShort(data.Slice(offset, 2), this.isBigEndian);
+                    offset += 2;
+
+                    l16.PackedValue = intensity;
+                    color.FromL16(l16);
+
+                    pixels[x, y] = color;
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb161616TiffColor{TPixel}.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers.Binary;
+using SixLabors.ImageSharp.Formats.Tiff.Utils;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -36,11 +37,11 @@ public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, in
 
                 for (int x = left; x < left + width; x++)
                 {
-                    ulong r = this.ConvertToShort(data.Slice(offset, 2));
+                    ulong r = TiffUtils.ConvertToShort(data.Slice(offset, 2), this.isBigEndian);
                     offset += 2;
-                    ulong g = this.ConvertToShort(data.Slice(offset, 2));
+                    ulong g = TiffUtils.ConvertToShort(data.Slice(offset, 2), this.isBigEndian);
                     offset += 2;
-                    ulong b = this.ConvertToShort(data.Slice(offset, 2));
+                    ulong b = TiffUtils.ConvertToShort(data.Slice(offset, 2), this.isBigEndian);
                     offset += 2;
 
                     rgba.PackedValue = r | (g << 16) | (b << 32) | (0xfffful << 48);
@@ -50,9 +51,5 @@ public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, in
                 }
             }
         }
-
-        private ushort ConvertToShort(ReadOnlySpan<byte> buffer) => this.isBigEndian
-                ? BinaryPrimitives.ReadUInt16BigEndian(buffer)
-                : BinaryPrimitives.ReadUInt16LittleEndian(buffer);
     }
 }

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorDecoderFactory{TPixel}.cs

@@ -52,6 +52,11 @@ public static TiffBaseColorDecoder<TPixel> Create(TiffColorType colorType, TiffB
                     DebugGuard.IsTrue(colorMap == null, "colorMap");
                     return new BlackIsZero8TiffColor<TPixel>();
 
+                case TiffColorType.BlackIsZero16:
+                    DebugGuard.IsTrue(bitsPerSample.Channels == 1 && bitsPerSample.Channel0 == 16, "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new BlackIsZero16TiffColor<TPixel>(byteOrder == ByteOrder.BigEndian);
+
                 case TiffColorType.Rgb:
                     DebugGuard.IsTrue(colorMap == null, "colorMap");
                     return new RgbTiffColor<TPixel>(bitsPerSample);

src/ImageSharp/Formats/Tiff/PhotometricInterpretation/TiffColorType.cs

@@ -28,6 +28,11 @@ internal enum TiffColorType
         /// </summary>
         BlackIsZero8,
 
+        /// <summary>
+        /// Grayscale: 0 is imaged as black. The maximum value is imaged as white. Optimized implementation for 16-bit images.
+        /// </summary>
+        BlackIsZero16,
+
         /// <summary>
         /// Grayscale: 0 is imaged as white. The maximum value is imaged as black.
         /// </summary>

src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs

@@ -154,6 +154,12 @@ private static void ParseColorType(this TiffDecoderCore options, ExifProfile exi
 
                     switch (bitsPerChannel)
                     {
+                        case 16:
+                        {
+                            options.ColorType = TiffColorType.BlackIsZero16;
+                            break;
+                        }
+
                         case 8:
                         {
                             options.ColorType = TiffColorType.BlackIsZero8;

src/ImageSharp/Formats/Tiff/Utils/TiffUtils.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Utils
+{
+    /// <summary>
+    /// Helper methods for TIFF decoding.
+    /// </summary>
+    internal static class TiffUtils
+    {
+        public static ushort ConvertToShort(ReadOnlySpan<byte> buffer, bool isBigEndian) => isBigEndian
+            ? BinaryPrimitives.ReadUInt16BigEndian(buffer)
+            : BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+    }
+}

tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs

@@ -140,6 +140,7 @@ public void TiffDecoder_CanDecode_14Bit<TPixel>(TestImageProvider<TPixel> provid
             where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 
         [Theory]
+        [WithFile(Flower16BitGrayLittleEndian, PixelTypes.Rgba32)]
         [WithFile(Flower16BitGray, PixelTypes.Rgba32)]
         public void TiffDecoder_CanDecode_16Bit<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);

tests/ImageSharp.Tests/TestImages.cs

@@ -582,6 +582,7 @@ public static class Tiff
             public const string Flower12BitGray = "Tiff/flower-minisblack-12.tiff";
             public const string Flower14BitGray = "Tiff/flower-minisblack-14.tiff";
             public const string Flower16BitGray = "Tiff/flower-minisblack-16.tiff";
+            public const string Flower16BitGrayLittleEndian = "Tiff/flower-minisblack-16_lsb.tiff";
             public const string Issues1716Rgb161616BitLittleEndian = "Tiff/Issues/Issue1716.tiff";
 
             public const string SmallRgbDeflate = "Tiff/rgb_small_deflate.tiff";

tests/Images/Input/Tiff/flower-minisblack-16_lsb.tiff

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3806304a5453a6ec8a6795bc77b967b9aa8593288af36bbf9802f22ee27869e
+size 6588