Merge branch 'main' into lvk/metadata-debuggerdisplay

Author: JimBobSquarePants

src/ImageSharp/Formats/DecoderOptions.cs

@@ -55,5 +55,10 @@ public sealed class DecoderOptions
     /// </summary>
     public uint MaxFrames { get => this.maxFrames; init => this.maxFrames = Math.Clamp(value, 1, int.MaxValue); }
 
+    /// <summary>
+    /// Gets the segment error handling strategy to use during decoding.
+    /// </summary>
+    public SegmentIntegrityHandling SegmentIntegrityHandling { get; init; } = SegmentIntegrityHandling.IgnoreNonCritical;
+
     internal void SetConfiguration(Configuration configuration) => this.configuration = configuration;
 }

src/ImageSharp/Formats/Png/PngChunk.cs

@@ -41,13 +41,13 @@ public PngChunk(int length, PngChunkType type, IMemoryOwner<byte> data = null)
     /// <summary>
     /// Gets a value indicating whether the given chunk is critical to decoding
     /// </summary>
-    /// <param name="handling">The chunk CRC handling behavior.</param>
-    public bool IsCritical(PngCrcChunkHandling handling)
+    /// <param name="handling">The segment handling behavior.</param>
+    public bool IsCritical(SegmentIntegrityHandling handling)
         => handling switch
         {
-            PngCrcChunkHandling.IgnoreNone => true,
-            PngCrcChunkHandling.IgnoreNonCritical => this.Type is PngChunkType.Header or PngChunkType.Palette or PngChunkType.Data or PngChunkType.FrameData,
-            PngCrcChunkHandling.IgnoreData => this.Type is PngChunkType.Header or PngChunkType.Palette,
+            SegmentIntegrityHandling.IgnoreNone => true,
+            SegmentIntegrityHandling.IgnoreNonCritical => this.Type is PngChunkType.Header or PngChunkType.Palette or PngChunkType.Data or PngChunkType.FrameData,
+            SegmentIntegrityHandling.IgnoreData => this.Type is PngChunkType.Header or PngChunkType.Palette,
             _ => false,
         };
 }

src/ImageSharp/Formats/Png/PngCrcChunkHandling.cs

@@ -119,7 +119,7 @@ internal sealed class PngDecoderCore : ImageDecoderCore
     /// <summary>
     /// How to handle CRC errors.
     /// </summary>
-    private readonly PngCrcChunkHandling pngCrcChunkHandling;
+    private readonly SegmentIntegrityHandling segmentIntegrityHandling;
 
     /// <summary>
     /// A reusable Crc32 hashing instance.
@@ -142,7 +142,7 @@ public PngDecoderCore(PngDecoderOptions options)
         this.maxFrames = options.GeneralOptions.MaxFrames;
         this.skipMetadata = options.GeneralOptions.SkipMetadata;
         this.memoryAllocator = this.configuration.MemoryAllocator;
-        this.pngCrcChunkHandling = options.PngCrcChunkHandling;
+        this.segmentIntegrityHandling = options.GeneralOptions.SegmentIntegrityHandling;
         this.maxUncompressedLength = options.MaxUncompressedAncillaryChunkSizeBytes;
     }
 
@@ -154,7 +154,7 @@ internal PngDecoderCore(PngDecoderOptions options, bool colorMetadataOnly)
         this.skipMetadata = true;
         this.configuration = options.GeneralOptions.Configuration;
         this.memoryAllocator = this.configuration.MemoryAllocator;
-        this.pngCrcChunkHandling = options.PngCrcChunkHandling;
+        this.segmentIntegrityHandling = options.GeneralOptions.SegmentIntegrityHandling;
         this.maxUncompressedLength = options.MaxUncompressedAncillaryChunkSizeBytes;
     }
 
@@ -833,7 +833,7 @@ private void DecodePixelData<TPixel>(
                     break;
 
                 default:
-                    if (this.pngCrcChunkHandling is PngCrcChunkHandling.IgnoreData or PngCrcChunkHandling.IgnoreAll)
+                    if (this.segmentIntegrityHandling is SegmentIntegrityHandling.IgnoreData or SegmentIntegrityHandling.IgnoreAll)
                     {
                         goto EXIT;
                     }
@@ -939,7 +939,7 @@ private void DecodeInterlacedPixelData<TPixel>(
                         break;
 
                     default:
-                        if (this.pngCrcChunkHandling is PngCrcChunkHandling.IgnoreData or PngCrcChunkHandling.IgnoreAll)
+                        if (this.segmentIntegrityHandling is SegmentIntegrityHandling.IgnoreData or SegmentIntegrityHandling.IgnoreAll)
                         {
                             goto EXIT;
                         }
@@ -1927,7 +1927,7 @@ private bool TryReadChunk(Span<byte> buffer, out PngChunk chunk)
     private void ValidateChunk(in PngChunk chunk, Span<byte> buffer)
     {
         uint inputCrc = this.ReadChunkCrc(buffer);
-        if (chunk.IsCritical(this.pngCrcChunkHandling))
+        if (chunk.IsCritical(this.segmentIntegrityHandling))
         {
             Span<byte> chunkType = stackalloc byte[4];
             BinaryPrimitives.WriteUInt32BigEndian(chunkType, (uint)chunk.Type);

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -11,11 +11,6 @@ public sealed class PngDecoderOptions : ISpecializedDecoderOptions
     /// <inheritdoc/>
     public DecoderOptions GeneralOptions { get; init; } = new DecoderOptions();
 
-    /// <summary>
-    /// Gets a value indicating how to handle validation of any CRC (Cyclic Redundancy Check) data within the encoded PNG.
-    /// </summary>
-    public PngCrcChunkHandling PngCrcChunkHandling { get; init; } = PngCrcChunkHandling.IgnoreNonCritical;
-
     /// <summary>
     /// Gets the maximum memory in bytes that a zTXt, sPLT, iTXt, iCCP, or unknown chunk can occupy when decompressed.
     /// Defaults to 8MB

src/ImageSharp/Formats/Png/PngDecoderOptions.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats;
+
+/// <summary>
+/// Specifies how to handle validation of errors in different segments of encoded image files.
+/// </summary>
+public enum SegmentIntegrityHandling
+{
+    /// <summary>
+    /// Do not ignore any errors.
+    /// </summary>
+    IgnoreNone,
+
+    /// <summary>
+    /// Ignore errors in non-critical segments of the encoded image.
+    /// </summary>
+    IgnoreNonCritical,
+
+    /// <summary>
+    /// Ignore errors in data segments (e.g., image data, metadata).
+    /// </summary>
+    IgnoreData,
+
+    /// <summary>
+    /// Ignore errors in all segments.
+    /// </summary>
+    IgnoreAll
+}

src/ImageSharp/Formats/SegmentIntegrityHandling.cs

@@ -572,7 +572,6 @@ private static void ParseCompression(this TiffDecoderCore options, TiffCompressi
                 }
 
                 options.CompressionType = TiffDecoderCompressionType.OldJpeg;
-
                 if (options.PhotometricInterpretation is TiffPhotometricInterpretation.YCbCr)
                 {
                     // Note: Setting PhotometricInterpretation and color type to RGB here, since the jpeg decoder will handle the conversion of the pixel data.
@@ -585,6 +584,14 @@ private static void ParseCompression(this TiffDecoderCore options, TiffCompressi
             case TiffCompression.Jpeg:
                 options.CompressionType = TiffDecoderCompressionType.Jpeg;
 
+                // Some tiff encoder set this to values different from [1, 1]. The jpeg decoder already handles this,
+                // so we set this always to [1, 1], see: https://github.com/SixLabors/ImageSharp/issues/2679
+                if (options.PhotometricInterpretation is TiffPhotometricInterpretation.YCbCr && options.YcbcrSubSampling != null)
+                {
+                    options.YcbcrSubSampling[0] = 1;
+                    options.YcbcrSubSampling[1] = 1;
+                }
+
                 if (options.PhotometricInterpretation is TiffPhotometricInterpretation.YCbCr && options.JpegTables is null)
                 {
                     // Note: Setting PhotometricInterpretation and color type to RGB here, since the jpeg decoder will handle the conversion of the pixel data.

src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs

@@ -381,6 +381,20 @@ public void Identify(string imagePath, int expectedPixelSize)
         Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
     }
 
+    [Theory]
+    [InlineData(TestImages.Png.Bad.WrongCrcDataChunk, 1)]
+    [InlineData(TestImages.Png.Bad.Issue2589, 24)]
+    public void Identify_IgnoreCrcErrors(string imagePath, int expectedPixelSize)
+    {
+        TestFile testFile = TestFile.Create(imagePath);
+        using MemoryStream stream = new(testFile.Bytes, false);
+
+        ImageInfo imageInfo = Image.Identify(new DecoderOptions() { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData }, stream);
+
+        Assert.NotNull(imageInfo);
+        Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
+    }
+
     [Theory]
     [WithFile(TestImages.Png.Bad.MissingDataChunk, PixelTypes.Rgba32)]
     public void Decode_MissingDataChunk_ThrowsException<TPixel>(TestImageProvider<TPixel> provider)
@@ -479,7 +493,7 @@ public void Decode_InvalidDataChunkCrc_ThrowsException<TPixel>(TestImageProvider
     public void Decode_InvalidDataChunkCrc_IgnoreCrcErrors<TPixel>(TestImageProvider<TPixel> provider, bool compare)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using Image<TPixel> image = provider.GetImage(PngDecoder.Instance, new PngDecoderOptions() { PngCrcChunkHandling = PngCrcChunkHandling.IgnoreData });
+        using Image<TPixel> image = provider.GetImage(PngDecoder.Instance, new DecoderOptions() { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData });
 
         image.DebugSave(provider);
         if (compare)
@@ -660,7 +674,7 @@ static void RunTest(string providerDump, string nonContiguousBuffersStr)
     public void Binary_PrematureEof()
     {
         PngDecoder decoder = PngDecoder.Instance;
-        PngDecoderOptions options = new() { PngCrcChunkHandling = PngCrcChunkHandling.IgnoreData };
+        PngDecoderOptions options = new() { GeneralOptions = new() { SegmentIntegrityHandling = SegmentIntegrityHandling.IgnoreData } };
         using EofHitCounter eofHitCounter = EofHitCounter.RunDecoder(TestImages.Png.Bad.FlagOfGermany0000016446, decoder, options);
 
         // TODO: Try to reduce this to 1.

tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs

@@ -671,6 +671,23 @@ public void TiffDecoder_CanDecode_TiledWithNonEqualWidthAndHeight<TPixel>(TestIm
     public void TiffDecoder_CanDecode_BiColorWithMissingBitsPerSample<TPixel>(TestImageProvider<TPixel> provider)
         where TPixel : unmanaged, IPixel<TPixel> => TestTiffDecoder(provider);
 
+    // https://github.com/SixLabors/ImageSharp/issues/2679
+    [Theory]
+    [WithFile(Issues2679, PixelTypes.Rgba32)]
+    public void TiffDecoder_CanDecode_JpegCompressedWithIssue2679<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(TiffDecoder.Instance);
+
+        // The image is handcrafted to simulate issue 2679. ImageMagick will throw an expection here and wont decode,
+        // so we compare to rererence output instead.
+        image.DebugSave(provider);
+        image.CompareToReferenceOutput(
+            ImageComparer.Exact,
+            provider,
+            appendPixelTypeToFileName: false);
+    }
+
     [Theory]
     [WithFile(JpegCompressedGray0000539558, PixelTypes.Rgba32)]
     public void TiffDecoder_ThrowsException_WithCircular_IFD_Offsets<TPixel>(TestImageProvider<TPixel> provider)

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

@@ -1047,6 +1047,7 @@ public static class Tiff
         public const string Issues2255 = "Tiff/Issues/Issue2255.png";
         public const string Issues2435 = "Tiff/Issues/Issue2435.tiff";
         public const string Issues2587 = "Tiff/Issues/Issue2587.tiff";
+        public const string Issues2679 = "Tiff/Issues/Issue2679.tiff";
         public const string JpegCompressedGray0000539558 = "Tiff/Issues/JpegCompressedGray-0000539558.tiff";
         public const string Tiled0000023664 = "Tiff/Issues/tiled-0000023664.tiff";