Fix transparency mode, update quantized refs

Author: JimBobSquarePants

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -182,7 +182,8 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
             if (clearTransparency)
             {
                 currentFrame = clonedFrame = currentFrame.Clone();
-                ClearTransparentPixels(currentFrame, this.backgroundColor.Value);
+                currentFrameRegion = currentFrame.PixelBuffer.GetRegion();
+                ClearTransparentPixels(in currentFrameRegion, this.backgroundColor.Value);
             }
 
             // Do not move this. We require an accurate bit depth for the header chunk.
@@ -217,7 +218,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
             {
                 cancellationToken.ThrowIfCancellationRequested();
                 FrameControl frameControl = new((uint)this.width, (uint)this.height);
-                this.WriteDataChunks(frameControl, currentFrame.PixelBuffer.GetRegion(), quantized, stream, false);
+                this.WriteDataChunks(in frameControl, in currentFrameRegion, quantized, stream, false);
                 currentFrameIndex++;
             }
 
@@ -286,9 +287,10 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                             background,
                             blend);
 
+                    Buffer2DRegion<TPixel> encodingFrameRegion = encodingFrame.PixelBuffer.GetRegion(bounds);
                     if (clearTransparency)
                     {
-                        ClearTransparentPixels(encodingFrame, background);
+                        ClearTransparentPixels(in encodingFrameRegion, background);
                     }
 
                     // Each frame control sequence number must be incremented by the number of frame data chunks that follow.
@@ -308,7 +310,6 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                         paletteQuantizer,
                         default);
 
-                    Buffer2DRegion<TPixel> encodingFrameRegion = encodingFrame.PixelBuffer.GetRegion(bounds);
                     sequenceNumber += this.WriteDataChunks(frameControl, in encodingFrameRegion, quantized, stream, true) + 1;
 
                     previousFrame = currentFrame;
@@ -392,27 +393,26 @@ private static PngFrameMetadata GetPngFrameMetadata<TPixel>(ImageFrame<TPixel> f
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
     /// <param name="clone">The cloned image frame where the transparent pixels will be changed.</param>
     /// <param name="color">The color to change transparent pixels to.</param>
-    private static void ClearTransparentPixels<TPixel>(ImageFrame<TPixel> clone, Color color)
+    private static void ClearTransparentPixels<TPixel>(in Buffer2DRegion<TPixel> clone, Color color)
         where TPixel : unmanaged, IPixel<TPixel>
-        => clone.ProcessPixelRows(accessor =>
+    {
+        Rgba32 rgba32 = default;
+        Rgba32 transparent = color;
+        for (int y = 0; y < clone.Height; y++)
         {
-            // TODO: We should be able to speed this up with SIMD and masking.
-            Rgba32 rgba32 = default;
-            Rgba32 transparent = color;
-            for (int y = 0; y < accessor.Height; y++)
+            Span<TPixel> row = clone.DangerousGetRowSpan(y);
+            for (int x = 0; x < row.Length; x++)
             {
-                Span<TPixel> span = accessor.GetRowSpan(y);
-                for (int x = 0; x < accessor.Width; x++)
-                {
-                    span[x].ToRgba32(ref rgba32);
+                ref TPixel pixel = ref row[x];
+                pixel.ToRgba32(ref rgba32);
 
-                    if (rgba32.A is 0)
-                    {
-                        span[x].FromRgba32(transparent);
-                    }
+                if (rgba32.A is 0)
+                {
+                    pixel.FromRgba32(transparent);
                 }
             }
-        });
+        }
+    }
 
     /// <summary>
     /// Creates the quantized image and calculates and sets the bit depth.
@@ -1595,7 +1595,7 @@ private void SanitizeAndSetEncoderOptions<TPixel>(
     /// <param name="paletteQuantizer">The quantizer containing any previously derived palette.</param>
     /// <param name="backgroundColor">The background color.</param>
     private IndexedImageFrame<TPixel>? CreateQuantizedFrame<TPixel>(
-        QuantizingImageEncoder encoder,
+        PngEncoder encoder,
         PngColorType colorType,
         byte bitDepth,
         PngMetadata metadata,
@@ -1667,7 +1667,22 @@ private void SanitizeAndSetEncoderOptions<TPixel>(
             frameQuantizer.AddPaletteColors(px.GetRegion());
         }
 
-        frameQuantizer.BuildPalette(encoder.PixelSamplingStrategy, image);
+        if (encoder.TransparentColorMode == PngTransparentColorMode.Clear)
+        {
+            foreach (Buffer2DRegion<TPixel> region in encoder.PixelSamplingStrategy.EnumeratePixelRegions(image))
+            {
+                using Buffer2D<TPixel> clone = region.Buffer.CloneRegion(this.configuration, region.Rectangle);
+                Buffer2DRegion<TPixel> clonedRegion = clone.GetRegion();
+
+                ClearTransparentPixels(in clonedRegion, backgroundColor);
+                frameQuantizer.AddPaletteColors(clonedRegion);
+            }
+        }
+        else
+        {
+            frameQuantizer.BuildPalette(encoder.PixelSamplingStrategy, image);
+        }
+
         return frameQuantizer.QuantizeFrame(frame, bounds);
     }
 

src/ImageSharp/Memory/Buffer2DExtensions.cs

@@ -25,6 +25,39 @@ public static IMemoryGroup<T> GetMemoryGroup<T>(this Buffer2D<T> buffer)
         return buffer.FastMemoryGroup.View;
     }
 
+    /// <summary>
+    /// Performs a deep clone of the buffer covering the specified <paramref name="rectangle"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="source">The source buffer.</param>
+    /// <param name="configuration">The configuration.</param>
+    /// <param name="rectangle">The rectangle to clone.</param>
+    /// <returns>The <see cref="Buffer2D{T}"/>.</returns>
+    internal static Buffer2D<T> CloneRegion<T>(this Buffer2D<T> source, Configuration configuration, Rectangle rectangle)
+        where T : unmanaged
+    {
+        Buffer2D<T> buffer = configuration.MemoryAllocator.Allocate2D<T>(
+            rectangle.Width,
+            rectangle.Height,
+            configuration.PreferContiguousImageBuffers);
+
+        // Optimization for when the size of the area is the same as the buffer size.
+        Buffer2DRegion<T> sourceRegion = source.GetRegion(rectangle);
+        if (sourceRegion.IsFullBufferArea)
+        {
+            sourceRegion.Buffer.FastMemoryGroup.CopyTo(buffer.FastMemoryGroup);
+        }
+        else
+        {
+            for (int y = 0; y < rectangle.Height; y++)
+            {
+                sourceRegion.DangerousGetRowSpan(y).CopyTo(buffer.DangerousGetRowSpan(y));
+            }
+        }
+
+        return buffer;
+    }
+
     /// <summary>
     /// TODO: Does not work with multi-buffer groups, should be specific to Resize.
     /// Copy <paramref name="columnCount"/> columns of <paramref name="buffer"/> inplace,

tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithOctreeQuantizer_rgb32.bmp

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:11375b15df083d98335f4a4baf0717e7fdd6b21ab2132a6815cadc787ac17e7d
+oid sha256:6785d108cab9e3b508e98ce10cef383037471beb2a6d14a69df6069b5fbf5f3d
 size 9270

tests/Images/External/ReferenceOutput/BmpEncoderTests/Encode_8BitColor_WithWuQuantizer_rgb32.bmp

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e063e97cd8a000de6830adcc3961a7dc41785d40cd4d83af10ca38d96e071362
+oid sha256:5d9f2745de2b6e7fc3b1403fe651f3bbba835c67a6fb410fc8a9d91a15b44328
 size 9270