Merge branch 'main' into bp/oldJpegCompression

4 years ago · d8f17acca1
11 changed files with 71 additions and 11 deletions
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@ -90,7 +90,7 @@ jobs:

      - name: DotNet Setup
        if: ${{ matrix.options.sdk-preview != true }}
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
          include-prerelease: true
          dotnet-version: |
@ -98,7 +98,7 @@ jobs:

      - name: DotNet Setup Preview
        if: ${{ matrix.options.sdk-preview == true }}
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
          include-prerelease: true
          dotnet-version: |
--- a/.github/workflows/code-coverage.yml
+++ b/.github/workflows/code-coverage.yml
@ -55,7 +55,7 @@ jobs:
          restore-keys: ${{ runner.os }}-nuget-

      - name: DotNet Setup
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: |
            6.0.x
--- a/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
+++ b/src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
@ -384,6 +384,13 @@ internal sealed class TiffEncoderCore : IImageEncoderInternals
        // If no photometric interpretation was chosen, the input image bit per pixel should be preserved.
        if (!photometricInterpretation.HasValue)
        {
+            if (IsOneBitCompression(this.CompressionType))
+            {
+                // We need to make sure bits per pixel is set to Bit1 now. WhiteIsZero is set because its the default for bilevel compressed data.
+                this.SetEncoderOptions(TiffBitsPerPixel.Bit1, TiffPhotometricInterpretation.WhiteIsZero, compression, TiffPredictor.None);
+                return;
+            }
+
            // At the moment only 8 and 32 bits per pixel can be preserved by the tiff encoder.
            if (inputBitsPerPixel == 8)
            {
--- a/src/ImageSharp/Formats/Webp/AlphaDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/AlphaDecoder.cs
@ -61,7 +61,13 @@ internal class AlphaDecoder : IDisposable
            var bitReader = new Vp8LBitReader(data);
            this.LosslessDecoder = new WebpLosslessDecoder(bitReader, memoryAllocator, configuration);
            this.LosslessDecoder.DecodeImageStream(this.Vp8LDec, width, height, true);
-            this.Use8BDecode = this.Vp8LDec.Transforms.Count > 0 && Is8BOptimizable(this.Vp8LDec.Metadata);
+
+            // Special case: if alpha data uses only the color indexing transform and
+            // doesn't use color cache (a frequent case), we will use DecodeAlphaData()
+            // method that only needs allocation of 1 byte per pixel (alpha channel).
+            this.Use8BDecode = this.Vp8LDec.Transforms.Count is 1
+                               && this.Vp8LDec.Transforms[0].TransformType == Vp8LTransformType.ColorIndexingTransform
+                               && Is8BOptimizable(this.Vp8LDec.Metadata);
        }
    }

--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderBaseTester.cs
@ -80,7 +80,7 @@ public abstract class TiffEncoderBaseTester
    protected static void TestTiffEncoderCore<TPixel>(
        TestImageProvider<TPixel> provider,
        TiffBitsPerPixel? bitsPerPixel,
-        TiffPhotometricInterpretation photometricInterpretation,
+        TiffPhotometricInterpretation? photometricInterpretation,
        TiffCompression compression = TiffCompression.None,
        TiffPredictor predictor = TiffPredictor.None,
        bool useExactComparer = true,
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
@ -427,6 +427,11 @@ public class TiffEncoderTests : TiffEncoderBaseTester
    public void TiffEncoder_EncodeBiColor_WithCcittGroup3FaxCompression_BlackIsZero_Works<TPixel>(TestImageProvider<TPixel> provider)
        where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, TiffBitsPerPixel.Bit1, TiffPhotometricInterpretation.BlackIsZero, TiffCompression.CcittGroup3Fax);

+    [Theory]
+    [WithFile(Issues2255, PixelTypes.Rgba32)]
+    public void TiffEncoder_EncodeBiColor_WithCcittGroup3FaxCompression_WithoutSpecifyingBitPerPixel_Works<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel> => TestTiffEncoderCore(provider, null, null, TiffCompression.CcittGroup3Fax, useExactComparer: false, compareTolerance: 0.025f);
+
    [Theory]
    [WithFile(Calliphora_BiColorUncompressed, PixelTypes.Rgba32)]
    public void TiffEncoder_EncodeBiColor_WithCcittGroup4FaxCompression_WhiteIsZero_Works<TPixel>(TestImageProvider<TPixel> provider)
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs
@ -396,6 +396,17 @@ public class WebpDecoderTests
        image.CompareToOriginal(provider, ReferenceDecoder);
    }

+    // https://github.com/SixLabors/ImageSharp/issues/2257
+    [Theory]
+    [WithFile(Lossy.Issue2257, PixelTypes.Rgba32)]
+    public void WebpDecoder_CanDecode_Issue2257<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> image = provider.GetImage(WebpDecoder);
+        image.DebugSave(provider);
+        image.CompareToOriginal(provider, ReferenceDecoder);
+    }
+
    [Theory]
    [WithFile(Lossless.LossLessCorruptImage3, PixelTypes.Rgba32)]
    public void WebpDecoder_ThrowImageFormatException_OnInvalidImages<TPixel>(TestImageProvider<TPixel> provider)
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
@ -267,28 +267,51 @@ public class WebpEncoderTests
    }

    [Theory]
-    [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, false, 64020)]
-    [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, true, 16200)]
-    public void Encode_Lossy_WithAlpha_Works<TPixel>(TestImageProvider<TPixel> provider, bool compressed, int expectedFileSize)
+    [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, 64020)]
+    public void Encode_Lossy_WithAlpha_Works<TPixel>(TestImageProvider<TPixel> provider, int expectedFileSize)
        where TPixel : unmanaged, IPixel<TPixel>
    {
        var encoder = new WebpEncoder()
        {
            FileFormat = WebpFileFormatType.Lossy,
-            UseAlphaCompression = compressed
+            UseAlphaCompression = false
        };

        using Image<TPixel> image = provider.GetImage();
        string encodedFile = image.VerifyEncoder(
            provider,
            "webp",
-            $"with_alpha_compressed_{compressed}",
+            "with_alpha",
            encoder,
            ImageComparer.Tolerant(0.04f),
            referenceDecoder: new MagickReferenceDecoder());

        int encodedBytes = File.ReadAllBytes(encodedFile).Length;
-        Assert.True(encodedBytes <= expectedFileSize);
+        Assert.True(encodedBytes <= expectedFileSize, $"encoded bytes are {encodedBytes} and should be smaller then expected file size of {expectedFileSize}");
+    }
+
+    [Theory]
+    [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, 16200)]
+    public void Encode_Lossy_WithAlphaUsingCompression_Works<TPixel>(TestImageProvider<TPixel> provider, int expectedFileSize)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        var encoder = new WebpEncoder()
+        {
+            FileFormat = WebpFileFormatType.Lossy,
+            UseAlphaCompression = true
+        };
+
+        using Image<TPixel> image = provider.GetImage();
+        string encodedFile = image.VerifyEncoder(
+            provider,
+            "webp",
+            "with_alpha_compressed",
+            encoder,
+            ImageComparer.Tolerant(0.04f),
+            referenceDecoder: new MagickReferenceDecoder());
+
+        int encodedBytes = File.ReadAllBytes(encodedFile).Length;
+        Assert.True(encodedBytes <= expectedFileSize, $"encoded bytes are {encodedBytes} and should be smaller then expected file size of {expectedFileSize}");
    }

    [Theory]
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@ -737,6 +737,7 @@ public static class TestImages
            // Issues
            public const string Issue1594 = "Webp/issues/Issue1594.webp";
            public const string Issue2243 = "Webp/issues/Issue2243.webp";
+            public const string Issue2257 = "Webp/issues/Issue2257.webp";
        }
    }

@ -939,6 +940,7 @@ public static class TestImages
        public const string Issues1891 = "Tiff/Issues/Issue1891.tiff";
        public const string Issues2123 = "Tiff/Issues/Issue2123.tiff";
        public const string Issues2149 = "Tiff/Issues/Group4CompressionWithStrips.tiff";
+        public const string Issues2255 = "Tiff/Issues/Issue2255.png";

        public const string SmallRgbDeflate = "Tiff/rgb_small_deflate.tiff";
        public const string SmallRgbLzw = "Tiff/rgb_small_lzw.tiff";
--- a/tests/Images/Input/Tiff/Issues/Issue2255.png
+++ b/tests/Images/Input/Tiff/Issues/Issue2255.png
@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff555fb2478406a1f3b2202c2ae3b0a691a16bfe2a5b586f38b348c9f4a858e6
+size 3635
--- a/tests/Images/Input/Webp/issues/Issue2257.webp
+++ b/tests/Images/Input/Webp/issues/Issue2257.webp
@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55f87aee4283615bad9705ac459867facba5b6be114d7e1ece51db7c1ef87916
+size 117810