Preserve Gif color palettes and deduplicate frame pixels.

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

@@ -629,6 +629,33 @@ public static Vector256<float> MultiplyAddNegated(
             return Avx.Subtract(c, Avx.Multiply(a, b));
         }
 
+        /// <summary>
+        /// Blend packed 8-bit 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<byte> BlendVariable(in Vector128<byte> left, in Vector128<byte> right, in Vector128<byte> mask)
+        {
+            if (Sse41.IsSupported)
+            {
+                return Sse41.BlendVariable(left, right, mask);
+            }
+            else if (Sse2.IsSupported)
+            {
+                return Sse2.Or(Sse2.And(right, mask), Sse2.AndNot(mask, left));
+            }
+
+            // Use a signed shift right to create a mask with the sign bit.
+            Vector128<short> signedMask = AdvSimd.ShiftRightArithmetic(mask.AsInt16(), 7);
+            return AdvSimd.BitwiseSelect(signedMask, right.AsInt16(), left.AsInt16()).AsByte();
+        }
+
         /// <summary>
         /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
         /// </summary>

src/ImageSharp/Formats/Bmp/BmpEncoder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Processing;
 
 namespace SixLabors.ImageSharp.Formats.Bmp;
 
@@ -10,6 +11,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp;
 /// </summary>
 public sealed class BmpEncoder : QuantizingImageEncoder
 {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BmpEncoder"/> class.
+    /// </summary>
+    public BmpEncoder() => this.Quantizer = KnownQuantizers.Octree;
+
     /// <summary>
     /// Gets the number of bits per pixel.
     /// </summary>

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -9,6 +9,7 @@
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Formats.Bmp;
@@ -100,7 +101,7 @@ public BmpEncoderCore(BmpEncoder encoder, MemoryAllocator memoryAllocator)
     {
         this.memoryAllocator = memoryAllocator;
         this.bitsPerPixel = encoder.BitsPerPixel;
-        this.quantizer = encoder.Quantizer;
+        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Octree;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.infoHeaderType = encoder.SupportTransparency ? BmpInfoHeaderType.WinVersion4 : BmpInfoHeaderType.WinVersion3;
     }

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -29,6 +29,16 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
     /// </summary>
     private IMemoryOwner<byte>? globalColorTable;
 
+    /// <summary>
+    /// The current local color table.
+    /// </summary>
+    private IMemoryOwner<byte>? currentLocalColorTable;
+
+    /// <summary>
+    /// Gets the size in bytes of the current local color table.
+    /// </summary>
+    private int currentLocalColorTableSize;
+
     /// <summary>
     /// The area to restore.
     /// </summary>
@@ -159,6 +169,7 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
         finally
         {
             this.globalColorTable?.Dispose();
+            this.currentLocalColorTable?.Dispose();
         }
 
         if (image is null)
@@ -229,6 +240,7 @@ public ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellat
         finally
         {
             this.globalColorTable?.Dispose();
+            this.currentLocalColorTable?.Dispose();
         }
 
         if (this.logicalScreenDescriptor.Width == 0 && this.logicalScreenDescriptor.Height == 0)
@@ -332,7 +344,7 @@ private void ReadApplicationExtension(BufferedReadStream stream)
             if (subBlockSize == GifConstants.NetscapeLoopingSubBlockSize)
             {
                 stream.Read(this.buffer.Span, 0, GifConstants.NetscapeLoopingSubBlockSize);
-                this.gifMetadata!.RepeatCount = GifNetscapeLoopingApplicationExtension.Parse(this.buffer.Span.Slice(1)).RepeatCount;
+                this.gifMetadata!.RepeatCount = GifNetscapeLoopingApplicationExtension.Parse(this.buffer.Span[1..]).RepeatCount;
                 stream.Skip(1); // Skip the terminator.
                 return;
             }
@@ -415,25 +427,27 @@ private void ReadFrame<TPixel>(BufferedReadStream stream, ref Image<TPixel>? ima
     {
         this.ReadImageDescriptor(stream);
 
-        IMemoryOwner<byte>? localColorTable = null;
         Buffer2D<byte>? indices = null;
         try
         {
             // Determine the color table for this frame. If there is a local one, use it otherwise use the global color table.
-            if (this.imageDescriptor.LocalColorTableFlag)
+            bool hasLocalColorTable = this.imageDescriptor.LocalColorTableFlag;
+
+            if (hasLocalColorTable)
             {
-                int length = this.imageDescriptor.LocalColorTableSize * 3;
-                localColorTable = this.configuration.MemoryAllocator.Allocate<byte>(length, AllocationOptions.Clean);
-                stream.Read(localColorTable.GetSpan());
+                // Read and store the local color table. We allocate the maximum possible size and slice to match.
+                int length = this.currentLocalColorTableSize = this.imageDescriptor.LocalColorTableSize * 3;
+                this.currentLocalColorTable ??= this.configuration.MemoryAllocator.Allocate<byte>(768, AllocationOptions.Clean);
+                stream.Read(this.currentLocalColorTable.GetSpan()[..length]);
             }
 
             indices = this.configuration.MemoryAllocator.Allocate2D<byte>(this.imageDescriptor.Width, this.imageDescriptor.Height, AllocationOptions.Clean);
             this.ReadFrameIndices(stream, indices);
 
             Span<byte> rawColorTable = default;
-            if (localColorTable != null)
+            if (hasLocalColorTable)
             {
-                rawColorTable = localColorTable.GetSpan();
+                rawColorTable = this.currentLocalColorTable!.GetSpan()[..this.currentLocalColorTableSize];
             }
             else if (this.globalColorTable != null)
             {
@@ -448,7 +462,6 @@ private void ReadFrame<TPixel>(BufferedReadStream stream, ref Image<TPixel>? ima
         }
         finally
         {
-            localColorTable?.Dispose();
             indices?.Dispose();
         }
     }
@@ -509,7 +522,10 @@ private void ReadFrameColors<TPixel>(ref Image<TPixel>? image, ref ImageFrame<TP
                 prevFrame = previousFrame;
             }
 
-            currentFrame = image!.Frames.CreateFrame();
+            // We create a clone of the frame and add it.
+            // We will overpaint the difference of pixels on the current frame to create a complete image.
+            // This ensures that we have enough pixel data to process without distortion. #2450
+            currentFrame = image!.Frames.AddFrame(previousFrame);
 
             this.SetFrameMetadata(currentFrame.Metadata);
 
@@ -631,7 +647,10 @@ private void ReadFrameMetadata(BufferedReadStream stream, List<ImageFrameMetadat
         // Skip the color table for this frame if local.
         if (this.imageDescriptor.LocalColorTableFlag)
         {
-            stream.Skip(this.imageDescriptor.LocalColorTableSize * 3);
+            // Read and store the local color table. We allocate the maximum possible size and slice to match.
+            int length = this.currentLocalColorTableSize = this.imageDescriptor.LocalColorTableSize * 3;
+            this.currentLocalColorTable ??= this.configuration.MemoryAllocator.Allocate<byte>(768, AllocationOptions.Clean);
+            stream.Read(this.currentLocalColorTable.GetSpan()[..length]);
         }
 
         // Skip the frame indices. Pixels length + mincode size.
@@ -682,21 +701,30 @@ private void SetFrameMetadata(ImageFrameMetadata metadata)
         {
             GifFrameMetadata gifMeta = metadata.GetGifMetadata();
             gifMeta.ColorTableMode = GifColorTableMode.Global;
-            gifMeta.ColorTableLength = this.logicalScreenDescriptor.GlobalColorTableSize;
         }
 
         if (this.imageDescriptor.LocalColorTableFlag
             && this.imageDescriptor.LocalColorTableSize > 0)
         {
             GifFrameMetadata gifMeta = metadata.GetGifMetadata();
             gifMeta.ColorTableMode = GifColorTableMode.Local;
-            gifMeta.ColorTableLength = this.imageDescriptor.LocalColorTableSize;
+
+            Color[] colorTable = new Color[this.imageDescriptor.LocalColorTableSize];
+            ref Rgb24 localBase = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<byte, Rgb24>(this.currentLocalColorTable!.GetSpan()[..this.currentLocalColorTableSize]));
+            for (int i = 0; i < colorTable.Length; i++)
+            {
+                colorTable[i] = new Color(Unsafe.Add(ref localBase, (uint)i));
+            }
+
+            gifMeta.LocalColorTable = colorTable;
         }
 
         // Graphics control extensions is optional.
         if (this.graphicsControlExtension != default)
         {
             GifFrameMetadata gifMeta = metadata.GetGifMetadata();
+            gifMeta.HasTransparency = this.graphicsControlExtension.TransparencyFlag;
+            gifMeta.TransparencyIndex = this.graphicsControlExtension.TransparencyIndex;
             gifMeta.FrameDelay = this.graphicsControlExtension.DelayTime;
             gifMeta.DisposalMethod = this.graphicsControlExtension.DisposalMethod;
         }
@@ -751,14 +779,21 @@ private void ReadLogicalScreenDescriptorAndGlobalColorTable(BufferedReadStream s
         if (this.logicalScreenDescriptor.GlobalColorTableFlag)
         {
             int globalColorTableLength = this.logicalScreenDescriptor.GlobalColorTableSize * 3;
-            this.gifMetadata.GlobalColorTableLength = globalColorTableLength;
-
             if (globalColorTableLength > 0)
             {
                 this.globalColorTable = this.memoryAllocator.Allocate<byte>(globalColorTableLength, AllocationOptions.Clean);
 
-                // Read the global color table data from the stream
+                // Read the global color table data from the stream and preserve it in the gif metadata
                 stream.Read(this.globalColorTable.GetSpan());
+
+                Color[] colorTable = new Color[this.logicalScreenDescriptor.GlobalColorTableSize];
+                ref Rgb24 globalBase = ref MemoryMarshal.GetReference(MemoryMarshal.Cast<byte, Rgb24>(this.globalColorTable.GetSpan()));
+                for (int i = 0; i < colorTable.Length; i++)
+                {
+                    colorTable[i] = new Color(Unsafe.Add(ref globalBase, (uint)i));
+                }
+
+                this.gifMetadata.GlobalColorTable = colorTable;
             }
         }
     }