Clarify some DebugGuard messages and a little cleanup

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

@@ -19,12 +19,15 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
             : base(output, allocator, width, bitsPerPixel, predictor)
             => this.compressionLevel = compressionLevel;
 
+        /// <inheritdoc/>
         public override TiffEncoderCompression Method => TiffEncoderCompression.Deflate;
 
+        /// <inheritdoc/>
         public override void Initialize(int rowsPerStrip)
         {
         }
 
+        /// <inheritdoc/>
         public override void CompressStrip(Span<byte> rows, int height)
         {
             this.memoryStream.Seek(0, SeekOrigin.Begin);
@@ -52,6 +55,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
 #endif
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
         }

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

@@ -17,10 +17,13 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
         {
         }
 
+        /// <inheritdoc/>
         public override TiffEncoderCompression Method => TiffEncoderCompression.Lzw;
 
+        /// <inheritdoc/>
         public override void Initialize(int rowsPerStrip) => this.lzwEncoder = new TiffLzwEncoder(this.Allocator);
 
+        /// <inheritdoc/>
         public override void CompressStrip(Span<byte> rows, int height)
         {
             if (this.Predictor == TiffPredictor.Horizontal)
@@ -31,6 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
             this.lzwEncoder.Encode(rows, this.Output);
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing) => this.lzwEncoder?.Dispose();
     }
 }

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

@@ -13,14 +13,18 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
         {
         }
 
+        /// <inheritdoc/>
         public override TiffEncoderCompression Method => TiffEncoderCompression.None;
 
+        /// <inheritdoc/>
         public override void Initialize(int rowsPerStrip)
         {
         }
 
+        /// <inheritdoc/>
         public override void CompressStrip(Span<byte> rows, int height) => this.Output.Write(rows);
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
         }

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

@@ -16,14 +16,17 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
         {
         }
 
+        /// <inheritdoc/>
         public override TiffEncoderCompression Method => TiffEncoderCompression.PackBits;
 
+        /// <inheritdoc/>
         public override void Initialize(int rowsPerStrip)
         {
             int additionalBytes = ((this.BytesPerRow + 126) / 127) + 1;
             this.pixelData = this.Allocator.AllocateManagedByteBuffer(this.BytesPerRow + additionalBytes);
         }
 
+        /// <inheritdoc/>
         public override void CompressStrip(Span<byte> rows, int height)
         {
             DebugGuard.IsTrue(rows.Length % height == 0, "Invalid height");
@@ -38,6 +41,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors
             }
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing) => this.pixelData?.Dispose();
     }
 }

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

@@ -54,6 +54,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Decompresso
             }
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
         }

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

@@ -38,6 +38,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Decompresso
             }
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
         }

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

@@ -23,6 +23,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Decompresso
         /// <inheritdoc/>
         protected override void Decompress(BufferedReadStream stream, int byteCount, 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

@@ -88,6 +88,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Decompresso
             }
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing) => this.compressedDataMemory?.Dispose();
     }
 }

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

@@ -81,6 +81,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Decompresso
             }
         }
 
+        /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
         }

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

@@ -17,20 +17,35 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression
             this.Width = width;
             this.BitsPerPixel = bitsPerPixel;
             this.Predictor = predictor;
-
             this.BytesPerRow = ((width * bitsPerPixel) + 7) / 8;
         }
 
+        /// <summary>
+        /// Gets the image width.
+        /// </summary>
         public int Width { get; }
 
+        /// <summary>
+        /// Gets the bits per pixel.
+        /// </summary>
         public int BitsPerPixel { get; }
 
+        /// <summary>
+        /// Gets the bytes per row.
+        /// </summary>
         public int BytesPerRow { get; }
 
+        /// <summary>
+        /// Gets the predictor to use. Should only be used with deflate or lzw compression.
+        /// </summary>
         public TiffPredictor Predictor { get; }
 
+        /// <summary>
+        /// Gets the memory allocator.
+        /// </summary>
         protected MemoryAllocator Allocator { get; }
 
+        /// <inheritdoc />
         public void Dispose()
         {
             if (this.isDisposed)

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

@@ -10,16 +10,39 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression
 {
     internal abstract class TiffBaseCompressor : TiffBaseCompression
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TiffBaseCompressor"/> class.
+        /// </summary>
+        /// <param name="output">The output stream to write the compressed image to.</param>
+        /// <param name="allocator">The memory allocator.</param>
+        /// <param name="width">The image width.</param>
+        /// <param name="bitsPerPixel">Bits per pixel.</param>
+        /// <param name="predictor">The predictor to use (should only be used with deflate or lzw compression). Defaults to none.</param>
         protected TiffBaseCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor = TiffPredictor.None)
             : base(allocator, width, bitsPerPixel, predictor)
             => this.Output = output;
 
+        /// <summary>
+        /// Gets the compression method to use.
+        /// </summary>
         public abstract TiffEncoderCompression Method { get; }
 
+        /// <summary>
+        /// Gets the output stream to write the compressed image to.
+        /// </summary>
         public Stream Output { get; }
 
+        /// <summary>
+        /// Does any initialization required for the compression.
+        /// </summary>
+        /// <param name="rowsPerStrip">The number of rows per strip.</param>
         public abstract void Initialize(int rowsPerStrip);
 
+        /// <summary>
+        /// Compresses a strip of the image.
+        /// </summary>
+        /// <param name="rows">Image rows to compress.</param>
+        /// <param name="height">Image height.</param>
         public abstract void CompressStrip(Span<byte> rows, int height);
     }
 }

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

@@ -1,11 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Buffers;
 using System.IO;
 using SixLabors.ImageSharp.Compression.Zlib;
-using SixLabors.ImageSharp.Formats.Experimental.Tiff;
 using SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression.Compressors;
 using SixLabors.ImageSharp.Formats.Experimental.Tiff.Constants;
 using SixLabors.ImageSharp.Memory;
@@ -26,31 +23,31 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression
             switch (method)
             {
                 case TiffEncoderCompression.None:
-                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "Values must be equals");
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
 
                     return new NoCompressor(output);
 
                 case TiffEncoderCompression.PackBits:
-                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "Values must be equals");
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
                     return new PackBitsCompressor(output, allocator, width, bitsPerPixel);
 
                 case TiffEncoderCompression.Deflate:
                     return new DeflateCompressor(output, allocator, width, bitsPerPixel, predictor, compressionLevel);
 
                 case TiffEncoderCompression.Lzw:
-                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "Values must be equals");
+                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set");
                     return new LzwCompressor(output, allocator, width, bitsPerPixel, predictor);
 
                 case TiffEncoderCompression.CcittGroup3Fax:
-                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "Values must be equals");
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
                     return new T4BitCompressor(output, allocator, width, bitsPerPixel, false);
 
                 case TiffEncoderCompression.ModifiedHuffman:
-                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "Values must be equals");
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
                     return new T4BitCompressor(output, allocator, width, bitsPerPixel, true);
 
                 default:

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

@@ -21,29 +21,29 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression
             switch (method)
             {
                 case TiffDecoderCompressionType.None:
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
-                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "Values must be equals");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
+                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
                     return new NoneTiffCompression();
 
                 case TiffDecoderCompressionType.PackBits:
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
-                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "Values must be equals");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
+                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
                     return new PackBitsTiffCompression(allocator);
 
                 case TiffDecoderCompressionType.Deflate:
-                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "Values must be equals");
+                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
                     return new DeflateTiffCompression(allocator, width, bitsPerPixel, predictor);
 
                 case TiffDecoderCompressionType.Lzw:
-                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "Values must be equals");
+                    DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected");
                     return new LzwTiffCompression(allocator, width, bitsPerPixel, predictor);
 
                 case TiffDecoderCompressionType.T4:
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
                     return new T4TiffCompression(allocator, faxOptions, photometricInterpretation, width);
 
                 case TiffDecoderCompressionType.HuffmanRle:
-                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Values must be equals");
+                    DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression");
                     return new ModifiedHuffmanTiffCompression(allocator, photometricInterpretation, width);
 
                 default:

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -12,7 +12,6 @@ using SixLabors.ImageSharp.Formats.Experimental.Tiff.Compression;
 using SixLabors.ImageSharp.Formats.Experimental.Tiff.Constants;
 using SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers;
 using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
@@ -58,6 +57,9 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
         /// </summary>
         private readonly DeflateCompressionLevel compressionLevel;
 
+        /// <summary>
+        /// The maximum number of bytes for a strip.
+        /// </summary>
         private readonly int maxStripBytes;
 
         /// <summary>
@@ -252,7 +254,8 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
                     this.bitsPerPixel = TiffBitsPerPixel.Pixel1;
                     return;
                 }
-                else if (this.Mode != TiffEncodingMode.BiColor)
+
+                if (this.Mode != TiffEncodingMode.BiColor)
                 {
                     TiffThrowHelper.ThrowImageFormatException($"The {this.CompressionType} compression and {this.Mode} aren't compatible. Please use {this.CompressionType} only with {TiffEncodingMode.BiColor} or {TiffEncodingMode.Default} mode.");
                 }

src/ImageSharp/Formats/Tiff/Writers/TiffBaseColorWriter.cs

@@ -63,6 +63,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
             this.AddStripTags(rowsPerStrip, stripOffsets, stripByteCounts);
         }
 
+        /// <inheritdoc/>
         public void Dispose()
         {
             if (this.isDisposed)

src/ImageSharp/Formats/Tiff/Writers/TiffBiColorWriter.cs

@@ -49,7 +49,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
 
             if (compressor.Method == TiffEncoderCompression.CcittGroup3Fax || compressor.Method == TiffEncoderCompression.ModifiedHuffman)
             {
-                // special case for T4BitCompressor
+                // Special case for T4BitCompressor.
                 compressor.CompressStrip(pixelAsGraySpan, height);
             }
             else
@@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
                 Span<byte> rows = this.bitStrip.Slice(0, bytesPerStrip);
                 rows.Clear();
 
-                int xx = 0;
+                int grayPixelIndex = 0;
                 for (int s = 0; s < height; s++)
                 {
                     int bitIndex = 0;
@@ -72,7 +72,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
                     for (int x = 0; x < this.Image.Width; x++)
                     {
                         int shift = 7 - bitIndex;
-                        if (pixelAsGraySpan[xx++] == 255)
+                        if (pixelAsGraySpan[grayPixelIndex++] == 255)
                         {
                             outputRow[byteIndex] |= (byte)(1 << shift);
                         }

src/ImageSharp/Formats/Tiff/Writers/TiffCompositeColorWriter.cs

@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
     {
         private IManagedByteBuffer rowBuffer;
 
-        public TiffCompositeColorWriter(ImageFrame<TPixel> image, MemoryAllocator memoryAllocator, Configuration configuration, TiffEncoderEntriesCollector entriesCollector)
+        protected TiffCompositeColorWriter(ImageFrame<TPixel> image, MemoryAllocator memoryAllocator, Configuration configuration, TiffEncoderEntriesCollector entriesCollector)
             : base(image, memoryAllocator, configuration, entriesCollector)
         {
         }
@@ -40,6 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
 
         protected abstract void EncodePixels(Span<TPixel> pixels, Span<byte> buffer);
 
+        /// <inheritdoc />
         protected override void Dispose(bool disposing) => this.rowBuffer?.Dispose();
     }
 }

src/ImageSharp/Formats/Tiff/Writers/TiffGrayWriter.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -16,8 +15,10 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
         {
         }
 
+        /// <inheritdoc />
         public override int BitsPerPixel => 8;
 
+        /// <inheritdoc />
         protected override void EncodePixels(Span<TPixel> pixels, Span<byte> buffer) => PixelOperations<TPixel>.Instance.ToL8Bytes(this.Configuration, pixels, buffer, pixels.Length);
     }
 }

src/ImageSharp/Formats/Tiff/Writers/TiffPaletteWriter.cs

@@ -31,14 +31,17 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
             this.AddTag(this.quantized);
         }
 
+        /// <inheritdoc />
         public override int BitsPerPixel => 8;
 
+        /// <inheritdoc />
         protected override void EncodeStrip(int y, int height, TiffBaseCompressor compressor)
         {
             Span<byte> pixels = GetStripPixels(((IPixelSource)this.quantized).PixelBuffer, y, height);
             compressor.CompressStrip(pixels, height);
         }
 
+        /// <inheritdoc />
         protected override void Dispose(bool disposing) => this.quantized?.Dispose();
 
         private void AddTag(IndexedImageFrame<TPixel> quantized)

src/ImageSharp/Formats/Tiff/Writers/TiffRgbWriter.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.IO;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -16,8 +15,10 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Writers
         {
         }
 
+        /// <inheritdoc />
         public override int BitsPerPixel => 24;
 
+        /// <inheritdoc />
         protected override void EncodePixels(Span<TPixel> pixels, Span<byte> buffer) => PixelOperations<TPixel>.Instance.ToRgb24Bytes(this.Configuration, pixels, buffer, pixels.Length);
     }
 }