Merge branch 'main' into inline-vector-constants

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Gets the dimensions of the image.
         /// </summary>
-        public Size Dimensions => new Size(this.imageDescriptor.Width, this.imageDescriptor.Height);
+        public Size Dimensions => new(this.imageDescriptor.Width, this.imageDescriptor.Height);
 
         private MemoryAllocator MemoryAllocator => this.Configuration.MemoryAllocator;
 

src/ImageSharp/Formats/Gif/GifFormat.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
 using System.Collections.Generic;
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Gets the current instance.
         /// </summary>
-        public static GifFormat Instance { get; } = new GifFormat();
+        public static GifFormat Instance { get; } = new();
 
         /// <inheritdoc/>
         public string Name => "GIF";
@@ -32,9 +32,9 @@ namespace SixLabors.ImageSharp.Formats.Gif
         public IEnumerable<string> FileExtensions => GifConstants.FileExtensions;
 
         /// <inheritdoc/>
-        public GifMetadata CreateDefaultFormatMetadata() => new GifMetadata();
+        public GifMetadata CreateDefaultFormatMetadata() => new();
 
         /// <inheritdoc/>
-        public GifFrameMetadata CreateDefaultFormatFrameMetadata() => new GifFrameMetadata();
+        public GifFrameMetadata CreateDefaultFormatFrameMetadata() => new();
     }
 }

src/ImageSharp/Formats/Webp/AnimationBlendingMethod.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    /// <summary>
+    /// Indicates how transparent pixels of the current frame are to be blended with corresponding pixels of the previous canvas.
+    /// </summary>
+    internal enum AnimationBlendingMethod
+    {
+        /// <summary>
+        /// Use alpha blending. After disposing of the previous frame, render the current frame on the canvas using alpha-blending.
+        /// If the current frame does not have an alpha channel, assume alpha value of 255, effectively replacing the rectangle.
+        /// </summary>
+        AlphaBlending = 0,
+
+        /// <summary>
+        /// Do not blend. After disposing of the previous frame,
+        /// render the current frame on the canvas by overwriting the rectangle covered by the current frame.
+        /// </summary>
+        DoNotBlend = 1
+    }
+}

src/ImageSharp/Formats/Webp/AnimationDisposalMethod.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    /// <summary>
+    /// Indicates how the current frame is to be treated after it has been displayed (before rendering the next frame) on the canvas.
+    /// </summary>
+    internal enum AnimationDisposalMethod
+    {
+        /// <summary>
+        /// Do not dispose. Leave the canvas as is.
+        /// </summary>
+        DoNotDispose = 0,
+
+        /// <summary>
+        /// Dispose to background color. Fill the rectangle on the canvas covered by the current frame with background color specified in the ANIM chunk.
+        /// </summary>
+        Dispose = 1
+    }
+}

src/ImageSharp/Formats/Webp/AnimationFrameData.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    internal struct AnimationFrameData
+    {
+        /// <summary>
+        /// The animation chunk size.
+        /// </summary>
+        public uint DataSize;
+
+        /// <summary>
+        /// The X coordinate of the upper left corner of the frame is Frame X * 2.
+        /// </summary>
+        public uint X;
+
+        /// <summary>
+        /// The Y coordinate of the upper left corner of the frame is Frame Y * 2.
+        /// </summary>
+        public uint Y;
+
+        /// <summary>
+        /// The width of the frame.
+        /// </summary>
+        public uint Width;
+
+        /// <summary>
+        /// The height of the frame.
+        /// </summary>
+        public uint Height;
+
+        /// <summary>
+        /// The time to wait before displaying the next frame, in 1 millisecond units.
+        /// Note the interpretation of frame duration of 0 (and often smaller then 10) is implementation defined.
+        /// </summary>
+        public uint Duration;
+
+        /// <summary>
+        /// Indicates how transparent pixels of the current frame are to be blended with corresponding pixels of the previous canvas.
+        /// </summary>
+        public AnimationBlendingMethod BlendingMethod;
+
+        /// <summary>
+        /// Indicates how the current frame is to be treated after it has been displayed (before rendering the next frame) on the canvas.
+        /// </summary>
+        public AnimationDisposalMethod DisposalMethod;
+    }
+}

src/ImageSharp/Formats/Webp/IWebpDecoderOptions.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Metadata;
+
 namespace SixLabors.ImageSharp.Formats.Webp
 {
     /// <summary>
@@ -12,5 +14,10 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
         /// </summary>
         bool IgnoreMetadata { get; }
+
+        /// <summary>
+        /// Gets the decoding mode for multi-frame images.
+        /// </summary>
+        FrameDecodingMode DecodingMode { get; }
     }
 }

src/ImageSharp/Formats/Webp/Lossless/WebpLosslessDecoder.cs

@@ -87,7 +87,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossless
         private static ReadOnlySpan<byte> LiteralMap => new byte[] { 0, 1, 1, 1, 0 };
 
         /// <summary>
-        /// Decodes the image from the stream using the bitreader.
+        /// Decodes the lossless webp image from the stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="pixels">The pixel buffer to store the decoded data.</param>

src/ImageSharp/Formats/Webp/Lossy/WebpLossyDecoder.cs

@@ -57,7 +57,16 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
             this.configuration = configuration;
         }
 
-        public void Decode<TPixel>(Buffer2D<TPixel> pixels, int width, int height, WebpImageInfo info)
+        /// <summary>
+        /// Decodes the lossless webp image from the stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="pixels">The pixel buffer to store the decoded data.</param>
+        /// <param name="width">The width of the image.</param>
+        /// <param name="height">The height of the image.</param>
+        /// <param name="info">Information about the image.</param>
+        /// <param name="alphaData">The ALPH chunk data.</param>
+        public void Decode<TPixel>(Buffer2D<TPixel> pixels, int width, int height, WebpImageInfo info, IMemoryOwner<byte> alphaData)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // Paragraph 9.2: color space and clamp type follow.
@@ -105,7 +114,7 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
                     using (var alphaDecoder = new AlphaDecoder(
                         width,
                         height,
-                        info.Features.AlphaData,
+                        alphaData,
                         info.Features.AlphaChunkHeader,
                         this.memoryAllocator,
                         this.configuration))

src/ImageSharp/Formats/Webp/MetadataExtensions.cs

@@ -17,5 +17,12 @@ namespace SixLabors.ImageSharp
         /// <param name="metadata">The metadata this method extends.</param>
         /// <returns>The <see cref="WebpMetadata"/>.</returns>
         public static WebpMetadata GetWebpMetadata(this ImageMetadata metadata) => metadata.GetFormatMetadata(WebpFormat.Instance);
+
+        /// <summary>
+        /// Gets the webp format specific metadata for the image frame.
+        /// </summary>
+        /// <param name="metadata">The metadata this method extends.</param>
+        /// <returns>The <see cref="WebpFrameMetadata"/>.</returns>
+        public static WebpFrameMetadata GetWebpMetadata(this ImageFrameMetadata metadata) => metadata.GetFormatMetadata(WebpFormat.Instance);
     }
 }

src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs

@@ -0,0 +1,386 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats.Webp.Lossless;
+using SixLabors.ImageSharp.Formats.Webp.Lossy;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    /// <summary>
+    /// Decoder for animated webp images.
+    /// </summary>
+    internal class WebpAnimationDecoder : IDisposable
+    {
+        /// <summary>
+        /// Reusable buffer.
+        /// </summary>
+        private readonly byte[] buffer = new byte[4];
+
+        /// <summary>
+        /// Used for allocating memory during the decoding operations.
+        /// </summary>
+        private readonly MemoryAllocator memoryAllocator;
+
+        /// <summary>
+        /// The global configuration.
+        /// </summary>
+        private readonly Configuration configuration;
+
+        /// <summary>
+        /// The area to restore.
+        /// </summary>
+        private Rectangle? restoreArea;
+
+        /// <summary>
+        /// The abstract metadata.
+        /// </summary>
+        private ImageMetadata metadata;
+
+        /// <summary>
+        /// The gif specific metadata.
+        /// </summary>
+        private WebpMetadata webpMetadata;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WebpAnimationDecoder"/> class.
+        /// </summary>
+        /// <param name="memoryAllocator">The memory allocator.</param>
+        /// <param name="configuration">The global configuration.</param>
+        /// <param name="decodingMode">The frame decoding mode.</param>
+        public WebpAnimationDecoder(MemoryAllocator memoryAllocator, Configuration configuration, FrameDecodingMode decodingMode)
+        {
+            this.memoryAllocator = memoryAllocator;
+            this.configuration = configuration;
+            this.DecodingMode = decodingMode;
+        }
+
+        /// <summary>
+        /// Gets or sets the alpha data, if an ALPH chunk is present.
+        /// </summary>
+        public IMemoryOwner<byte> AlphaData { get; set; }
+
+        /// <summary>
+        /// Gets the decoding mode for multi-frame images.
+        /// </summary>
+        public FrameDecodingMode DecodingMode { get; }
+
+        /// <summary>
+        /// Decodes the animated webp image from the specified stream.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="stream">The stream, where the image should be decoded from. Cannot be null.</param>
+        /// <param name="features">The webp features.</param>
+        /// <param name="width">The width of the image.</param>
+        /// <param name="height">The height of the image.</param>
+        /// <param name="completeDataSize">The size of the image data in bytes.</param>
+        public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, WebpFeatures features, uint width, uint height, uint completeDataSize)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Image<TPixel> image = null;
+            ImageFrame<TPixel> previousFrame = null;
+
+            this.metadata = new ImageMetadata();
+            this.webpMetadata = this.metadata.GetWebpMetadata();
+            this.webpMetadata.AnimationLoopCount = features.AnimationLoopCount;
+
+            int remainingBytes = (int)completeDataSize;
+            while (remainingBytes > 0)
+            {
+                WebpChunkType chunkType = WebpChunkParsingUtils.ReadChunkType(stream, this.buffer);
+                remainingBytes -= 4;
+                switch (chunkType)
+                {
+                    case WebpChunkType.Animation:
+                        uint dataSize = this.ReadFrame(stream, ref image, ref previousFrame, width, height, features.AnimationBackgroundColor.Value);
+                        remainingBytes -= (int)dataSize;
+                        break;
+                    case WebpChunkType.Xmp:
+                    case WebpChunkType.Exif:
+                        WebpChunkParsingUtils.ParseOptionalChunks(stream, chunkType, image.Metadata, false, this.buffer);
+                        break;
+                    default:
+                        WebpThrowHelper.ThrowImageFormatException("Read unexpected webp chunk data");
+                        break;
+                }
+
+                if (stream.Position == stream.Length || this.DecodingMode is FrameDecodingMode.First)
+                {
+                    break;
+                }
+            }
+
+            return image;
+        }
+
+        /// <summary>
+        /// Reads an individual webp frame.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="stream">The stream, where the image should be decoded from. Cannot be null.</param>
+        /// <param name="image">The image to decode the information to.</param>
+        /// <param name="previousFrame">The previous frame.</param>
+        /// <param name="width">The width of the image.</param>
+        /// <param name="height">The height of the image.</param>
+        /// <param name="backgroundColor">The default background color of the canvas in.</param>
+        private uint ReadFrame<TPixel>(BufferedReadStream stream, ref Image<TPixel> image, ref ImageFrame<TPixel> previousFrame, uint width, uint height, Color backgroundColor)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            AnimationFrameData frameData = this.ReadFrameHeader(stream);
+            long streamStartPosition = stream.Position;
+
+            WebpChunkType chunkType = WebpChunkParsingUtils.ReadChunkType(stream, this.buffer);
+            bool hasAlpha = false;
+            byte alphaChunkHeader = 0;
+            if (chunkType is WebpChunkType.Alpha)
+            {
+                alphaChunkHeader = this.ReadAlphaData(stream);
+                hasAlpha = true;
+                chunkType = WebpChunkParsingUtils.ReadChunkType(stream, this.buffer);
+            }
+
+            WebpImageInfo webpInfo = null;
+            var features = new WebpFeatures();
+            switch (chunkType)
+            {
+                case WebpChunkType.Vp8:
+                    webpInfo = WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, stream, this.buffer, features);
+                    features.Alpha = hasAlpha;
+                    features.AlphaChunkHeader = alphaChunkHeader;
+                    break;
+                case WebpChunkType.Vp8L:
+                    webpInfo = WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, stream, this.buffer, features);
+                    break;
+                default:
+                    WebpThrowHelper.ThrowImageFormatException("Read unexpected chunk type, should be VP8 or VP8L");
+                    break;
+            }
+
+            ImageFrame<TPixel> currentFrame = null;
+            ImageFrame<TPixel> imageFrame;
+            if (previousFrame is null)
+            {
+                image = new Image<TPixel>(this.configuration, (int)width, (int)height, backgroundColor.ToPixel<TPixel>(), this.metadata);
+
+                this.SetFrameMetadata(image.Frames.RootFrame.Metadata, frameData.Duration);
+
+                imageFrame = image.Frames.RootFrame;
+            }
+            else
+            {
+                currentFrame = image.Frames.AddFrame(previousFrame); // This clones the frame and adds it the collection.
+
+                this.SetFrameMetadata(currentFrame.Metadata, frameData.Duration);
+
+                imageFrame = currentFrame;
+            }
+
+            int frameX = (int)(frameData.X * 2);
+            int frameY = (int)(frameData.Y * 2);
+            int frameWidth = (int)frameData.Width;
+            int frameHeight = (int)frameData.Height;
+            var regionRectangle = Rectangle.FromLTRB(frameX, frameY, frameX + frameWidth, frameY + frameHeight);
+
+            if (frameData.DisposalMethod is AnimationDisposalMethod.Dispose)
+            {
+                this.RestoreToBackground(imageFrame, backgroundColor);
+            }
+
+            using Buffer2D<TPixel> decodedImage = this.DecodeImageData<TPixel>(frameData, webpInfo);
+            this.DrawDecodedImageOnCanvas(decodedImage, imageFrame, frameX, frameY, frameWidth, frameHeight);
+
+            if (previousFrame != null && frameData.BlendingMethod is AnimationBlendingMethod.AlphaBlending)
+            {
+                this.AlphaBlend(previousFrame, imageFrame, frameX, frameY, frameWidth, frameHeight);
+            }
+
+            previousFrame = currentFrame ?? image.Frames.RootFrame;
+            this.restoreArea = regionRectangle;
+
+            return (uint)(stream.Position - streamStartPosition);
+        }
+
+        /// <summary>
+        /// Sets the frames metadata.
+        /// </summary>
+        /// <param name="meta">The metadata.</param>
+        /// <param name="duration">The frame duration.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SetFrameMetadata(ImageFrameMetadata meta, uint duration)
+        {
+            WebpFrameMetadata frameMetadata = meta.GetWebpMetadata();
+            frameMetadata.FrameDuration = duration;
+        }
+
+        /// <summary>
+        /// Reads the ALPH chunk data.
+        /// </summary>
+        /// <param name="stream">The stream to read from.</param>
+        private byte ReadAlphaData(BufferedReadStream stream)
+        {
+            this.AlphaData?.Dispose();
+
+            uint alphaChunkSize = WebpChunkParsingUtils.ReadChunkSize(stream, this.buffer);
+            int alphaDataSize = (int)(alphaChunkSize - 1);
+            this.AlphaData = this.memoryAllocator.Allocate<byte>(alphaDataSize);
+
+            byte alphaChunkHeader = (byte)stream.ReadByte();
+            Span<byte> alphaData = this.AlphaData.GetSpan();
+            stream.Read(alphaData, 0, alphaDataSize);
+
+            return alphaChunkHeader;
+        }
+
+        /// <summary>
+        /// Decodes the either lossy or lossless webp image data.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="frameData">The frame data.</param>
+        /// <param name="webpInfo">The webp information.</param>
+        /// <returns>A decoded image.</returns>
+        private Buffer2D<TPixel> DecodeImageData<TPixel>(AnimationFrameData frameData, WebpImageInfo webpInfo)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            var decodedImage = new Image<TPixel>((int)frameData.Width, (int)frameData.Height);
+
+            try
+            {
+                Buffer2D<TPixel> pixelBufferDecoded = decodedImage.Frames.RootFrame.PixelBuffer;
+                if (webpInfo.IsLossless)
+                {
+                    var losslessDecoder = new WebpLosslessDecoder(webpInfo.Vp8LBitReader, this.memoryAllocator, this.configuration);
+                    losslessDecoder.Decode(pixelBufferDecoded, (int)webpInfo.Width, (int)webpInfo.Height);
+                }
+                else
+                {
+                    var lossyDecoder = new WebpLossyDecoder(webpInfo.Vp8BitReader, this.memoryAllocator, this.configuration);
+                    lossyDecoder.Decode(pixelBufferDecoded, (int)webpInfo.Width, (int)webpInfo.Height, webpInfo, this.AlphaData);
+                }
+
+                return pixelBufferDecoded;
+            }
+            catch
+            {
+                decodedImage?.Dispose();
+                throw;
+            }
+            finally
+            {
+                webpInfo.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Draws the decoded image on canvas. The decoded image can be smaller the the canvas.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="decodedImage">The decoded image.</param>
+        /// <param name="imageFrame">The image frame to draw into.</param>
+        /// <param name="frameX">The frame x coordinate.</param>
+        /// <param name="frameY">The frame y coordinate.</param>
+        /// <param name="frameWidth">The width of the frame.</param>
+        /// <param name="frameHeight">The height of the frame.</param>
+        private void DrawDecodedImageOnCanvas<TPixel>(Buffer2D<TPixel> decodedImage, ImageFrame<TPixel> imageFrame, int frameX, int frameY, int frameWidth, int frameHeight)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Buffer2D<TPixel> imageFramePixels = imageFrame.PixelBuffer;
+            int decodedRowIdx = 0;
+            for (int y = frameY; y < frameY + frameHeight; y++)
+            {
+                Span<TPixel> framePixelRow = imageFramePixels.DangerousGetRowSpan(y);
+                Span<TPixel> decodedPixelRow = decodedImage.DangerousGetRowSpan(decodedRowIdx++).Slice(0, frameWidth);
+                decodedPixelRow.TryCopyTo(framePixelRow.Slice(frameX));
+            }
+        }
+
+        /// <summary>
+        /// After disposing of the previous frame, render the current frame on the canvas using alpha-blending.
+        /// If the current frame does not have an alpha channel, assume alpha value of 255, effectively replacing the rectangle.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="src">The source image.</param>
+        /// <param name="dst">The destination image.</param>
+        /// <param name="frameX">The frame x coordinate.</param>
+        /// <param name="frameY">The frame y coordinate.</param>
+        /// <param name="frameWidth">The width of the frame.</param>
+        /// <param name="frameHeight">The height of the frame.</param>
+        private void AlphaBlend<TPixel>(ImageFrame<TPixel> src, ImageFrame<TPixel> dst, int frameX, int frameY, int frameWidth, int frameHeight)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Buffer2D<TPixel> srcPixels = src.PixelBuffer;
+            Buffer2D<TPixel> dstPixels = dst.PixelBuffer;
+            PixelBlender<TPixel> blender = PixelOperations<TPixel>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.SrcOver);
+            for (int y = frameY; y < frameY + frameHeight; y++)
+            {
+                Span<TPixel> srcPixelRow = srcPixels.DangerousGetRowSpan(y).Slice(frameX, frameWidth);
+                Span<TPixel> dstPixelRow = dstPixels.DangerousGetRowSpan(y).Slice(frameX, frameWidth);
+
+                blender.Blend<TPixel>(this.configuration, dstPixelRow, srcPixelRow, dstPixelRow, 1.0f);
+            }
+        }
+
+        /// <summary>
+        /// Dispose to background color. Fill the rectangle on the canvas covered by the current frame
+        /// with background color specified in the ANIM chunk.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="imageFrame">The image frame.</param>
+        /// <param name="backgroundColor">Color of the background.</param>
+        private void RestoreToBackground<TPixel>(ImageFrame<TPixel> imageFrame, Color backgroundColor)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            if (!this.restoreArea.HasValue)
+            {
+                return;
+            }
+
+            var interest = Rectangle.Intersect(imageFrame.Bounds(), this.restoreArea.Value);
+            Buffer2DRegion<TPixel> pixelRegion = imageFrame.PixelBuffer.GetRegion(interest);
+            TPixel backgroundPixel = backgroundColor.ToPixel<TPixel>();
+            pixelRegion.Fill(backgroundPixel);
+        }
+
+        /// <summary>
+        /// Reads the animation frame header.
+        /// </summary>
+        /// <param name="stream">The stream to read from.</param>
+        /// <returns>Animation frame data.</returns>
+        private AnimationFrameData ReadFrameHeader(BufferedReadStream stream)
+        {
+            var data = new AnimationFrameData
+            {
+                DataSize = WebpChunkParsingUtils.ReadChunkSize(stream, this.buffer)
+            };
+
+            // 3 bytes for the X coordinate of the upper left corner of the frame.
+            data.X = WebpChunkParsingUtils.ReadUnsignedInt24Bit(stream, this.buffer);
+
+            // 3 bytes for the Y coordinate of the upper left corner of the frame.
+            data.Y = WebpChunkParsingUtils.ReadUnsignedInt24Bit(stream, this.buffer);
+
+            // Frame width Minus One.
+            data.Width = WebpChunkParsingUtils.ReadUnsignedInt24Bit(stream, this.buffer) + 1;
+
+            // Frame height Minus One.
+            data.Height = WebpChunkParsingUtils.ReadUnsignedInt24Bit(stream, this.buffer) + 1;
+
+            // Frame duration.
+            data.Duration = WebpChunkParsingUtils.ReadUnsignedInt24Bit(stream, this.buffer);
+
+            byte flags = (byte)stream.ReadByte();
+            data.DisposalMethod = (flags & 1) == 1 ? AnimationDisposalMethod.Dispose : AnimationDisposalMethod.DoNotDispose;
+            data.BlendingMethod = (flags & (1 << 1)) != 0 ? AnimationBlendingMethod.DoNotBlend : AnimationBlendingMethod.AlphaBlending;
+
+            return data;
+        }
+
+        /// <inheritdoc/>
+        public void Dispose() => this.AlphaData?.Dispose();
+    }
+}

src/ImageSharp/Formats/Webp/WebpChunkParsingUtils.cs

@@ -0,0 +1,375 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers.Binary;
+using SixLabors.ImageSharp.Formats.Webp.BitReader;
+using SixLabors.ImageSharp.Formats.Webp.Lossy;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
+using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    internal static class WebpChunkParsingUtils
+    {
+        /// <summary>
+        /// Reads the header of a lossy webp image.
+        /// </summary>
+        /// <returns>Information about this webp image.</returns>
+        public static WebpImageInfo ReadVp8Header(MemoryAllocator memoryAllocator, BufferedReadStream stream, byte[] buffer, WebpFeatures features)
+        {
+            // VP8 data size (not including this 4 bytes).
+            int bytesRead = stream.Read(buffer, 0, 4);
+            if (bytesRead != 4)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 header");
+            }
+
+            uint dataSize = BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+
+            // Remaining counts the available image data payload.
+            uint remaining = dataSize;
+
+            // Paragraph 9.1 https://tools.ietf.org/html/rfc6386#page-30
+            // Frame tag that contains four fields:
+            // - A 1-bit frame type (0 for key frames, 1 for interframes).
+            // - A 3-bit version number.
+            // - A 1-bit show_frame flag.
+            // - A 19-bit field containing the size of the first data partition in bytes.
+            bytesRead = stream.Read(buffer, 0, 3);
+            if (bytesRead != 3)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 header");
+            }
+
+            uint frameTag = (uint)(buffer[0] | (buffer[1] << 8) | (buffer[2] << 16));
+            remaining -= 3;
+            bool isNoKeyFrame = (frameTag & 0x1) == 1;
+            if (isNoKeyFrame)
+            {
+                WebpThrowHelper.ThrowImageFormatException("VP8 header indicates the image is not a key frame");
+            }
+
+            uint version = (frameTag >> 1) & 0x7;
+            if (version > 3)
+            {
+                WebpThrowHelper.ThrowImageFormatException($"VP8 header indicates unknown profile {version}");
+            }
+
+            bool invisibleFrame = ((frameTag >> 4) & 0x1) == 0;
+            if (invisibleFrame)
+            {
+                WebpThrowHelper.ThrowImageFormatException("VP8 header indicates that the first frame is invisible");
+            }
+
+            uint partitionLength = frameTag >> 5;
+            if (partitionLength > dataSize)
+            {
+                WebpThrowHelper.ThrowImageFormatException("VP8 header contains inconsistent size information");
+            }
+
+            // Check for VP8 magic bytes.
+            bytesRead = stream.Read(buffer, 0, 3);
+            if (bytesRead != 3)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 magic bytes");
+            }
+
+            if (!buffer.AsSpan(0, 3).SequenceEqual(WebpConstants.Vp8HeaderMagicBytes))
+            {
+                WebpThrowHelper.ThrowImageFormatException("VP8 magic bytes not found");
+            }
+
+            bytesRead = stream.Read(buffer, 0, 4);
+            if (bytesRead != 4)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 header, could not read width and height");
+            }
+
+            uint tmp = BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+            uint width = tmp & 0x3fff;
+            sbyte xScale = (sbyte)(tmp >> 6);
+            tmp = BinaryPrimitives.ReadUInt16LittleEndian(buffer.AsSpan(2));
+            uint height = tmp & 0x3fff;
+            sbyte yScale = (sbyte)(tmp >> 6);
+            remaining -= 7;
+            if (width == 0 || height == 0)
+            {
+                WebpThrowHelper.ThrowImageFormatException("width or height can not be zero");
+            }
+
+            if (partitionLength > remaining)
+            {
+                WebpThrowHelper.ThrowImageFormatException("bad partition length");
+            }
+
+            var vp8FrameHeader = new Vp8FrameHeader()
+            {
+                KeyFrame = true,
+                Profile = (sbyte)version,
+                PartitionLength = partitionLength
+            };
+
+            var bitReader = new Vp8BitReader(
+                stream,
+                remaining,
+                memoryAllocator,
+                partitionLength)
+            {
+                Remaining = remaining
+            };
+
+            return new WebpImageInfo()
+            {
+                Width = width,
+                Height = height,
+                XScale = xScale,
+                YScale = yScale,
+                BitsPerPixel = features?.Alpha == true ? WebpBitsPerPixel.Pixel32 : WebpBitsPerPixel.Pixel24,
+                IsLossless = false,
+                Features = features,
+                Vp8Profile = (sbyte)version,
+                Vp8FrameHeader = vp8FrameHeader,
+                Vp8BitReader = bitReader
+            };
+        }
+
+        /// <summary>
+        /// Reads the header of a lossless webp image.
+        /// </summary>
+        /// <returns>Information about this image.</returns>
+        public static WebpImageInfo ReadVp8LHeader(MemoryAllocator memoryAllocator, BufferedReadStream stream, byte[] buffer, WebpFeatures features)
+        {
+            // VP8 data size.
+            uint imageDataSize = ReadChunkSize(stream, buffer);
+
+            var bitReader = new Vp8LBitReader(stream, imageDataSize, memoryAllocator);
+
+            // One byte signature, should be 0x2f.
+            uint signature = bitReader.ReadValue(8);
+            if (signature != WebpConstants.Vp8LHeaderMagicByte)
+            {
+                WebpThrowHelper.ThrowImageFormatException("Invalid VP8L signature");
+            }
+
+            // The first 28 bits of the bitstream specify the width and height of the image.
+            uint width = bitReader.ReadValue(WebpConstants.Vp8LImageSizeBits) + 1;
+            uint height = bitReader.ReadValue(WebpConstants.Vp8LImageSizeBits) + 1;
+            if (width == 0 || height == 0)
+            {
+                WebpThrowHelper.ThrowImageFormatException("invalid width or height read");
+            }
+
+            // The alphaIsUsed flag should be set to 0 when all alpha values are 255 in the picture, and 1 otherwise.
+            // TODO: this flag value is not used yet
+            bool alphaIsUsed = bitReader.ReadBit();
+
+            // The next 3 bits are the version. The version number is a 3 bit code that must be set to 0.
+            // Any other value should be treated as an error.
+            uint version = bitReader.ReadValue(WebpConstants.Vp8LVersionBits);
+            if (version != 0)
+            {
+                WebpThrowHelper.ThrowNotSupportedException($"Unexpected version number {version} found in VP8L header");
+            }
+
+            return new WebpImageInfo()
+            {
+                Width = width,
+                Height = height,
+                BitsPerPixel = WebpBitsPerPixel.Pixel32,
+                IsLossless = true,
+                Features = features,
+                Vp8LBitReader = bitReader
+            };
+        }
+
+        /// <summary>
+        /// Reads an the extended webp file header. An extended file header consists of:
+        /// - A 'VP8X' chunk with information about features used in the file.
+        /// - An optional 'ICCP' chunk with color profile.
+        /// - An optional 'XMP' chunk with metadata.
+        /// - An optional 'ANIM' chunk with animation control data.
+        /// - An optional 'ALPH' chunk with alpha channel data.
+        /// After the image header, image data will follow. After that optional image metadata chunks (EXIF and XMP) can follow.
+        /// </summary>
+        /// <returns>Information about this webp image.</returns>
+        public static WebpImageInfo ReadVp8XHeader(BufferedReadStream stream, byte[] buffer, WebpFeatures features)
+        {
+            uint fileSize = ReadChunkSize(stream, buffer);
+
+            // The first byte contains information about the image features used.
+            byte imageFeatures = (byte)stream.ReadByte();
+
+            // The first two bit of it are reserved and should be 0.
+            if (imageFeatures >> 6 != 0)
+            {
+                WebpThrowHelper.ThrowImageFormatException("first two bits of the VP8X header are expected to be zero");
+            }
+
+            // If bit 3 is set, a ICC Profile Chunk should be present.
+            features.IccProfile = (imageFeatures & (1 << 5)) != 0;
+
+            // If bit 4 is set, any of the frames of the image contain transparency information ("alpha" chunk).
+            features.Alpha = (imageFeatures & (1 << 4)) != 0;
+
+            // If bit 5 is set, a EXIF metadata should be present.
+            features.ExifProfile = (imageFeatures & (1 << 3)) != 0;
+
+            // If bit 6 is set, XMP metadata should be present.
+            features.XmpMetaData = (imageFeatures & (1 << 2)) != 0;
+
+            // If bit 7 is set, animation should be present.
+            features.Animation = (imageFeatures & (1 << 1)) != 0;
+
+            // 3 reserved bytes should follow which are supposed to be zero.
+            stream.Read(buffer, 0, 3);
+            if (buffer[0] != 0 || buffer[1] != 0 || buffer[2] != 0)
+            {
+                WebpThrowHelper.ThrowImageFormatException("reserved bytes should be zero");
+            }
+
+            // 3 bytes for the width.
+            uint width = ReadUnsignedInt24Bit(stream, buffer) + 1;
+
+            // 3 bytes for the height.
+            uint height = ReadUnsignedInt24Bit(stream, buffer) + 1;
+
+            // Read all the chunks in the order they occur.
+            var info = new WebpImageInfo()
+            {
+                Width = width,
+                Height = height,
+                Features = features
+            };
+
+            return info;
+        }
+
+        /// <summary>
+        /// Reads a unsigned 24 bit integer.
+        /// </summary>
+        /// <param name="stream">The stream to read from.</param>
+        /// <param name="buffer">The buffer to store the read data into.</param>
+        /// <returns>A unsigned 24 bit integer.</returns>
+        public static uint ReadUnsignedInt24Bit(BufferedReadStream stream, byte[] buffer)
+        {
+            if (stream.Read(buffer, 0, 3) == 3)
+            {
+                buffer[3] = 0;
+                return BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+            }
+
+            throw new ImageFormatException("Invalid Webp data, could not read unsigned integer.");
+        }
+
+        /// <summary>
+        /// Reads the chunk size. If Chunk Size is odd, a single padding byte will be added to the payload,
+        /// so the chunk size will be increased by 1 in those cases.
+        /// </summary>
+        /// <param name="stream">The stream to read the data from.</param>
+        /// <param name="buffer">Buffer to store the data read from the stream.</param>
+        /// <returns>The chunk size in bytes.</returns>
+        public static uint ReadChunkSize(BufferedReadStream stream, byte[] buffer)
+        {
+            if (stream.Read(buffer, 0, 4) == 4)
+            {
+                uint chunkSize = BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+                return (chunkSize % 2 == 0) ? chunkSize : chunkSize + 1;
+            }
+
+            throw new ImageFormatException("Invalid Webp data, could not read chunk size.");
+        }
+
+        /// <summary>
+        /// Identifies the chunk type from the chunk.
+        /// </summary>
+        /// <param name="stream">The stream to read the data from.</param>
+        /// <param name="buffer">Buffer to store the data read from the stream.</param>
+        /// <exception cref="ImageFormatException">
+        /// Thrown if the input stream is not valid.
+        /// </exception>
+        public static WebpChunkType ReadChunkType(BufferedReadStream stream, byte[] buffer)
+        {
+            if (stream.Read(buffer, 0, 4) == 4)
+            {
+                var chunkType = (WebpChunkType)BinaryPrimitives.ReadUInt32BigEndian(buffer);
+                return chunkType;
+            }
+
+            throw new ImageFormatException("Invalid Webp data, could not read chunk type.");
+        }
+
+        /// <summary>
+        /// Parses optional metadata chunks. There SHOULD be at most one chunk of each type ('EXIF' and 'XMP ').
+        /// If there are more such chunks, readers MAY ignore all except the first one.
+        /// Also, a file may possibly contain both 'EXIF' and 'XMP ' chunks.
+        /// </summary>
+        public static void ParseOptionalChunks(BufferedReadStream stream, WebpChunkType chunkType, ImageMetadata metadata, bool ignoreMetaData, byte[] buffer)
+        {
+            long streamLength = stream.Length;
+            while (stream.Position < streamLength)
+            {
+                uint chunkLength = ReadChunkSize(stream, buffer);
+
+                if (ignoreMetaData)
+                {
+                    stream.Skip((int)chunkLength);
+                }
+
+                int bytesRead;
+                switch (chunkType)
+                {
+                    case WebpChunkType.Exif:
+                        byte[] exifData = new byte[chunkLength];
+                        bytesRead = stream.Read(exifData, 0, (int)chunkLength);
+                        if (bytesRead != chunkLength)
+                        {
+                            WebpThrowHelper.ThrowImageFormatException("Could not read enough data for the EXIF profile");
+                        }
+
+                        if (metadata.ExifProfile != null)
+                        {
+                            metadata.ExifProfile = new ExifProfile(exifData);
+                        }
+
+                        break;
+                    case WebpChunkType.Xmp:
+                        byte[] xmpData = new byte[chunkLength];
+                        bytesRead = stream.Read(xmpData, 0, (int)chunkLength);
+                        if (bytesRead != chunkLength)
+                        {
+                            WebpThrowHelper.ThrowImageFormatException("Could not read enough data for the XMP profile");
+                        }
+
+                        if (metadata.XmpProfile != null)
+                        {
+                            metadata.XmpProfile = new XmpProfile(xmpData);
+                        }
+
+                        break;
+                    default:
+                        stream.Skip((int)chunkLength);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determines if the chunk type is an optional VP8X chunk.
+        /// </summary>
+        /// <param name="chunkType">The chunk type.</param>
+        /// <returns>True, if its an optional chunk type.</returns>
+        public static bool IsOptionalVp8XChunk(WebpChunkType chunkType) => chunkType switch
+        {
+            WebpChunkType.Alpha => true,
+            WebpChunkType.AnimationParameter => true,
+            WebpChunkType.Exif => true,
+            WebpChunkType.Iccp => true,
+            WebpChunkType.Xmp => true,
+            _ => false
+        };
+    }
+}

src/ImageSharp/Formats/Webp/WebpDecoder.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Threading;
 using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp
@@ -18,13 +19,19 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// </summary>
         public bool IgnoreMetadata { get; set; }
 
+        /// <summary>
+        /// Gets or sets the decoding mode for multi-frame images.
+        /// Defaults to All.
+        /// </summary>
+        public FrameDecodingMode DecodingMode { get; set; } = FrameDecodingMode.All;
+
         /// <inheritdoc/>
         public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Guard.NotNull(stream, nameof(stream));
 
-            var decoder = new WebpDecoderCore(configuration, this);
+            using var decoder = new WebpDecoderCore(configuration, this);
 
             try
             {

src/ImageSharp/Formats/Webp/WebpDecoderCore.cs

@@ -2,10 +2,10 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.Buffers.Binary;
 using System.IO;
 using System.Threading;
-using SixLabors.ImageSharp.Formats.Webp.BitReader;
 using SixLabors.ImageSharp.Formats.Webp.Lossless;
 using SixLabors.ImageSharp.Formats.Webp.Lossy;
 using SixLabors.ImageSharp.IO;
@@ -21,7 +21,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
     /// <summary>
     /// Performs the webp decoding operation.
     /// </summary>
-    internal sealed class WebpDecoderCore : IImageDecoderInternals
+    internal sealed class WebpDecoderCore : IImageDecoderInternals, IDisposable
     {
         /// <summary>
         /// Reusable buffer.
@@ -29,14 +29,14 @@ namespace SixLabors.ImageSharp.Formats.Webp
         private readonly byte[] buffer = new byte[4];
 
         /// <summary>
-        /// Used for allocating memory during processing operations.
+        /// Used for allocating memory during the decoding operations.
         /// </summary>
         private readonly MemoryAllocator memoryAllocator;
 
         /// <summary>
         /// The stream to decode from.
         /// </summary>
-        private Stream currentStream;
+        private BufferedReadStream currentStream;
 
         /// <summary>
         /// The webp specific metadata.
@@ -56,10 +56,19 @@ namespace SixLabors.ImageSharp.Formats.Webp
         public WebpDecoderCore(Configuration configuration, IWebpDecoderOptions options)
         {
             this.Configuration = configuration;
+            this.DecodingMode = options.DecodingMode;
             this.memoryAllocator = configuration.MemoryAllocator;
             this.IgnoreMetadata = options.IgnoreMetadata;
         }
 
+        /// <inheritdoc/>
+        public Configuration Configuration { get; }
+
+        /// <summary>
+        /// Gets the decoding mode for multi-frame images.
+        /// </summary>
+        public FrameDecodingMode DecodingMode { get; }
+
         /// <summary>
         /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
         /// </summary>
@@ -70,14 +79,16 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// </summary>
         public ImageMetadata Metadata { get; private set; }
 
-        /// <inheritdoc/>
-        public Configuration Configuration { get; }
-
         /// <summary>
         /// Gets the dimensions of the image.
         /// </summary>
         public Size Dimensions => new((int)this.webImageInfo.Width, (int)this.webImageInfo.Height);
 
+        /// <summary>
+        /// Gets or sets the alpha data, if an ALPH chunk is present.
+        /// </summary>
+        public IMemoryOwner<byte> AlphaData { get; set; }
+
         /// <inheritdoc />
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
@@ -92,6 +103,12 @@ namespace SixLabors.ImageSharp.Formats.Webp
 
                 using (this.webImageInfo = this.ReadVp8Info())
                 {
+                    if (this.webImageInfo.Features is { Animation: true })
+                    {
+                        using var animationDecoder = new WebpAnimationDecoder(this.memoryAllocator, this.Configuration, this.DecodingMode);
+                        return animationDecoder.Decode<TPixel>(stream, this.webImageInfo.Features, this.webImageInfo.Width, this.webImageInfo.Height, fileSize);
+                    }
+
                     if (this.webImageInfo.Features is { Animation: true })
                     {
                         WebpThrowHelper.ThrowNotSupportedException("Animations are not supported");
@@ -107,7 +124,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
                     else
                     {
                         var lossyDecoder = new WebpLossyDecoder(this.webImageInfo.Vp8BitReader, this.memoryAllocator, this.Configuration);
-                        lossyDecoder.Decode(pixels, image.Width, image.Height, this.webImageInfo);
+                        lossyDecoder.Decode(pixels, image.Width, image.Height, this.webImageInfo, this.AlphaData);
                     }
 
                     // There can be optional chunks after the image data, like EXIF and XMP.
@@ -132,7 +149,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
             this.currentStream = stream;
 
             this.ReadImageHeader();
-            using (this.webImageInfo = this.ReadVp8Info())
+            using (this.webImageInfo = this.ReadVp8Info(true))
             {
                 return new ImageInfo(new PixelTypeInfo((int)this.webImageInfo.BitsPerPixel), (int)this.webImageInfo.Width, (int)this.webImageInfo.Height, this.Metadata);
             }
@@ -150,7 +167,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
             // Read file size.
             // The size of the file in bytes starting at offset 8.
             // The file size in the header is the total size of the chunks that follow plus 4 bytes for the ‘WEBP’ FourCC.
-            uint fileSize = this.ReadChunkSize();
+            uint fileSize = WebpChunkParsingUtils.ReadChunkSize(this.currentStream, this.buffer);
 
             // Skip 'WEBP' from the header.
             this.currentStream.Skip(4);
@@ -161,310 +178,59 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// <summary>
         /// Reads information present in the image header, about the image content and how to decode the image.
         /// </summary>
+        /// <param name="ignoreAlpha">For identify, the alpha data should not be read.</param>
         /// <returns>Information about the webp image.</returns>
-        private WebpImageInfo ReadVp8Info()
+        private WebpImageInfo ReadVp8Info(bool ignoreAlpha = false)
         {
             this.Metadata = new ImageMetadata();
             this.webpMetadata = this.Metadata.GetFormatMetadata(WebpFormat.Instance);
 
-            WebpChunkType chunkType = this.ReadChunkType();
+            WebpChunkType chunkType = WebpChunkParsingUtils.ReadChunkType(this.currentStream, this.buffer);
 
+            var features = new WebpFeatures();
             switch (chunkType)
             {
                 case WebpChunkType.Vp8:
-                    return this.ReadVp8Header();
+                    this.webpMetadata.FileFormat = WebpFileFormatType.Lossy;
+                    return WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, this.currentStream, this.buffer, features);
                 case WebpChunkType.Vp8L:
-                    return this.ReadVp8LHeader();
+                    this.webpMetadata.FileFormat = WebpFileFormatType.Lossless;
+                    return WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, this.currentStream, this.buffer, features);
                 case WebpChunkType.Vp8X:
-                    return this.ReadVp8XHeader();
+                    WebpImageInfo webpInfos = WebpChunkParsingUtils.ReadVp8XHeader(this.currentStream, this.buffer, features);
+                    while (this.currentStream.Position < this.currentStream.Length)
+                    {
+                        chunkType = WebpChunkParsingUtils.ReadChunkType(this.currentStream, this.buffer);
+                        if (chunkType == WebpChunkType.Vp8)
+                        {
+                            this.webpMetadata.FileFormat = WebpFileFormatType.Lossy;
+                            webpInfos = WebpChunkParsingUtils.ReadVp8Header(this.memoryAllocator, this.currentStream, this.buffer, features);
+                        }
+                        else if (chunkType == WebpChunkType.Vp8L)
+                        {
+                            this.webpMetadata.FileFormat = WebpFileFormatType.Lossless;
+                            webpInfos = WebpChunkParsingUtils.ReadVp8LHeader(this.memoryAllocator, this.currentStream, this.buffer, features);
+                        }
+                        else if (WebpChunkParsingUtils.IsOptionalVp8XChunk(chunkType))
+                        {
+                            bool isAnimationChunk = this.ParseOptionalExtendedChunks(chunkType, features, ignoreAlpha);
+                            if (isAnimationChunk)
+                            {
+                                return webpInfos;
+                            }
+                        }
+                        else
+                        {
+                            WebpThrowHelper.ThrowImageFormatException("Unexpected chunk followed VP8X header");
+                        }
+                    }
+
+                    return webpInfos;
                 default:
                     WebpThrowHelper.ThrowImageFormatException("Unrecognized VP8 header");
-                    return new WebpImageInfo(); // this return will never be reached, because throw helper will throw an exception.
+                    return
-            }
+                        new WebpImageInfo(); // this return will never be reached, because throw helper will throw an exception.
-        }
-
-        /// <summary>
-        /// Reads an the extended webp file header. An extended file header consists of:
-        /// - A 'VP8X' chunk with information about features used in the file.
-        /// - An optional 'ICCP' chunk with color profile.
-        /// - An optional 'XMP' chunk with metadata.
-        /// - An optional 'ANIM' chunk with animation control data.
-        /// - An optional 'ALPH' chunk with alpha channel data.
-        /// After the image header, image data will follow. After that optional image metadata chunks (EXIF and XMP) can follow.
-        /// </summary>
-        /// <returns>Information about this webp image.</returns>
-        private WebpImageInfo ReadVp8XHeader()
-        {
-            var features = new WebpFeatures();
-            uint fileSize = this.ReadChunkSize();
-
-            // The first byte contains information about the image features used.
-            int imageFeatures = this.currentStream.ReadByte();
-            if (imageFeatures == -1)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("VP8X header doe not contain enough data");
-            }
-
-            // The first two bit of it are reserved and should be 0.
-            if (imageFeatures >> 6 != 0)
-            {
-                WebpThrowHelper.ThrowImageFormatException("first two bits of the VP8X header are expected to be zero");
-            }
-
-            // If bit 3 is set, a ICC Profile Chunk should be present.
-            features.IccProfile = (imageFeatures & (1 << 5)) != 0;
-
-            // If bit 4 is set, any of the frames of the image contain transparency information ("alpha" chunk).
-            features.Alpha = (imageFeatures & (1 << 4)) != 0;
-
-            // If bit 5 is set, a EXIF metadata should be present.
-            features.ExifProfile = (imageFeatures & (1 << 3)) != 0;
-
-            // If bit 6 is set, XMP metadata should be present.
-            features.XmpMetaData = (imageFeatures & (1 << 2)) != 0;
-
-            // If bit 7 is set, animation should be present.
-            features.Animation = (imageFeatures & (1 << 1)) != 0;
-
-            // 3 reserved bytes should follow which are supposed to be zero.
-            int bytesRead = this.currentStream.Read(this.buffer, 0, 3);
-            if (bytesRead != 3)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("VP8X header does not contain enough data");
-            }
-
-            if (this.buffer[0] != 0 || this.buffer[1] != 0 || this.buffer[2] != 0)
-            {
-                WebpThrowHelper.ThrowImageFormatException("reserved bytes should be zero");
-            }
-
-            // 3 bytes for the width.
-            bytesRead = this.currentStream.Read(this.buffer, 0, 3);
-            if (bytesRead != 3)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("VP8 header does not contain enough data to read the width");
             }
-
-            this.buffer[3] = 0;
-            uint width = (uint)BinaryPrimitives.ReadInt32LittleEndian(this.buffer) + 1;
-
-            // 3 bytes for the height.
-            bytesRead = this.currentStream.Read(this.buffer, 0, 3);
-            if (bytesRead != 3)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("VP8 header does not contain enough data to read the height");
-            }
-
-            this.buffer[3] = 0;
-            uint height = (uint)BinaryPrimitives.ReadInt32LittleEndian(this.buffer) + 1;
-
-            // Read all the chunks in the order they occur.
-            var info = new WebpImageInfo();
-            while (this.currentStream.Position < this.currentStream.Length)
-            {
-                WebpChunkType chunkType = this.ReadChunkType();
-                if (chunkType == WebpChunkType.Vp8)
-                {
-                    info = this.ReadVp8Header(features);
-                }
-                else if (chunkType == WebpChunkType.Vp8L)
-                {
-                    info = this.ReadVp8LHeader(features);
-                }
-                else if (IsOptionalVp8XChunk(chunkType))
-                {
-                    this.ParseOptionalExtendedChunks(chunkType, features);
-                }
-                else
-                {
-                    WebpThrowHelper.ThrowImageFormatException("Unexpected chunk followed VP8X header");
-                }
-            }
-
-            if (features.Animation)
-            {
-                // TODO: Animations are not yet supported.
-                return new WebpImageInfo() { Width = width, Height = height, Features = features };
-            }
-
-            return info;
-        }
-
-        /// <summary>
-        /// Reads the header of a lossy webp image.
-        /// </summary>
-        /// <param name="features">Webp features.</param>
-        /// <returns>Information about this webp image.</returns>
-        private WebpImageInfo ReadVp8Header(WebpFeatures features = null)
-        {
-            this.webpMetadata.FileFormat = WebpFileFormatType.Lossy;
-
-            // VP8 data size (not including this 4 bytes).
-            int bytesRead = this.currentStream.Read(this.buffer, 0, 4);
-            if (bytesRead != 4)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 data size");
-            }
-
-            uint dataSize = BinaryPrimitives.ReadUInt32LittleEndian(this.buffer);
-
-            // remaining counts the available image data payload.
-            uint remaining = dataSize;
-
-            // Paragraph 9.1 https://tools.ietf.org/html/rfc6386#page-30
-            // Frame tag that contains four fields:
-            // - A 1-bit frame type (0 for key frames, 1 for interframes).
-            // - A 3-bit version number.
-            // - A 1-bit show_frame flag.
-            // - A 19-bit field containing the size of the first data partition in bytes.
-            bytesRead = this.currentStream.Read(this.buffer, 0, 3);
-            if (bytesRead != 3)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 frame tag");
-            }
-
-            uint frameTag = (uint)(this.buffer[0] | (this.buffer[1] << 8) | (this.buffer[2] << 16));
-            remaining -= 3;
-            bool isNoKeyFrame = (frameTag & 0x1) == 1;
-            if (isNoKeyFrame)
-            {
-                WebpThrowHelper.ThrowImageFormatException("VP8 header indicates the image is not a key frame");
-            }
-
-            uint version = (frameTag >> 1) & 0x7;
-            if (version > 3)
-            {
-                WebpThrowHelper.ThrowImageFormatException($"VP8 header indicates unknown profile {version}");
-            }
-
-            bool invisibleFrame = ((frameTag >> 4) & 0x1) == 0;
-            if (invisibleFrame)
-            {
-                WebpThrowHelper.ThrowImageFormatException("VP8 header indicates that the first frame is invisible");
-            }
-
-            uint partitionLength = frameTag >> 5;
-            if (partitionLength > dataSize)
-            {
-                WebpThrowHelper.ThrowImageFormatException("VP8 header contains inconsistent size information");
-            }
-
-            // Check for VP8 magic bytes.
-            bytesRead = this.currentStream.Read(this.buffer, 0, 3);
-            if (bytesRead != 3)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the VP8 magic bytes");
-            }
-
-            if (!this.buffer.AsSpan(0, 3).SequenceEqual(WebpConstants.Vp8HeaderMagicBytes))
-            {
-                WebpThrowHelper.ThrowImageFormatException("VP8 magic bytes not found");
-            }
-
-            bytesRead = this.currentStream.Read(this.buffer, 0, 4);
-            if (bytesRead != 4)
-            {
-                WebpThrowHelper.ThrowInvalidImageContentException("VP8 header does not contain enough data to read the image width and height");
-            }
-
-            uint tmp = (uint)BinaryPrimitives.ReadInt16LittleEndian(this.buffer);
-            uint width = tmp & 0x3fff;
-            sbyte xScale = (sbyte)(tmp >> 6);
-            tmp = (uint)BinaryPrimitives.ReadInt16LittleEndian(this.buffer.AsSpan(2));
-            uint height = tmp & 0x3fff;
-            sbyte yScale = (sbyte)(tmp >> 6);
-            remaining -= 7;
-            if (width == 0 || height == 0)
-            {
-                WebpThrowHelper.ThrowImageFormatException("width or height can not be zero");
-            }
-
-            if (partitionLength > remaining)
-            {
-                WebpThrowHelper.ThrowImageFormatException("bad partition length");
-            }
-
-            var vp8FrameHeader = new Vp8FrameHeader()
-            {
-                KeyFrame = true,
-                Profile = (sbyte)version,
-                PartitionLength = partitionLength
-            };
-
-            var bitReader = new Vp8BitReader(
-                this.currentStream,
-                remaining,
-                this.memoryAllocator,
-                partitionLength)
-            {
-                Remaining = remaining
-            };
-
-            return new WebpImageInfo()
-            {
-                Width = width,
-                Height = height,
-                XScale = xScale,
-                YScale = yScale,
-                BitsPerPixel = features?.Alpha == true ? WebpBitsPerPixel.Pixel32 : WebpBitsPerPixel.Pixel24,
-                IsLossless = false,
-                Features = features,
-                Vp8Profile = (sbyte)version,
-                Vp8FrameHeader = vp8FrameHeader,
-                Vp8BitReader = bitReader
-            };
-        }
-
-        /// <summary>
-        /// Reads the header of a lossless webp image.
-        /// </summary>
-        /// <param name="features">Webp image features.</param>
-        /// <returns>Information about this image.</returns>
-        private WebpImageInfo ReadVp8LHeader(WebpFeatures features = null)
-        {
-            this.webpMetadata.FileFormat = WebpFileFormatType.Lossless;
-
-            // VP8 data size.
-            uint imageDataSize = this.ReadChunkSize();
-
-            var bitReader = new Vp8LBitReader(this.currentStream, imageDataSize, this.memoryAllocator);
-
-            // One byte signature, should be 0x2f.
-            uint signature = bitReader.ReadValue(8);
-            if (signature != WebpConstants.Vp8LHeaderMagicByte)
-            {
-                WebpThrowHelper.ThrowImageFormatException("Invalid VP8L signature");
-            }
-
-            // The first 28 bits of the bitstream specify the width and height of the image.
-            uint width = bitReader.ReadValue(WebpConstants.Vp8LImageSizeBits) + 1;
-            uint height = bitReader.ReadValue(WebpConstants.Vp8LImageSizeBits) + 1;
-            if (width == 0 || height == 0)
-            {
-                WebpThrowHelper.ThrowImageFormatException("invalid width or height read");
-            }
-
-            // The alphaIsUsed flag should be set to 0 when all alpha values are 255 in the picture, and 1 otherwise.
-            // TODO: this flag value is not used yet
-            bool alphaIsUsed = bitReader.ReadBit();
-
-            // The next 3 bits are the version. The version number is a 3 bit code that must be set to 0.
-            // Any other value should be treated as an error.
-            uint version = bitReader.ReadValue(WebpConstants.Vp8LVersionBits);
-            if (version != 0)
-            {
-                WebpThrowHelper.ThrowNotSupportedException($"Unexpected version number {version} found in VP8L header");
-            }
-
-            return new WebpImageInfo()
-            {
-                Width = width,
-                Height = height,
-                BitsPerPixel = WebpBitsPerPixel.Pixel32,
-                IsLossless = true,
-                Features = features,
-                Vp8LBitReader = bitReader
-            };
         }
 
         /// <summary>
@@ -472,7 +238,9 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// </summary>
         /// <param name="chunkType">The chunk type.</param>
         /// <param name="features">The webp image features.</param>
-        private void ParseOptionalExtendedChunks(WebpChunkType chunkType, WebpFeatures features)
+        /// <param name="ignoreAlpha">For identify, the alpha data should not be read.</param>
+        /// <returns>true, if its a alpha chunk.</returns>
+        private bool ParseOptionalExtendedChunks(WebpChunkType chunkType, WebpFeatures features, bool ignoreAlpha)
         {
             switch (chunkType)
             {
@@ -488,32 +256,23 @@ namespace SixLabors.ImageSharp.Formats.Webp
                     this.ReadXmpProfile();
                     break;
 
-                case WebpChunkType.Animation:
+                case WebpChunkType.AnimationParameter:
-                    // TODO: Decoding animation is not implemented yet.
+                    this.ReadAnimationParameters(features);
-                    break;
+                    return true;
 
                 case WebpChunkType.Alpha:
-                    uint alphaChunkSize = this.ReadChunkSize();
+                    this.ReadAlphaData(features, ignoreAlpha);
-                    features.AlphaChunkHeader = (byte)this.currentStream.ReadByte();
-                    int alphaDataSize = (int)(alphaChunkSize - 1);
-                    features.AlphaData = this.memoryAllocator.Allocate<byte>(alphaDataSize);
-                    int bytesRead = this.currentStream.Read(features.AlphaData.Memory.Span, 0, alphaDataSize);
-                    if (bytesRead != alphaDataSize)
-                    {
-                        WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the alpha chunk");
-                    }
-
                     break;
                 default:
                     WebpThrowHelper.ThrowImageFormatException("Unexpected chunk followed VP8X header");
                     break;
             }
+
+            return false;
         }
 
         /// <summary>
-        /// Parses optional metadata chunks. There SHOULD be at most one chunk of each type ('EXIF' and 'XMP ').
+        /// Reads the optional metadata EXIF of XMP profiles, which can follow the image data.
-        /// If there are more such chunks, readers MAY ignore all except the first one.
-        /// Also, a file may possibly contain both 'EXIF' and 'XMP ' chunks.
         /// </summary>
         /// <param name="features">The webp features.</param>
         private void ParseOptionalChunks(WebpFeatures features)
@@ -622,6 +381,53 @@ namespace SixLabors.ImageSharp.Formats.Webp
             }
         }
 
+        /// <summary>
+        /// Reads the animation parameters chunk from the stream.
+        /// </summary>
+        /// <param name="features">The webp features.</param>
+        private void ReadAnimationParameters(WebpFeatures features)
+        {
+            features.Animation = true;
+            uint animationChunkSize = WebpChunkParsingUtils.ReadChunkSize(this.currentStream, this.buffer);
+            byte blue = (byte)this.currentStream.ReadByte();
+            byte green = (byte)this.currentStream.ReadByte();
+            byte red = (byte)this.currentStream.ReadByte();
+            byte alpha = (byte)this.currentStream.ReadByte();
+            features.AnimationBackgroundColor = new Color(new Rgba32(red, green, blue, alpha));
+            int bytesRead = this.currentStream.Read(this.buffer, 0, 2);
+            if (bytesRead != 2)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the animation loop count");
+            }
+
+            features.AnimationLoopCount = BinaryPrimitives.ReadUInt16LittleEndian(this.buffer);
+        }
+
+        /// <summary>
+        /// Reads the alpha data chunk data from the stream.
+        /// </summary>
+        /// <param name="features">The features.</param>
+        /// <param name="ignoreAlpha">if set to true, skips the chunk data.</param>
+        private void ReadAlphaData(WebpFeatures features, bool ignoreAlpha)
+        {
+            uint alphaChunkSize = WebpChunkParsingUtils.ReadChunkSize(this.currentStream, this.buffer);
+            if (ignoreAlpha)
+            {
+                this.currentStream.Skip((int)alphaChunkSize);
+                return;
+            }
+
+            features.AlphaChunkHeader = (byte)this.currentStream.ReadByte();
+            int alphaDataSize = (int)(alphaChunkSize - 1);
+            this.AlphaData = this.memoryAllocator.Allocate<byte>(alphaDataSize);
+            Span<byte> alphaData = this.AlphaData.GetSpan();
+            int bytesRead = this.currentStream.Read(alphaData, 0, alphaDataSize);
+            if (bytesRead != alphaDataSize)
+            {
+                WebpThrowHelper.ThrowInvalidImageContentException("Not enough data to read the alpha data from the stream");
+            }
+        }
+
         /// <summary>
         /// Identifies the chunk type from the chunk.
         /// </summary>
@@ -655,19 +461,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
             throw new ImageFormatException("Invalid Webp data.");
         }
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Determines if the chunk type is an optional VP8X chunk.
+        public void Dispose() => this.AlphaData?.Dispose();
-        /// </summary>
-        /// <param name="chunkType">The chunk type.</param>
-        /// <returns>True, if its an optional chunk type.</returns>
-        private static bool IsOptionalVp8XChunk(WebpChunkType chunkType) => chunkType switch
-        {
-            WebpChunkType.Alpha => true,
-            WebpChunkType.Animation => true,
-            WebpChunkType.Exif => true,
-            WebpChunkType.Iccp => true,
-            WebpChunkType.Xmp => true,
-            _ => false
-        };
     }
 }

src/ImageSharp/Formats/Webp/WebpFeatures.cs

@@ -1,15 +1,12 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
-using System.Buffers;
-
 namespace SixLabors.ImageSharp.Formats.Webp
 {
     /// <summary>
     /// Image features of a VP8X image.
     /// </summary>
-    internal class WebpFeatures : IDisposable
+    internal class WebpFeatures
     {
         /// <summary>
         /// Gets or sets a value indicating whether this image has an ICC Profile.
@@ -21,11 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// </summary>
         public bool Alpha { get; set; }
 
-        /// <summary>
-        /// Gets or sets the alpha data, if an ALPH chunk is present.
-        /// </summary>
-        public IMemoryOwner<byte> AlphaData { get; set; }
-
         /// <summary>
         /// Gets or sets the alpha chunk header.
         /// </summary>
@@ -46,7 +38,15 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// </summary>
         public bool Animation { get; set; }
 
-        /// <inheritdoc/>
+        /// <summary>
-        public void Dispose() => this.AlphaData?.Dispose();
+        /// Gets or sets the animation loop count. 0 means infinitely.
+        /// </summary>
+        public ushort AnimationLoopCount { get; set; }
+
+        /// <summary>
+        /// Gets or sets  default background color of the animation frame canvas.
+        /// This color MAY be used to fill the unused space on the canvas around the frames, as well as the transparent pixels of the first frame..
+        /// </summary>
+        public Color? AnimationBackgroundColor { get; set; }
     }
 }

src/ImageSharp/Formats/Webp/WebpFormat.cs

@@ -6,9 +6,9 @@ using System.Collections.Generic;
 namespace SixLabors.ImageSharp.Formats.Webp
 {
     /// <summary>
-    /// Registers the image encoders, decoders and mime type detectors for the Webp format
+    /// Registers the image encoders, decoders and mime type detectors for the Webp format.
     /// </summary>
-    public sealed class WebpFormat : IImageFormat<WebpMetadata>
+    public sealed class WebpFormat : IImageFormat<WebpMetadata, WebpFrameMetadata>
     {
         private WebpFormat()
         {
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// <summary>
         /// Gets the current instance.
         /// </summary>
-        public static WebpFormat Instance { get; } = new WebpFormat();
+        public static WebpFormat Instance { get; } = new();
 
         /// <inheritdoc/>
         public string Name => "Webp";
@@ -32,6 +32,9 @@ namespace SixLabors.ImageSharp.Formats.Webp
         public IEnumerable<string> FileExtensions => WebpConstants.FileExtensions;
 
         /// <inheritdoc/>
-        public WebpMetadata CreateDefaultFormatMetadata() => new WebpMetadata();
+        public WebpMetadata CreateDefaultFormatMetadata() => new();
+
+        /// <inheritdoc/>
+        public WebpFrameMetadata CreateDefaultFormatFrameMetadata() => new();
     }
 }

src/ImageSharp/Formats/Webp/WebpFrameMetadata.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    /// <summary>
+    /// Provides webp specific metadata information for the image frame.
+    /// </summary>
+    public class WebpFrameMetadata : IDeepCloneable
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WebpFrameMetadata"/> class.
+        /// </summary>
+        public WebpFrameMetadata()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WebpFrameMetadata"/> class.
+        /// </summary>
+        /// <param name="other">The metadata to create an instance from.</param>
+        private WebpFrameMetadata(WebpFrameMetadata other) => this.FrameDuration = other.FrameDuration;
+
+        /// <summary>
+        /// Gets or sets the frame duration. The time to wait before displaying the next frame,
+        /// in 1 millisecond units. Note the interpretation of frame duration of 0 (and often smaller and equal to  10) is implementation defined.
+        /// </summary>
+        public uint FrameDuration { get; set; }
+
+        /// <inheritdoc/>
+        public IDeepCloneable DeepClone() => new WebpFrameMetadata(this);
+    }
+}

src/ImageSharp/Formats/Webp/WebpImageInfo.cs

@@ -63,7 +63,6 @@ namespace SixLabors.ImageSharp.Formats.Webp
         {
             this.Vp8BitReader?.Dispose();
             this.Vp8LBitReader?.Dispose();
-            this.Features?.AlphaData?.Dispose();
         }
     }
 }

src/ImageSharp/Formats/Webp/WebpMetadata.cs

@@ -19,13 +19,22 @@ namespace SixLabors.ImageSharp.Formats.Webp
         /// Initializes a new instance of the <see cref="WebpMetadata"/> class.
         /// </summary>
         /// <param name="other">The metadata to create an instance from.</param>
-        private WebpMetadata(WebpMetadata other) => this.FileFormat = other.FileFormat;
+        private WebpMetadata(WebpMetadata other)
+        {
+            this.FileFormat = other.FileFormat;
+            this.AnimationLoopCount = other.AnimationLoopCount;
+        }
 
         /// <summary>
         /// Gets or sets the webp file format used. Either lossless or lossy.
         /// </summary>
         public WebpFileFormatType? FileFormat { get; set; }
 
+        /// <summary>
+        /// Gets or sets the loop count. The number of times to loop the animation. 0 means infinitely.
+        /// </summary>
+        public ushort AnimationLoopCount { get; set; } = 1;
+
         /// <inheritdoc/>
         public IDeepCloneable DeepClone() => new WebpMetadata(this);
     }

src/ImageSharp/Memory/Buffer2DRegion{T}.cs

@@ -141,6 +141,9 @@ namespace SixLabors.ImageSharp.Memory
             return ref this.Buffer.DangerousGetRowSpan(y)[x];
         }
 
+        /// <summary>
+        /// Clears the contents of this <see cref="Buffer2DRegion{T}"/>.
+        /// </summary>
         internal void Clear()
         {
             // Optimization for when the size of the area is the same as the buffer size.
@@ -156,5 +159,25 @@ namespace SixLabors.ImageSharp.Memory
                 row.Clear();
             }
         }
+
+        /// <summary>
+        /// Fills the elements of this <see cref="Buffer2DRegion{T}"/> with the specified value.
+        /// </summary>
+        /// <param name="value">The value to assign to each element of the region.</param>
+        internal void Fill(T value)
+        {
+            // Optimization for when the size of the area is the same as the buffer size.
+            if (this.IsFullBufferArea)
+            {
+                this.Buffer.FastMemoryGroup.Fill(value);
+                return;
+            }
+
+            for (int y = 0; y < this.Rectangle.Height; y++)
+            {
+                Span<T> row = this.DangerousGetRowSpan(y);
+                row.Fill(value);
+            }
+        }
     }
 }

src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroupExtensions.cs

@@ -7,6 +7,12 @@ namespace SixLabors.ImageSharp.Memory
 {
     internal static class MemoryGroupExtensions
     {
+        /// <summary>
+        /// Fills the elements of this <see cref="IMemoryGroup{T}"/> with the specified value.
+        /// </summary>
+        /// <typeparam name="T">The type of element.</typeparam>
+        /// <param name="group">The group to fill.</param>
+        /// <param name="value">The value to assign to each element of the group.</param>
         internal static void Fill<T>(this IMemoryGroup<T> group, T value)
             where T : struct
         {
@@ -16,6 +22,11 @@ namespace SixLabors.ImageSharp.Memory
             }
         }
 
+        /// <summary>
+        /// Clears the contents of this <see cref="IMemoryGroup{T}"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of element.</typeparam>
+        /// <param name="group">The group to clear.</param>
         internal static void Clear<T>(this IMemoryGroup<T> group)
             where T : struct
         {

src/ImageSharp/Metadata/ImageFrameMetadata.cs

@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Metadata
     /// </summary>
     public sealed class ImageFrameMetadata : IDeepCloneable<ImageFrameMetadata>
     {
-        private readonly Dictionary<IImageFormat, IDeepCloneable> formatMetadata = new Dictionary<IImageFormat, IDeepCloneable>();
+        private readonly Dictionary<IImageFormat, IDeepCloneable> formatMetadata = new();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageFrameMetadata"/> class.
@@ -67,7 +67,7 @@ namespace SixLabors.ImageSharp.Metadata
         public IptcProfile IptcProfile { get; set; }
 
         /// <inheritdoc/>
-        public ImageFrameMetadata DeepClone() => new ImageFrameMetadata(this);
+        public ImageFrameMetadata DeepClone() => new(this);
 
         /// <summary>
         /// Gets the metadata value associated with the specified key.

src/ImageSharp/Metadata/ImageMetadata.cs

@@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Metadata
         /// </summary>
         public const PixelResolutionUnit DefaultPixelResolutionUnits = PixelResolutionUnit.PixelsPerInch;
 
-        private readonly Dictionary<IImageFormat, IDeepCloneable> formatMetadata = new Dictionary<IImageFormat, IDeepCloneable>();
+        private readonly Dictionary<IImageFormat, IDeepCloneable> formatMetadata = new();
         private double horizontalResolution;
         private double verticalResolution;
 

src/ImageSharp/Primitives/Rectangle.cs

@@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp
         public Point Location
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new Point(this.X, this.Y);
+            get => new(this.X, this.Y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             set
@@ -98,7 +98,7 @@ namespace SixLabors.ImageSharp
         public Size Size
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new Size(this.Width, this.Height);
+            get => new(this.Width, this.Height);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             set
@@ -147,14 +147,14 @@ namespace SixLabors.ImageSharp
         /// </summary>
         /// <param name="rectangle">The rectangle.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static implicit operator RectangleF(Rectangle rectangle) => new RectangleF(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+        public static implicit operator RectangleF(Rectangle rectangle) => new(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
 
         /// <summary>
         /// Creates a <see cref="Vector4"/> with the coordinates of the specified <see cref="Rectangle"/>.
         /// </summary>
         /// <param name="rectangle">The rectangle.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static implicit operator Vector4(Rectangle rectangle) => new Vector4(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+        public static implicit operator Vector4(Rectangle rectangle) => new(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
 
         /// <summary>
         /// Compares two <see cref="Rectangle"/> objects for equality.
@@ -188,7 +188,7 @@ namespace SixLabors.ImageSharp
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 
         // ReSharper disable once InconsistentNaming
-        public static Rectangle FromLTRB(int left, int top, int right, int bottom) => new Rectangle(left, top, unchecked(right - left), unchecked(bottom - top));
+        public static Rectangle FromLTRB(int left, int top, int right, int bottom) => new(left, top, unchecked(right - left), unchecked(bottom - top));
 
         /// <summary>
         /// Returns the center point of the given <see cref="Rectangle"/>.
@@ -196,7 +196,7 @@ namespace SixLabors.ImageSharp
         /// <param name="rectangle">The rectangle.</param>
         /// <returns>The <see cref="Point"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Point Center(Rectangle rectangle) => new Point(rectangle.Left + (rectangle.Width / 2), rectangle.Top + (rectangle.Height / 2));
+        public static Point Center(Rectangle rectangle) => new(rectangle.Left + (rectangle.Width / 2), rectangle.Top + (rectangle.Height / 2));
 
         /// <summary>
         /// Creates a rectangle that represents the intersection between <paramref name="a"/> and
@@ -376,7 +376,7 @@ namespace SixLabors.ImageSharp
         public void Inflate(Size size) => this.Inflate(size.Width, size.Height);
 
         /// <summary>
-        /// Determines if the specfied point is contained within the rectangular region defined by
+        /// Determines if the specified point is contained within the rectangular region defined by
         /// this <see cref="Rectangle"/>.
         /// </summary>
         /// <param name="x">The x-coordinate of the given point.</param>
@@ -405,10 +405,10 @@ namespace SixLabors.ImageSharp
             (this.Y <= rectangle.Y) && (rectangle.Bottom <= this.Bottom);
 
         /// <summary>
-        /// Determines if the specfied <see cref="Rectangle"/> intersects the rectangular region defined by
+        /// Determines if the specified <see cref="Rectangle"/> intersects the rectangular region defined by
         /// this <see cref="Rectangle"/>.
         /// </summary>
-        /// <param name="rectangle">The other Rectange. </param>
+        /// <param name="rectangle">The other Rectangle. </param>
         /// <returns>The <see cref="bool"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IntersectsWith(Rectangle rectangle) =>
@@ -438,16 +438,10 @@ namespace SixLabors.ImageSharp
         }
 
         /// <inheritdoc/>
-        public override int GetHashCode()
+        public override int GetHashCode() => HashCode.Combine(this.X, this.Y, this.Width, this.Height);
-        {
-            return HashCode.Combine(this.X, this.Y, this.Width, this.Height);
-        }
 
         /// <inheritdoc/>
-        public override string ToString()
+        public override string ToString() => $"Rectangle [ X={this.X}, Y={this.Y}, Width={this.Width}, Height={this.Height} ]";
-        {
-            return $"Rectangle [ X={this.X}, Y={this.Y}, Width={this.Width}, Height={this.Height} ]";
-        }
 
         /// <inheritdoc/>
         public override bool Equals(object obj) => obj is Rectangle other && this.Equals(other);

tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs

@@ -131,7 +131,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         public void Decode_WithInvalidDimensions_DoesThrowException<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            System.Exception ex = Record.Exception(
+            Exception ex = Record.Exception(
                 () =>
                 {
                     using Image<TPixel> image = provider.GetImage(GifDecoder);

tests/ImageSharp.Tests/Formats/WebP/WebpDecoderTests.cs

@@ -3,8 +3,10 @@
 
 using System.IO;
 using SixLabors.ImageSharp.Formats.Webp;
+using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.TestUtilities;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using SixLabors.ImageSharp.Tests.TestUtilities.ReferenceCodecs;
 using Xunit;
 using static SixLabors.ImageSharp.Tests.TestImages.Webp;
@@ -34,7 +36,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         [InlineData(Lossless.NoTransform2, 128, 128, 32)]
         [InlineData(Lossy.Alpha1, 1000, 307, 32)]
         [InlineData(Lossy.Alpha2, 1000, 307, 32)]
-        [InlineData(Lossy.Bike, 250, 195, 24)]
+        [InlineData(Lossy.BikeWithExif, 250, 195, 24)]
         public void Identify_DetectsCorrectDimensionsAndBitDepth(
             string imagePath,
             int expectedWidth,
@@ -53,7 +55,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         }
 
         [Theory]
-        [WithFile(Lossy.Bike, PixelTypes.Rgba32)]
+        [WithFile(Lossy.BikeWithExif, PixelTypes.Rgba32)]
         [WithFile(Lossy.NoFilter01, PixelTypes.Rgba32)]
         [WithFile(Lossy.NoFilter02, PixelTypes.Rgba32)]
         [WithFile(Lossy.NoFilter03, PixelTypes.Rgba32)]
@@ -234,7 +236,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
 
         // TODO: Reference decoder throws here MagickCorruptImageErrorException, webpinfo also indicates an error here, but decoding the image seems to work.
         // [WithFile(Lossless.GreenTransform5, PixelTypes.Rgba32)]
-        public void WebpDecoder_CanDecode_Lossless_WithSubstractGreenTransform<TPixel>(
+        public void WebpDecoder_CanDecode_Lossless_WithSubtractGreenTransform<TPixel>(
             TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -330,6 +332,55 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
             }
         }
 
+        [Theory]
+        [WithFile(Lossless.Animated, PixelTypes.Rgba32)]
+        public void Decode_AnimatedLossless_VerifyAllFrames<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage(WebpDecoder))
+            {
+                WebpMetadata webpMetaData = image.Metadata.GetWebpMetadata();
+                WebpFrameMetadata frameMetaData = image.Frames.RootFrame.Metadata.GetWebpMetadata();
+
+                image.DebugSaveMultiFrame(provider);
+                image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Exact);
+
+                Assert.Equal(0, webpMetaData.AnimationLoopCount);
+                Assert.Equal(150U, frameMetaData.FrameDuration);
+                Assert.Equal(12, image.Frames.Count);
+            }
+        }
+
+        [Theory]
+        [WithFile(Lossy.Animated, PixelTypes.Rgba32)]
+        public void Decode_AnimatedLossy_VerifyAllFrames<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage(WebpDecoder))
+            {
+                WebpMetadata webpMetaData = image.Metadata.GetWebpMetadata();
+                WebpFrameMetadata frameMetaData = image.Frames.RootFrame.Metadata.GetWebpMetadata();
+
+                image.DebugSaveMultiFrame(provider);
+                image.CompareToReferenceOutputMultiFrame(provider, ImageComparer.Tolerant(0.04f));
+
+                Assert.Equal(0, webpMetaData.AnimationLoopCount);
+                Assert.Equal(150U, frameMetaData.FrameDuration);
+                Assert.Equal(12, image.Frames.Count);
+            }
+        }
+
+        [Theory]
+        [WithFile(Lossless.Animated, PixelTypes.Rgba32)]
+        public void Decode_AnimatedLossless_WithFrameDecodingModeFirst_OnlyDecodesOneFrame<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage(new WebpDecoder() { DecodingMode = FrameDecodingMode.First }))
+            {
+                Assert.Equal(1, image.Frames.Count);
+            }
+        }
+
         [Theory]
         [WithFile(Lossless.LossLessCorruptImage1, PixelTypes.Rgba32)]
         [WithFile(Lossless.LossLessCorruptImage2, PixelTypes.Rgba32)]

tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs

@@ -20,7 +20,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         [Theory]
         [WithFile(Flag, PixelTypes.Rgba32, WebpFileFormatType.Lossy)] // If its not a webp input image, it should default to lossy.
         [WithFile(Lossless.NoTransform1, PixelTypes.Rgba32, WebpFileFormatType.Lossless)]
-        [WithFile(Lossy.Bike, PixelTypes.Rgba32, WebpFileFormatType.Lossy)]
+        [WithFile(Lossy.BikeWithExif, PixelTypes.Rgba32, WebpFileFormatType.Lossy)]
         public void Encode_PreserveRatio<TPixel>(TestImageProvider<TPixel> provider, WebpFileFormatType expectedFormat)
             where TPixel : unmanaged, IPixel<TPixel>
         {

tests/ImageSharp.Tests/Formats/WebP/WebpMetaDataTests.cs

@@ -18,11 +18,31 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         private static WebpDecoder WebpDecoder => new() { IgnoreMetadata = false };
 
         [Theory]
-        [WithFile(TestImages.Webp.Lossy.WithExif, PixelTypes.Rgba32, false)]
+        [WithFile(TestImages.Webp.Lossy.BikeWithExif, PixelTypes.Rgba32, false)]
-        [WithFile(TestImages.Webp.Lossy.WithExif, PixelTypes.Rgba32, true)]
+        [WithFile(TestImages.Webp.Lossy.BikeWithExif, PixelTypes.Rgba32, true)]
+        public void IgnoreMetadata_ControlsWhetherExifIsParsed_WithLossyImage<TPixel>(TestImageProvider<TPixel> provider, bool ignoreMetadata)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            var decoder = new WebpDecoder { IgnoreMetadata = ignoreMetadata };
+
+            using Image<TPixel> image = provider.GetImage(decoder);
+            if (ignoreMetadata)
+            {
+                Assert.Null(image.Metadata.ExifProfile);
+            }
+            else
+            {
+                ExifProfile exifProfile = image.Metadata.ExifProfile;
+                Assert.NotNull(exifProfile);
+                Assert.NotEmpty(exifProfile.Values);
+                Assert.Contains(exifProfile.Values, m => m.Tag.Equals(ExifTag.Software) && m.GetValue().Equals("GIMP 2.10.2"));
+            }
+        }
+
+        [Theory]
         [WithFile(TestImages.Webp.Lossless.WithExif, PixelTypes.Rgba32, false)]
         [WithFile(TestImages.Webp.Lossless.WithExif, PixelTypes.Rgba32, true)]
-        public void IgnoreMetadata_ControlsWhetherExifIsParsed<TPixel>(TestImageProvider<TPixel> provider, bool ignoreMetadata)
+        public void IgnoreMetadata_ControlsWhetherExifIsParsed_WithLosslessImage<TPixel>(TestImageProvider<TPixel> provider, bool ignoreMetadata)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var decoder = new WebpDecoder { IgnoreMetadata = ignoreMetadata };
@@ -111,7 +131,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         }
 
         [Theory]
-        [WithFile(TestImages.Webp.Lossy.WithExif, PixelTypes.Rgba32)]
+        [WithFile(TestImages.Webp.Lossy.BikeWithExif, PixelTypes.Rgba32)]
         public void EncodeLossyWebp_PreservesExif<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {

tests/ImageSharp.Tests/MemoryAllocatorValidator.cs

@@ -59,9 +59,9 @@ namespace SixLabors.ImageSharp.Tests
 
             public void Validate(int expectedAllocationCount)
             {
-                var count = this.TotalRemainingAllocated;
+                int count = this.TotalRemainingAllocated;
-                var pass = expectedAllocationCount == count;
+                bool pass = expectedAllocationCount == count;
-                Assert.True(pass, $"Expected a {expectedAllocationCount} undisposed buffers but found {count}");
+                Assert.True(pass, $"Expected {expectedAllocationCount} undisposed buffers but found {count}");
             }
 
             public void Dispose()

tests/ImageSharp.Tests/TestImages.cs

@@ -562,16 +562,9 @@ namespace SixLabors.ImageSharp.Tests
             // Test images for converting rgb data to yuv.
             public const string Yuv = "Webp/yuv_test.png";
 
-            public static class Animated
-            {
-                public const string Animated1 = "Webp/animated-webp.webp";
-                public const string Animated2 = "Webp/animated2.webp";
-                public const string Animated3 = "Webp/animated3.webp";
-                public const string Animated4 = "Webp/animated_lossy.webp";
-            }
-
             public static class Lossless
             {
+                public const string Animated = "Webp/leo_animated_lossless.webp";
                 public const string Earth = "Webp/earth_lossless.webp";
                 public const string Alpha = "Webp/lossless_alpha_small.webp";
                 public const string WithExif = "Webp/exif_lossless.webp";
@@ -648,10 +641,11 @@ namespace SixLabors.ImageSharp.Tests
                 public const string WithExifNotEnoughData = "Webp/exif_lossy_not_enough_data.webp";
                 public const string WithIccp = "Webp/lossy_with_iccp.webp";
                 public const string WithXmp = "Webp/xmp_lossy.webp";
-                public const string BikeSmall = "Webp/bike_lossless_small.webp";
+                public const string BikeSmall = "Webp/bike_lossy_small.webp";
+                public const string Animated = "Webp/leo_animated_lossy.webp";
 
                 // Lossy images without macroblock filtering.
-                public const string Bike = "Webp/bike_lossy.webp";
+                public const string BikeWithExif = "Webp/bike_lossy_with_exif.webp";
                 public const string NoFilter01 = "Webp/vp80-01-intra-1400.webp";
                 public const string NoFilter02 = "Webp/vp80-00-comprehensive-010.webp";
                 public const string NoFilter03 = "Webp/vp80-00-comprehensive-005.webp";

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/00.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d99914f1a4dc3e554b9dded9e547194685b1b9ecc5d816d9f329cef483c525d5
+size 50298

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/01.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:391ed80dc5ba4a21bdc4ea4db9fde4c6dad8556d1b8f0bf198db3c2bb5dc50ad
+size 49389

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/02.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84bf215392014c2d7dbeb495bd1717bc2da4566b285bc388ed7bc8e88ebb0e85
+size 52686

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/03.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e7a47ba473440f699f337fb8886cd170c6610452b3145c068a0f18584541559
+size 53244

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/04.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4e7572c91c73e63e74c795e16ce951fbbdba5a015921102844d7bdf0fb0b473
+size 56046

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/05.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6681af3640adb85452f9c1fa0cb5dce04638b48d80994c20c40d11e07670f1de
+size 62469

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/06.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8549aeb786fc12d4e947b3b5f862701fab8158576193a03877f4b891815077e0
+size 61068

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/07.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:474a6bbf07604de5a412d1eed2d3ba6ce191a85b88464c5848a50bef42566de5
+size 60411

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/08.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f296bbd4b5637d1583ea337e8b807b34613640e0eabfb5e13e4e6cefe8ae2527
+size 58793

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/09.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b16c16f9663b5ba80fa2ef06503851009b15700ff257375bd41cdb362098a391
+size 57157

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/10.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5c39781b77219a6e9c05233d2376dfde04bd0dbe39f63274168073abf7a0e4d
+size 55424

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossless_VerifyAllFrames_Rgba32_leo_animated_lossless.webp/11.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5133dc9a5f8f6d26d388f40fd1df3a262f489d80a0d1eed588f7662bef7523de
+size 59950

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/00.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d99914f1a4dc3e554b9dded9e547194685b1b9ecc5d816d9f329cef483c525d5
+size 50298

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/01.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:391ed80dc5ba4a21bdc4ea4db9fde4c6dad8556d1b8f0bf198db3c2bb5dc50ad
+size 49389

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/02.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84bf215392014c2d7dbeb495bd1717bc2da4566b285bc388ed7bc8e88ebb0e85
+size 52686

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/03.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e7a47ba473440f699f337fb8886cd170c6610452b3145c068a0f18584541559
+size 53244

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/04.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4e7572c91c73e63e74c795e16ce951fbbdba5a015921102844d7bdf0fb0b473
+size 56046

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/05.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6681af3640adb85452f9c1fa0cb5dce04638b48d80994c20c40d11e07670f1de
+size 62469

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/06.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8549aeb786fc12d4e947b3b5f862701fab8158576193a03877f4b891815077e0
+size 61068

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/07.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:474a6bbf07604de5a412d1eed2d3ba6ce191a85b88464c5848a50bef42566de5
+size 60411

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/08.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f296bbd4b5637d1583ea337e8b807b34613640e0eabfb5e13e4e6cefe8ae2527
+size 58793

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/09.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b16c16f9663b5ba80fa2ef06503851009b15700ff257375bd41cdb362098a391
+size 57157

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/10.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5c39781b77219a6e9c05233d2376dfde04bd0dbe39f63274168073abf7a0e4d
+size 55424

tests/Images/External/ReferenceOutput/WebpDecoderTests/Decode_AnimatedLossy_VerifyAllFrames_Rgba32_leo_animated_lossy.webp/11.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5133dc9a5f8f6d26d388f40fd1df3a262f489d80a0d1eed588f7662bef7523de
+size 59950

tests/Images/Input/Webp/leo_animated_lossless.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bab815db08e8f413c7a355b7e9c152e1a73e503392012af16ada92858706d255
+size 400342

tests/Images/Input/Webp/leo_animated_lossy.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00fffbb0d67b0336574d9bad9cbacaf97d81f2e70db3d458508c430e3d103228
+size 64972