Tiff: Performance improvements for Fax4 decompression

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -75,6 +75,12 @@ public static int LeastCommonMultiple(int a, int b)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int Modulo8(int x) => x & 7;
 
+        /// <summary>
+        /// Calculates <paramref name="x"/> % 8
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static nint Modulo8(nint x) => x & 7;
+
         /// <summary>
         /// Fast (x mod m) calculator, with the restriction that
         /// <paramref name="m"/> should be power of 2.

src/ImageSharp/Formats/Tiff/Compression/BitWriterUtils.cs

@@ -2,21 +2,23 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression
 {
     internal static class BitWriterUtils
     {
-        public static void WriteBits(Span<byte> buffer, int pos, uint count, byte value)
+        public static void WriteBits(Span<byte> buffer, nint pos, nint count, byte value)
         {
-            int bitPos = pos % 8;
-            int bufferPos = pos / 8;
-            int startIdx = bufferPos + bitPos;
-            int endIdx = (int)(startIdx + count);
+            nint bitPos = Numerics.Modulo8(pos);
+            nint bufferPos = pos / 8;
+            nint startIdx = bufferPos + bitPos;
+            nint endIdx = startIdx + count;
 
             if (value == 1)
             {
-                for (int i = startIdx; i < endIdx; i++)
+                for (nint i = startIdx; i < endIdx; i++)
                 {
                     WriteBit(buffer, bufferPos, bitPos);
 
@@ -30,7 +32,7 @@ public static void WriteBits(Span<byte> buffer, int pos, uint count, byte value)
             }
             else
             {
-                for (int i = startIdx; i < endIdx; i++)
+                for (nint i = startIdx; i < endIdx; i++)
                 {
                     WriteZeroBit(buffer, bufferPos, bitPos);
 
@@ -44,8 +46,18 @@ public static void WriteBits(Span<byte> buffer, int pos, uint count, byte value)
             }
         }
 
-        public static void WriteBit(Span<byte> buffer, int bufferPos, int bitPos) => buffer[bufferPos] |= (byte)(1 << (7 - bitPos));
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void WriteBit(Span<byte> buffer, nint bufferPos, nint bitPos)
+        {
+            ref byte b = ref Unsafe.Add(ref MemoryMarshal.GetReference(buffer), bufferPos);
+            b |= (byte)(1 << (int)(7 - bitPos));
+        }
 
-        public static void WriteZeroBit(Span<byte> buffer, int bufferPos, int bitPos) => buffer[bufferPos] = (byte)(buffer[bufferPos] & ~(1 << (7 - bitPos)));
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void WriteZeroBit(Span<byte> buffer, nint bufferPos, nint bitPos)
+        {
+            ref byte b = ref Unsafe.Add(ref MemoryMarshal.GetReference(buffer), bufferPos);
+            b = (byte)(b & ~(1 << (int)(7 - bitPos)));
+        }
     }
 }

src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffCcittCompressor.cs

@@ -442,16 +442,16 @@ protected uint GetMakeupCode(uint runLength, out uint codeLength, bool isWhiteRu
         }
 
         /// <summary>
-        /// Pads output to the next byte
+        /// Pads output to the next byte.
         /// </summary>
         /// <remarks>
         /// If the output is not currently on a byte boundary,
-        /// zero-pad it to the next byte
+        /// zero-pad it to the next byte.
         /// </remarks>
         protected void PadByte()
         {
             // Check if padding is necessary.
-            if (this.bitPosition % 8 != 0)
+            if (Numerics.Modulo8(this.bitPosition) != 0)
             {
                 // Skip padding bits, move to next byte.
                 this.bytePosition++;

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

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
 {
@@ -130,6 +131,7 @@ private int FindB1ForNormalLine(int a0, byte a0Byte)
             return index + offset;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private int FindB2ForImaginaryWhiteLine() => this.width;
 
         private int FindB2ForNormalLine(int b1)

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

@@ -13,15 +13,21 @@ internal readonly struct CcittTwoDimensionalCode
         /// <summary>
         /// Initializes a new instance of the <see cref="CcittTwoDimensionalCode"/> struct.
         /// </summary>
-        /// <param name="type">The type.</param>
+        /// <param name="code">The code word.</param>
+        /// <param name="type">The type of the code.</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));
+        public CcittTwoDimensionalCode(int code, CcittTwoDimensionalCodeType type, int bitsRequired, int extensionBits = 0)
+        {
+            this.Code = code;
+            this.value = (ushort)((byte)type | ((bitsRequired & 0b1111) << 8) | ((extensionBits & 0b111) << 11));
+        }
 
         /// <summary>
         /// Gets the code type.
         /// </summary>
         public CcittTwoDimensionalCodeType Type => (CcittTwoDimensionalCodeType)(this.value & 0b11111111);
+
+        public int Code { get; }
     }
 }

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

@@ -1,9 +1,8 @@
 // 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;
+using SixLabors.ImageSharp.IO;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
 {
@@ -19,14 +18,13 @@ internal sealed class ModifiedHuffmanBitReader : T4BitReader
         /// <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)
+        public ModifiedHuffmanBitReader(BufferedReadStream input, TiffFillOrder fillOrder, int bytesToRead)
+            : base(input, fillOrder, bytesToRead)
         {
         }
 
         /// <inheritdoc/>
-        public override bool HasMoreData => this.Position < (ulong)this.DataLength - 1 || ((uint)(this.BitsRead - 1) < (7 - 1));
+        public override bool HasMoreData => this.Position < (ulong)this.DataLength - 1 || (uint)(this.BitsRead - 1) < 6;
 
         /// <inheritdoc/>
         public override bool IsEndOfScanLine
@@ -53,12 +51,11 @@ public override void StartNewRow()
         {
             base.StartNewRow();
 
-            int remainder = this.BitsRead & 7;    // bit-hack for % 8
+            int remainder = Numerics.Modulo8(this.BitsRead);
             if (remainder != 0)
             {
                 // Skip padding bits, move to next byte.
-                this.Position++;
-                this.ResetBitsRead();
+                this.AdvancePosition();
             }
         }
 

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

@@ -42,11 +42,12 @@ public ModifiedHuffmanTiffCompression(MemoryAllocator allocator, TiffFillOrder f
         /// <inheritdoc/>
         protected override void Decompress(BufferedReadStream stream, int byteCount, int stripHeight, Span<byte> buffer)
         {
-            using var bitReader = new ModifiedHuffmanBitReader(stream, this.FillOrder, byteCount, this.Allocator);
+            var bitReader = new ModifiedHuffmanBitReader(stream, this.FillOrder, byteCount);
 
             buffer.Clear();
-            uint bitsWritten = 0;
-            uint pixelsWritten = 0;
+            nint bitsWritten = 0;
+            nuint pixelsWritten = 0;
+            nint rowsWritten = 0;
             while (bitReader.HasMoreData)
             {
                 bitReader.ReadNextRun();
@@ -55,32 +56,39 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, int
                 {
                     if (bitReader.IsWhiteRun)
                     {
-                        BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.whiteValue);
+                        BitWriterUtils.WriteBits(buffer, bitsWritten, (int)bitReader.RunLength, this.whiteValue);
                     }
                     else
                     {
-                        BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.blackValue);
+                        BitWriterUtils.WriteBits(buffer, bitsWritten, (int)bitReader.RunLength, this.blackValue);
                     }
 
-                    bitsWritten += bitReader.RunLength;
+                    bitsWritten += (int)bitReader.RunLength;
                     pixelsWritten += bitReader.RunLength;
                 }
 
-                if (pixelsWritten == this.Width)
+                if (pixelsWritten == (ulong)this.Width)
                 {
-                    bitReader.StartNewRow();
+                    rowsWritten++;
                     pixelsWritten = 0;
 
                     // Write padding bits, if necessary.
-                    uint pad = 8 - (bitsWritten % 8);
+                    nint pad = 8 - Numerics.Modulo8(bitsWritten);
                     if (pad != 8)
                     {
-                        BitWriterUtils.WriteBits(buffer, (int)bitsWritten, pad, 0);
+                        BitWriterUtils.WriteBits(buffer, bitsWritten, pad, 0);
                         bitsWritten += pad;
                     }
+
+                    if (rowsWritten >= stripHeight)
+                    {
+                        break;
+                    }
+
+                    bitReader.StartNewRow();
                 }
 
-                if (pixelsWritten > this.Width)
+                if (pixelsWritten > (ulong)this.Width)
                 {
                     TiffThrowHelper.ThrowImageFormatException("ccitt compression parsing error, decoded more pixels then image width");
                 }

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

@@ -73,22 +73,14 @@ protected override void Decompress(BufferedReadStream stream, int byteCount, int
                     byte repeatData = compressedData[compressedOffset + 1];
                     int repeatLength = 257 - headerByte;
 
-                    ArrayCopyRepeat(repeatData, buffer, decompressedOffset, repeatLength);
+                    buffer.Slice(decompressedOffset, repeatLength).Fill(repeatData);
 
                     compressedOffset += 2;
                     decompressedOffset += repeatLength;
                 }
             }
         }
 
-        private static void ArrayCopyRepeat(byte value, Span<byte> destinationArray, int destinationIndex, int length)
-        {
-            for (int i = 0; i < length; i++)
-            {
-                destinationArray[i + destinationIndex] = value;
-            }
-        }
-
         /// <inheritdoc/>
         protected override void Dispose(bool disposing) => this.compressedDataMemory?.Dispose();
     }