Add smart animated format conversion.

src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -656,6 +657,36 @@ public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte
             return AdvSimd.BitwiseSelect(signedMask, right.AsInt16(), left.AsInt16()).AsByte();
         }
 
+        /// <summary>
+        /// Blend packed 32-bit unsigned integers from <paramref name="left"/> and <paramref name="right"/> using <paramref name="mask"/>.
+        /// The high bit of each corresponding <paramref name="mask"/> byte determines the selection.
+        /// If the high bit is set the element of <paramref name="left"/> is selected.
+        /// The element of <paramref name="right"/> is selected otherwise.
+        /// </summary>
+        /// <param name="left">The left vector.</param>
+        /// <param name="right">The right vector.</param>
+        /// <param name="mask">The mask vector.</param>
+        /// <returns>The <see cref="Vector256{T}"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<uint> BlendVariable(Vector128<uint> left, Vector128<uint> right, Vector128<uint> mask)
+            => BlendVariable(left.AsByte(), right.AsByte(), mask.AsByte()).AsUInt32();
+
+        /// <summary>
+        /// Count the number of leading zero bits in a mask.
+        /// Similar in behavior to the x86 instruction LZCNT.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public static ushort LeadingZeroCount(ushort value)
+            => (ushort)(BitOperations.LeadingZeroCount(value) - 16);
+
+        /// <summary>
+        /// Count the number of trailing zero bits in an integer value.
+        /// Similar in behavior to the x86 instruction TZCNT.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public static ushort TrailingZeroCount(ushort value)
+            => (ushort)(BitOperations.TrailingZeroCount(value << 16) - 16);
+
         /// <summary>
         /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
         /// </summary>

src/ImageSharp/Formats/AnimationUtilities.cs

@@ -25,26 +25,31 @@ internal static class AnimationUtilities
     /// <param name="configuration">The configuration.</param>
     /// <param name="previousFrame">The previous frame if present.</param>
     /// <param name="currentFrame">The current frame.</param>
+    /// <param name="nextFrame">The next frame if present.</param>
     /// <param name="resultFrame">The resultant output.</param>
     /// <param name="replacement">The value to use when replacing duplicate pixels.</param>
+    /// <param name="blend">Whether the resultant frame represents an animation blend.</param>
     /// <param name="clampingMode">The clamping bound to apply when calculating difference bounds.</param>
     /// <returns>The <see cref="ValueTuple{Boolean, Rectangle}"/> representing the operation result.</returns>
     public static (bool Difference, Rectangle Bounds) DeDuplicatePixels<TPixel>(
         Configuration configuration,
         ImageFrame<TPixel>? previousFrame,
         ImageFrame<TPixel> currentFrame,
+        ImageFrame<TPixel>? nextFrame,
         ImageFrame<TPixel> resultFrame,
-        Vector4 replacement,
+        Color replacement,
+        bool blend,
         ClampingMode clampingMode = ClampingMode.None)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // TODO: This would be faster (but more complicated to find diff bounds) if we operated on Rgba32.
-        // If someone wants to do that, they have my unlimited thanks.
         MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
-        IMemoryOwner<Vector4> buffers = memoryAllocator.Allocate<Vector4>(currentFrame.Width * 3, AllocationOptions.Clean);
-        Span<Vector4> previous = buffers.GetSpan()[..currentFrame.Width];
-        Span<Vector4> current = buffers.GetSpan().Slice(currentFrame.Width, currentFrame.Width);
-        Span<Vector4> result = buffers.GetSpan()[(currentFrame.Width * 2)..];
+        using IMemoryOwner<Rgba32> buffers = memoryAllocator.Allocate<Rgba32>(currentFrame.Width * 4, AllocationOptions.Clean);
+        Span<Rgba32> previous = buffers.GetSpan()[..currentFrame.Width];
+        Span<Rgba32> current = buffers.GetSpan().Slice(currentFrame.Width, currentFrame.Width);
+        Span<Rgba32> next = buffers.GetSpan().Slice(currentFrame.Width * 2, currentFrame.Width);
+        Span<Rgba32> result = buffers.GetSpan()[(currentFrame.Width * 3)..];
+
+        Rgba32 bg = replacement;
 
         int top = int.MinValue;
         int bottom = int.MaxValue;
@@ -56,83 +61,145 @@ internal static class AnimationUtilities
         {
             if (previousFrame != null)
             {
-                PixelOperations<TPixel>.Instance.ToVector4(configuration, previousFrame.DangerousGetPixelRowMemory(y).Span, previous, PixelConversionModifiers.Scale);
+                PixelOperations<TPixel>.Instance.ToRgba32(configuration, previousFrame.DangerousGetPixelRowMemory(y).Span, previous);
             }
 
-            PixelOperations<TPixel>.Instance.ToVector4(configuration, currentFrame.DangerousGetPixelRowMemory(y).Span, current, PixelConversionModifiers.Scale);
-
-            ref Vector256<float> previousBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(previous));
-            ref Vector256<float> currentBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(current));
-            ref Vector256<float> resultBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
+            PixelOperations<TPixel>.Instance.ToRgba32(configuration, currentFrame.DangerousGetPixelRowMemory(y).Span, current);
 
-            Vector256<float> replacement256 = Vector256.Create(replacement.X, replacement.Y, replacement.Z, replacement.W, replacement.X, replacement.Y, replacement.Z, replacement.W);
+            if (nextFrame != null)
+            {
+                PixelOperations<TPixel>.Instance.ToRgba32(configuration, nextFrame.DangerousGetPixelRowMemory(y).Span, next);
+            }
 
-            int size = Unsafe.SizeOf<Vector4>();
+            ref Vector256<byte> previousBase256 = ref Unsafe.As<Rgba32, Vector256<byte>>(ref MemoryMarshal.GetReference(previous));
+            ref Vector256<byte> currentBase256 = ref Unsafe.As<Rgba32, Vector256<byte>>(ref MemoryMarshal.GetReference(current));
+            ref Vector256<byte> nextBase256 = ref Unsafe.As<Rgba32, Vector256<byte>>(ref MemoryMarshal.GetReference(next));
+            ref Vector256<byte> resultBase256 = ref Unsafe.As<Rgba32, Vector256<byte>>(ref MemoryMarshal.GetReference(result));
 
-            bool hasRowDiff = false;
             int i = 0;
             uint x = 0;
+            bool hasRowDiff = false;
             int length = current.Length;
             int remaining = current.Length;
-            if (Avx2.IsSupported && remaining >= 2)
+
+            if (Avx2.IsSupported && remaining >= 8)
             {
-                while (remaining >= 2)
+                Vector256<uint> r256 = previousFrame != null ? Vector256.Create(bg.PackedValue) : Vector256<uint>.Zero;
+                Vector256<uint> vmb256 = Vector256<uint>.Zero;
+                if (blend)
                 {
-                    Vector256<float> p = Unsafe.Add(ref previousBase, x);
-                    Vector256<float> c = Unsafe.Add(ref currentBase, x);
+                    vmb256 = Avx2.CompareEqual(vmb256, vmb256);
+                }
+
+                while (remaining >= 8)
+                {
+                    Vector256<uint> p = Unsafe.Add(ref previousBase256, x).AsUInt32();
+                    Vector256<uint> c = Unsafe.Add(ref currentBase256, x).AsUInt32();
 
-                    // Compare the previous and current pixels
-                    Vector256<int> mask = Avx2.CompareEqual(p.AsInt32(), c.AsInt32());
-                    mask = Avx2.CompareEqual(mask.AsInt64(), Vector256<long>.AllBitsSet).AsInt32();
-                    mask = Avx2.And(mask, Avx2.Shuffle(mask, 0b_01_00_11_10)).AsInt32();
+                    Vector256<uint> eq = Avx2.CompareEqual(p, c);
+                    Vector256<uint> r = Avx2.BlendVariable(c, r256, Avx2.And(eq, vmb256));
 
-                    Vector256<int> neq = Avx2.Xor(mask.AsInt64(), Vector256<long>.AllBitsSet).AsInt32();
-                    int m = Avx2.MoveMask(neq.AsByte());
-                    if (m != 0)
+                    if (nextFrame != null)
+                    {
+                        Vector256<int> n = Avx2.ShiftRightLogical(Unsafe.Add(ref nextBase256, x).AsUInt32(), 24).AsInt32();
+                        eq = Avx2.AndNot(Avx2.CompareGreaterThan(Avx2.ShiftRightLogical(c, 24).AsInt32(), n).AsUInt32(), eq);
+                    }
+
+                    Unsafe.Add(ref resultBase256, x) = r.AsByte();
+
+                    uint msk = (uint)Avx2.MoveMask(eq.AsByte());
+                    msk = ~msk;
+
+                    if (msk != 0)
                     {
                         // If is diff is found, the left side is marked by the min of previously found left side and the start position.
                         // The right is the max of the previously found right side and the end position.
-                        int start = i + (BitOperations.TrailingZeroCount(m) / size);
-                        int end = i + (2 - (BitOperations.LeadingZeroCount((uint)m) / size));
+                        int start = i + (BitOperations.TrailingZeroCount(msk) / sizeof(uint));
+                        int end = i + (8 - (BitOperations.LeadingZeroCount(msk) / sizeof(uint)));
                         left = Math.Min(left, start);
                         right = Math.Max(right, end);
                         hasRowDiff = true;
                         hasDiff = true;
                     }
 
-                    // Replace the pixel value with the replacement if the full pixel is matched.
-                    Vector256<float> r = Avx.BlendVariable(c, replacement256, mask.AsSingle());
-                    Unsafe.Add(ref resultBase, x) = r;
+                    x++;
+                    i += 8;
+                    remaining -= 8;
+                }
+            }
+
+            if (Sse2.IsSupported && remaining >= 4)
+            {
+                // Update offset since we may be operating on the remainder previously incremented by pixel steps of 8.
+                x *= 2;
+                Vector128<uint> r128 = previousFrame != null ? Vector128.Create(bg.PackedValue) : Vector128<uint>.Zero;
+                Vector128<uint> vmb128 = Vector128<uint>.Zero;
+                if (blend)
+                {
+                    vmb128 = Sse2.CompareEqual(vmb128, vmb128);
+                }
+
+                while (remaining >= 4)
+                {
+                    Vector128<uint> p = Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref previousBase256), x);
+                    Vector128<uint> c = Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref currentBase256), x);
+
+                    Vector128<uint> eq = Sse2.CompareEqual(p, c);
+                    Vector128<uint> r = SimdUtils.HwIntrinsics.BlendVariable(c, r128, Sse2.And(eq, vmb128));
+
+                    if (nextFrame != null)
+                    {
+                        Vector128<int> n = Sse2.ShiftRightLogical(Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref nextBase256), x), 24).AsInt32();
+                        eq = Sse2.AndNot(Sse2.CompareGreaterThan(Sse2.ShiftRightLogical(c, 24).AsInt32(), n).AsUInt32(), eq);
+                    }
+
+                    Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref resultBase256), x) = r;
+
+                    ushort msk = (ushort)(uint)Sse2.MoveMask(eq.AsByte());
+                    msk = (ushort)~msk;
+                    if (msk != 0)
+                    {
+                        // If is diff is found, the left side is marked by the min of previously found left side and the start position.
+                        // The right is the max of the previously found right side and the end position.
+                        int start = i + (SimdUtils.HwIntrinsics.TrailingZeroCount(msk) / sizeof(uint));
+                        int end = i + (4 - (SimdUtils.HwIntrinsics.LeadingZeroCount(msk) / sizeof(uint)));
+                        left = Math.Min(left, start);
+                        right = Math.Max(right, end);
+                        hasRowDiff = true;
+                        hasDiff = true;
+                    }
 
                     x++;
-                    i += 2;
-                    remaining -= 2;
+                    i += 4;
+                    remaining -= 4;
                 }
             }
 
+            // TODO: v4 AdvSimd when we can use .NET 8
             for (i = remaining; i > 0; i--)
             {
                 x = (uint)(length - i);
 
-                Vector4 p = Unsafe.Add(ref Unsafe.As<Vector256<float>, Vector4>(ref previousBase), x);
-                Vector4 c = Unsafe.Add(ref Unsafe.As<Vector256<float>, Vector4>(ref currentBase), x);
-                ref Vector4 r = ref Unsafe.Add(ref Unsafe.As<Vector256<float>, Vector4>(ref resultBase), x);
+                Rgba32 p = Unsafe.Add(ref MemoryMarshal.GetReference(previous), x);
+                Rgba32 c = Unsafe.Add(ref MemoryMarshal.GetReference(current), x);
+                Rgba32 n = Unsafe.Add(ref MemoryMarshal.GetReference(next), x);
+                ref Rgba32 r = ref Unsafe.Add(ref MemoryMarshal.GetReference(result), x);
 
-                if (p != c)
-                {
-                    r = c;
+                bool peq = c.Rgba == (previousFrame != null ? p.Rgba : bg.Rgba);
+                Rgba32 val = (blend & peq) ? replacement : c;
+
+                peq &= nextFrame == null || (n.Rgba >> 24 >= c.Rgba >> 24);
+                r = val;
 
+                if (!peq)
+                {
                     // If is diff is found, the left side is marked by the min of previously found left side and the diff position.
                     // The right is the max of the previously found right side and the diff position + 1.
                     left = Math.Min(left, (int)x);
                     right = Math.Max(right, (int)x + 1);
                     hasRowDiff = true;
                     hasDiff = true;
                 }
-                else
-                {
-                    r = replacement;
-                }
             }
 
             if (hasRowDiff)
@@ -145,7 +212,7 @@ internal static class AnimationUtilities
                 bottom = y + 1;
             }
 
-            PixelOperations<TPixel>.Instance.FromVector4Destructive(configuration, result, resultFrame.DangerousGetPixelRowMemory(y).Span, PixelConversionModifiers.Scale);
+            PixelOperations<TPixel>.Instance.FromRgba32(configuration, result, resultFrame.DangerousGetPixelRowMemory(y).Span);
         }
 
         Rectangle bounds = Rectangle.FromLTRB(
@@ -163,20 +230,7 @@ internal static class AnimationUtilities
             bounds.Y = Math.Max(0, bounds.Y - (bounds.Y & 1));
         }
 
-        return new(hasDiff, bounds);
-    }
-
-    public static void CopySource<TPixel>(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Rectangle bounds)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        Buffer2DRegion<TPixel> sourceBuffer = source.PixelBuffer.GetRegion(bounds);
-        Buffer2DRegion<TPixel> destBuffer = destination.PixelBuffer.GetRegion(bounds);
-        for (int y = 0; y < destBuffer.Height; y++)
-        {
-            Span<TPixel> sourceRow = sourceBuffer.DangerousGetRowSpan(y);
-            Span<TPixel> destRow = destBuffer.DangerousGetRowSpan(y);
-            sourceRow.CopyTo(destRow);
-        }
+        return (hasDiff, bounds);
     }
 }
 

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -168,15 +168,15 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         stream.WriteByte(GifConstants.EndIntroducer);
 
-        quantized.Dispose();
+        quantized?.Dispose();
     }
 
     private static GifMetadata GetGifMetadata<TPixel>(Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         if (image.Metadata.TryGetGifMetadata(out GifMetadata? gif))
         {
-            return gif;
+            return (GifMetadata)gif.DeepClone();
         }
 
         if (image.Metadata.TryGetPngMetadata(out PngMetadata? png))
@@ -251,6 +251,7 @@ private static GifFrameMetadata GetGifFrameMetadata<TPixel>(ImageFrame<TPixel> f
         {
             // Gather the metadata for this frame.
             ImageFrame<TPixel> currentFrame = image.Frames[i];
+            ImageFrame<TPixel>? nextFrame = i < image.Frames.Count - 1 ? image.Frames[i + 1] : null;
             GifFrameMetadata gifMetadata = GetGifFrameMetadata(currentFrame, globalTransparencyIndex);
             bool useLocal = this.colorTableMode == GifColorTableMode.Local || (gifMetadata.ColorTableMode == GifColorTableMode.Local);
 
@@ -268,6 +269,7 @@ private static GifFrameMetadata GetGifFrameMetadata<TPixel>(ImageFrame<TPixel> f
                 stream,
                 previousFrame,
                 currentFrame,
+                nextFrame,
                 encodingFrame,
                 useLocal,
                 gifMetadata,
@@ -311,6 +313,7 @@ private static GifFrameMetadata GetGifFrameMetadata<TPixel>(ImageFrame<TPixel> f
         Stream stream,
         ImageFrame<TPixel> previousFrame,
         ImageFrame<TPixel> currentFrame,
+        ImageFrame<TPixel>? nextFrame,
         ImageFrame<TPixel> encodingFrame,
         bool useLocal,
         GifFrameMetadata metadata,
@@ -325,7 +328,15 @@ private static GifFrameMetadata GetGifFrameMetadata<TPixel>(ImageFrame<TPixel> f
         ImageFrame<TPixel>? previous = previousDisposal == GifDisposalMethod.RestoreToBackground ? null : previousFrame;
 
         // Deduplicate and quantize the frame capturing only required parts.
-        (bool difference, Rectangle bounds) = AnimationUtilities.DeDuplicatePixels(this.configuration, previous, currentFrame, encodingFrame, Vector4.Zero);
+        (bool difference, Rectangle bounds) =
+            AnimationUtilities.DeDuplicatePixels(
+                this.configuration,
+                previous,
+                currentFrame,
+                nextFrame,
+                encodingFrame,
+                Color.Transparent,
+                true);
 
         using IndexedImageFrame<TPixel> quantized = this.QuantizeAdditionalFrameAndUpdateMetadata(
                 encodingFrame,