Add support for decoding 10 bit per channel rgb tiff's

src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs

@@ -115,6 +115,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Constants
         /// </summary>
         public static readonly ushort[] BitsPerSampleRgb10Bit = { 10, 10, 10 };
 
+        /// <summary>
+        /// The bits per sample for color images with 14 bits for each color channel.
+        /// </summary>
+        public static readonly ushort[] BitsPerSampleRgb14Bit = { 14, 14, 14 };
+
         /// <summary>
         /// The list of mimetypes that equate to a tiff.
         /// </summary>

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

@@ -97,6 +97,16 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
                     DebugGuard.IsTrue(colorMap == null, "colorMap");
                     return new RgbTiffColor<TPixel>(bitsPerSample);
 
+                case TiffColorType.Rgb141414:
+                    DebugGuard.IsTrue(
+                        bitsPerSample.Length == 3
+                        && bitsPerSample[0] == 14
+                        && bitsPerSample[1] == 14
+                        && bitsPerSample[2] == 14,
+                        "bitsPerSample");
+                    DebugGuard.IsTrue(colorMap == null, "colorMap");
+                    return new RgbTiffColor<TPixel>(bitsPerSample);
+
                 case TiffColorType.PaletteColor:
                     DebugGuard.NotNull(bitsPerSample, "bitsPerSample");
                     DebugGuard.NotNull(colorMap, "colorMap");

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

@@ -78,6 +78,11 @@ namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation
         /// </summary>
         Rgb101010,
 
+        /// <summary>
+        /// RGB color image with 14 bits for each channel.
+        /// </summary>
+        Rgb141414,
+
         /// <summary>
         /// RGB Full Color. Planar configuration of data.
         /// </summary>

src/ImageSharp/Formats/Tiff/TiffBitsPerPixel.cs

@@ -48,5 +48,12 @@ namespace SixLabors.ImageSharp.Formats.Tiff
         /// Note: The TiffEncoder does not yet support 10 bits per color channel and will default to 24 bits per pixel instead.
         /// </summary>
         Bit30 = 30,
+
+        /// <summary>
+        /// 42 bits per pixel. 14 bit for each color channel.
+        ///
+        /// Note: The TiffEncoder does not yet support 14 bits per color channel and will default to 24 bits per pixel instead.
+        /// </summary>
+        Bit42 = 42,
     }
 }

src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs

@@ -47,5 +47,10 @@ namespace SixLabors.ImageSharp.Formats.Tiff
         /// Thirty bits per sample, each channel has 10 bits.
         /// </summary>
         Bit30 = 30,
+
+        /// <summary>
+        /// Forty two bits per sample, each channel has 14 bits.
+        /// </summary>
+        Bit42 = 42,
     }
 }

src/ImageSharp/Formats/Tiff/TiffBitsPerSampleExtensions.cs

@@ -31,6 +31,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     return TiffConstants.BitsPerSampleRgb8Bit;
                 case TiffBitsPerSample.Bit30:
                     return TiffConstants.BitsPerSampleRgb10Bit;
+                case TiffBitsPerSample.Bit42:
+                    return TiffConstants.BitsPerSampleRgb14Bit;
 
                 default:
                     return Array.Empty<ushort>();
@@ -47,6 +49,13 @@ namespace SixLabors.ImageSharp.Formats.Tiff
             switch (bitsPerSample.Length)
             {
                 case 3:
+                    if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb14Bit[2] &&
+                        bitsPerSample[1] == TiffConstants.BitsPerSampleRgb14Bit[1] &&
+                        bitsPerSample[0] == TiffConstants.BitsPerSampleRgb14Bit[0])
+                    {
+                        return TiffBitsPerSample.Bit42;
+                    }
+
                     if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb10Bit[2] &&
                         bitsPerSample[1] == TiffConstants.BitsPerSampleRgb10Bit[1] &&
                         bitsPerSample[0] == TiffConstants.BitsPerSampleRgb10Bit[0])

src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs

@@ -182,6 +182,10 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     {
                         switch (options.BitsPerSample)
                         {
+                            case TiffBitsPerSample.Bit42:
+                                options.ColorType = TiffColorType.Rgb141414;
+                                break;
+
                             case TiffBitsPerSample.Bit30:
                                 options.ColorType = TiffColorType.Rgb101010;
                                 break;
@@ -297,6 +301,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
             TiffBitsPerPixel.Bit12 => TiffBitsPerSample.Bit12,
             TiffBitsPerPixel.Bit24 => TiffBitsPerSample.Bit24,
             TiffBitsPerPixel.Bit30 => TiffBitsPerSample.Bit30,
+            TiffBitsPerPixel.Bit42 => TiffBitsPerSample.Bit42,
             _ => throw new NotSupportedException("The bits per pixel are not supported"),
         };
     }

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -322,7 +322,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff
                     case TiffBitsPerPixel.Bit6:
                     case TiffBitsPerPixel.Bit12:
                     case TiffBitsPerPixel.Bit30:
-                        // Encoding 30, 12 and 6 bits per pixel is not yet supported. Default to 24 bits.
+                    case TiffBitsPerPixel.Bit42:
+                        // Encoding 42, 30, 12 and 6 bits per pixel is not yet supported. Default to 24 bits.
                         this.SetEncoderOptions(TiffBitsPerPixel.Bit24, TiffPhotometricInterpretation.Rgb, compression, TiffPredictor.None);
                         break;
                     default:

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

@@ -117,6 +117,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         public void TiffDecoder_CanDecode_30Bit<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 
+        [Theory]
+        [WithFile(FlowerRgb141414Contiguous, PixelTypes.Rgba32)]
+        [WithFile(FlowerRgb141414Planar, PixelTypes.Rgba32)]
+        public void TiffDecoder_CanDecode_42Bit<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
+
         [Theory]
         [WithFile(GrayscaleDeflateMultistrip, PixelTypes.Rgba32)]
         [WithFile(RgbDeflateMultistrip, PixelTypes.Rgba32)]

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

@@ -78,6 +78,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         }
 
         [Theory]
+        [InlineData(TiffBitsPerPixel.Bit42)]
         [InlineData(TiffBitsPerPixel.Bit30)]
         [InlineData(TiffBitsPerPixel.Bit12)]
         [InlineData(TiffBitsPerPixel.Bit6)]

tests/ImageSharp.Tests/TestImages.cs

@@ -560,6 +560,8 @@ namespace SixLabors.ImageSharp.Tests
             public const string RgbPaletteDeflate = "Tiff/rgb_palette_deflate.tiff";
             public const string Flower4BitPalette = "Tiff/flower-palette-04.tiff";
             public const string Flower4BitPaletteGray = "Tiff/flower-minisblack-04.tiff";
+            public const string FlowerRgb141414Contiguous = "Tiff/flower-rgb-contig-14.tiff";
+            public const string FlowerRgb141414Planar = "Tiff/flower-rgb-planar-14.tiff";
             public const string FlowerRgb101010Contiguous = "Tiff/flower-rgb-contig-10.tiff";
             public const string FlowerRgb101010Planar = "Tiff/flower-rgb-planar-10.tiff";
             public const string FlowerRgb444Contiguous = "Tiff/flower-rgb-contig-04.tiff";

tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs

@@ -25,10 +25,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
         {
         }
 
-        public MagickReferenceDecoder(bool validate)
-        {
-            this.validate = validate;
-        }
+        public MagickReferenceDecoder(bool validate) => this.validate = validate;
 
         public static MagickReferenceDecoder Instance { get; } = new MagickReferenceDecoder();
 
@@ -93,7 +90,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs
 
                     FromRgba32Bytes(configuration, data, framePixels);
                 }
-                else if (magicFrame.Depth == 16)
+                else if (magicFrame.Depth == 16 || magicFrame.Depth == 14)
                 {
                     ushort[] data = pixels.ToShortArray(PixelMapping.RGBA);
                     Span<byte> bytes = MemoryMarshal.Cast<ushort, byte>(data.AsSpan());

tests/Images/Input/Tiff/flower-rgb-contig-14.tiff

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

tests/Images/Input/Tiff/flower-rgb-planar-14.tiff

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