Add support for decoding tiff's with T.6 fax compression

Author: brianpopow

src/ImageSharp/Formats/Tiff/Compression/Decompressors/CcittReferenceScanline.cs

@@ -0,0 +1,154 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
+{
+    /// <summary>
+    /// Represents a reference scan line for CCITT 2D decoding.
+    /// </summary>
+    internal readonly ref struct CcittReferenceScanline
+    {
+        private readonly ReadOnlySpan<byte> scanLine;
+        private readonly int width;
+        private readonly byte whiteByte;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CcittReferenceScanline"/> struct.
+        /// </summary>
+        /// <param name="whiteIsZero">Indicates, if white is zero, otherwise black is zero.</param>
+        /// <param name="scanLine">The scan line.</param>
+        public CcittReferenceScanline(bool whiteIsZero, ReadOnlySpan<byte> scanLine)
+        {
+            this.scanLine = scanLine;
+            this.width = scanLine.Length;
+            this.whiteByte = whiteIsZero ? (byte)0 : (byte)255;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CcittReferenceScanline"/> struct.
+        /// </summary>
+        /// <param name="whiteIsZero">Indicates, if white is zero, otherwise black is zero.</param>
+        /// <param name="width">The width of the scanline.</param>
+        public CcittReferenceScanline(bool whiteIsZero, int width)
+        {
+            this.scanLine = default;
+            this.width = width;
+            this.whiteByte = whiteIsZero ? (byte)0 : (byte)255;
+        }
+
+        public bool IsEmpty => this.scanLine.IsEmpty;
+
+        /// <summary>
+        /// Finds b1: The first changing element on the reference line to the right of a0 and of opposite color to a0.
+        /// </summary>
+        /// <param name="a0">The reference or starting element om the coding line.</param>
+        /// <param name="a0Byte">Fill byte.</param>
+        /// <returns>Position of b1.</returns>
+        public int FindB1(int a0, byte a0Byte)
+        {
+            if (this.scanLine.IsEmpty)
+            {
+                return this.FindB1ForImaginaryWhiteLine(a0, a0Byte);
+            }
+
+            return this.FindB1ForNormalLine(a0, a0Byte);
+        }
+
+        /// <summary>
+        /// Finds b2: The next changing element to the right of b1 on the reference line.
+        /// </summary>
+        /// <param name="b1">The first changing element on the reference line to the right of a0 and opposite of color to a0.</param>
+        /// <returns>Position of b1.</returns>
+        public int FindB2(int b1)
+        {
+            if (this.scanLine.IsEmpty)
+            {
+                return this.FindB2ForImaginaryWhiteLine();
+            }
+
+            return this.FindB2ForNormalLine(b1);
+        }
+
+        private int FindB1ForImaginaryWhiteLine(int a0, byte a0Byte)
+        {
+            if (a0 < 0)
+            {
+                if (a0Byte != this.whiteByte)
+                {
+                    return 0;
+                }
+            }
+
+            return this.width;
+        }
+
+        private int FindB1ForNormalLine(int a0, byte a0Byte)
+        {
+            int offset = 0;
+            if (a0 < 0)
+            {
+                if (a0Byte != this.scanLine[0])
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                offset = a0;
+            }
+
+            ReadOnlySpan<byte> searchSpace = this.scanLine.Slice(offset);
+            byte searchByte = (byte)~a0Byte;
+            int index = searchSpace.IndexOf(searchByte);
+            if (index < 0)
+            {
+                return this.scanLine.Length;
+            }
+
+            if (index != 0)
+            {
+                return offset + index;
+            }
+
+            searchByte = (byte)~searchSpace[0];
+            index = searchSpace.IndexOf(searchByte);
+            if (index < 0)
+            {
+                return this.scanLine.Length;
+            }
+
+            searchSpace = searchSpace.Slice(index);
+            offset += index;
+            index = searchSpace.IndexOf((byte)~searchByte);
+            if (index < 0)
+            {
+                return this.scanLine.Length;
+            }
+
+            return index + offset;
+        }
+
+        private int FindB2ForImaginaryWhiteLine() => this.width;
+
+        private int FindB2ForNormalLine(int b1)
+        {
+            if (b1 >= this.scanLine.Length)
+            {
+                return this.scanLine.Length;
+            }
+
+            byte searchByte = (byte)~this.scanLine[b1];
+            int offset = b1 + 1;
+            ReadOnlySpan<byte> searchSpace = this.scanLine.Slice(offset);
+            int index = searchSpace.IndexOf(searchByte);
+            if (index == -1)
+            {
+                return this.scanLine.Length;
+            }
+
+            return offset + index;
+        }
+    }
+}

src/ImageSharp/Formats/Tiff/Compression/Decompressors/CcittTwoDimensionalCode.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Diagnostics;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
+{
+    [DebuggerDisplay("Type = {Type}")]
+    internal readonly struct CcittTwoDimensionalCode
+    {
+        private readonly ushort value;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CcittTwoDimensionalCode"/> struct.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <param name="bitsRequired">The bits required.</param>
+        /// <param name="extensionBits">The extension bits.</param>
+        public CcittTwoDimensionalCode(CcittTwoDimensionalCodeType type, int bitsRequired, int extensionBits = 0)
+            => this.value = (ushort)((byte)type | ((bitsRequired & 0b1111) << 8) | ((extensionBits & 0b111) << 11));
+
+        /// <summary>
+        /// Gets the code type.
+        /// </summary>
+        public CcittTwoDimensionalCodeType Type => (CcittTwoDimensionalCodeType)(this.value & 0b11111111);
+    }
+}

src/ImageSharp/Formats/Tiff/Compression/Decompressors/CcittTwoDimensionalCodeType.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
+{
+    internal enum CcittTwoDimensionalCodeType
+    {
+        None = 0,
+
+        Pass = 1,
+
+        Horizontal = 2,
+
+        Vertical0 = 3,
+
+        VerticalR1 = 4,
+
+        VerticalR2 = 5,
+
+        VerticalR3 = 6,
+
+        VerticalL1 = 7,
+
+        VerticalL2 = 8,
+
+        VerticalL3 = 9,
+
+        Extensions1D = 10,
+
+        Extensions2D = 11,
+    }
+}

src/ImageSharp/Formats/Tiff/Compression/Decompressors/DeflateTiffCompression.cs

@@ -41,7 +41,7 @@ public DeflateTiffCompression(MemoryAllocator memoryAllocator, int width, int bi
         }
 
         /// <inheritdoc/>
-        protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer)
+        protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
         {
             long pos = stream.Position;
             using (var deframeStream = new ZlibInflateStream(

src/ImageSharp/Formats/Tiff/Compression/Decompressors/LzwTiffCompression.cs

@@ -35,7 +35,7 @@ public LzwTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPe
         }
 
         /// <inheritdoc/>
-        protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer)
+        protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
         {
             var decoder = new TiffLzwDecoder(stream);
             decoder.DecodePixels(buffer);

src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanBitReader.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using SixLabors.ImageSharp.Formats.Tiff.Constants;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
+{
+    /// <summary>
+    /// Bit reader for data encoded with the modified huffman rle method.
+    /// See TIFF 6.0 specification, section 10.
+    /// </summary>
+    internal class ModifiedHuffmanBitReader : T4BitReader
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ModifiedHuffmanBitReader"/> class.
+        /// </summary>
+        /// <param name="input">The compressed input stream.</param>
+        /// <param name="fillOrder">The logical order of bits within a byte.</param>
+        /// <param name="bytesToRead">The number of bytes to read from the stream.</param>
+        /// <param name="allocator">The memory allocator.</param>
+        public ModifiedHuffmanBitReader(Stream input, TiffFillOrder fillOrder, int bytesToRead, MemoryAllocator allocator)
+            : base(input, fillOrder, bytesToRead, allocator)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool HasMoreData => this.Position < (ulong)this.DataLength - 1 || (this.BitsRead > 0 && this.BitsRead < 7);
+
+        /// <inheritdoc/>
+        public override bool IsEndOfScanLine
+        {
+            get
+            {
+                if (this.IsWhiteRun && this.CurValueBitsRead == 12 && this.Value == 1)
+                {
+                    return true;
+                }
+
+                if (this.CurValueBitsRead == 11 && this.Value == 0)
+                {
+                    // black run.
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void StartNewRow()
+        {
+            base.StartNewRow();
+
+            int pad = 8 - (this.BitsRead % 8);
+            if (pad != 8)
+            {
+                // Skip padding bits, move to next byte.
+                this.Position++;
+                this.ResetBitsRead();
+            }
+        }
+
+        /// <summary>
+        /// No EOL is expected at the start of a run for the modified huffman encoding.
+        /// </summary>
+        protected override void ReadEolBeforeFirstData()
+        {
+            // Nothing to do here.
+        }
+    }
+}

src/ImageSharp/Formats/Tiff/Compression/Decompressors/ModifiedHuffmanTiffCompression.cs

@@ -35,9 +35,9 @@ public ModifiedHuffmanTiffCompression(MemoryAllocator allocator, TiffFillOrder f
         }
 
         /// <inheritdoc/>
-        protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer)
+        protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
         {
-            using var bitReader = new T4BitReader(stream, this.FillOrder, byteCount, this.Allocator, eolPadding: false, isModifiedHuffman: true);
+            using var bitReader = new ModifiedHuffmanBitReader(stream, this.FillOrder, byteCount, this.Allocator);
 
             buffer.Clear();
             uint bitsWritten = 0;
@@ -51,20 +51,20 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, Spa
                     if (bitReader.IsWhiteRun)
                     {
                         BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.whiteValue);
-                        bitsWritten += bitReader.RunLength;
-                        pixelsWritten += bitReader.RunLength;
                     }
                     else
                     {
                         BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.blackValue);
-                        bitsWritten += bitReader.RunLength;
-                        pixelsWritten += bitReader.RunLength;
                     }
+
+                    bitsWritten += bitReader.RunLength;
+                    pixelsWritten += bitReader.RunLength;
                 }
 
-                if (pixelsWritten % this.Width == 0)
+                if (pixelsWritten == this.Width)
                 {
                     bitReader.StartNewRow();
+                    pixelsWritten = 0;
 
                     // Write padding bits, if necessary.
                     uint pad = 8 - (bitsWritten % 8);
@@ -74,6 +74,11 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, Spa
                         bitsWritten += pad;
                     }
                 }
+
+                if (pixelsWritten > this.Width)
+                {
+                    TiffThrowHelper.ThrowImageFormatException("ccitt compression parsing error, decoded more pixels then image width");
+                }
             }
         }
     }

src/ImageSharp/Formats/Tiff/Compression/Decompressors/NoneTiffCompression.cs

@@ -25,7 +25,8 @@ public NoneTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsP
         }
 
         /// <inheritdoc/>
-        protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) => _ = stream.Read(buffer, 0, Math.Min(buffer.Length, byteCount));
+        protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
+            => _ = stream.Read(buffer, 0, Math.Min(buffer.Length, byteCount));
 
         /// <inheritdoc/>
         protected override void Dispose(bool disposing)

src/ImageSharp/Formats/Tiff/Compression/Decompressors/PackBitsTiffCompression.cs

@@ -28,7 +28,7 @@ public PackBitsTiffCompression(MemoryAllocator memoryAllocator, int width, int b
         }
 
         /// <inheritdoc/>
-        protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer)
+        protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
         {
             if (this.compressedDataMemory == null)
             {