From 96c1c725f94dcb8d5882c22af68c3f46a9d5582e Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Sun, 30 Jan 2022 18:41:56 +0100
Subject: [PATCH 1/8] Write ALPH chunk (only uncompressed for now)

---
 src/ImageSharp/Formats/Webp/AlphaEncoder.cs   | 42 ++++++++++++++++++
 .../Formats/Webp/BitWriter/BitWriterBase.cs   | 43 ++++++++++++++++++-
 .../Formats/Webp/BitWriter/Vp8BitWriter.cs    | 35 ++++++++++++---
 .../Formats/Webp/Lossy/Vp8Encoder.cs          | 13 ++++--
 .../Formats/Webp/Lossy/YuvConversion.cs       | 11 ++++-
 5 files changed, 133 insertions(+), 11 deletions(-)
 create mode 100644 src/ImageSharp/Formats/Webp/AlphaEncoder.cs

diff --git a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
new file mode 100644
index 0000000000..06c114c71f
--- /dev/null
+++ b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Webp
+{
+    /// <summary>
+    /// Encodes the alpha channel data.
+    /// Data is either compressed as lossless webp image or uncompressed.
+    /// </summary>
+    internal static class AlphaEncoder
+    {
+        public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            Buffer2D<TPixel> imageBuffer = image.Frames.RootFrame.PixelBuffer;
+            int height = image.Height;
+            int width = image.Width;
+            byte[] alphaData = new byte[width * height];
+
+            using IMemoryOwner<Rgba32> rowBuffer = memoryAllocator.Allocate<Rgba32>(width);
+            Span<Rgba32> rgbaRow = rowBuffer.GetSpan();
+
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> rowSpan = imageBuffer.DangerousGetRowSpan(y);
+                PixelOperations<TPixel>.Instance.ToRgba32(configuration, rowSpan, rgbaRow);
+                int offset = y * width;
+                for (int x = 0; x < width; x++)
+                {
+                    alphaData[offset + x] = rgbaRow[x].A;
+                }
+            }
+
+            return alphaData;
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
index ac039be797..b33f7987c1 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
@@ -94,7 +94,7 @@ protected void WriteRiffHeader(Stream stream, uint riffSize)
         /// Calculates the chunk size of EXIF or XMP metadata.
         /// </summary>
         /// <param name="metadataBytes">The metadata profile bytes.</param>
-        /// <returns>The exif chunk size in bytes.</returns>
+        /// <returns>The metadata chunk size in bytes.</returns>
         protected uint MetadataChunkSize(byte[] metadataBytes)
         {
             uint metaSize = (uint)metadataBytes.Length;
@@ -103,6 +103,19 @@ protected uint MetadataChunkSize(byte[] metadataBytes)
             return metaChunkSize;
         }
 
+        /// <summary>
+        /// Calculates the chunk size of a alpha chunk.
+        /// </summary>
+        /// <param name="alphaBytes">The alpha chunk bytes.</param>
+        /// <returns>The alpha data chunk size in bytes.</returns>
+        protected uint AlphaChunkSize(byte[] alphaBytes)
+        {
+            uint alphaSize = (uint)alphaBytes.Length + 1;
+            uint alphaChunkSize = WebpConstants.ChunkHeaderSize + alphaSize + (alphaSize & 1);
+
+            return alphaChunkSize;
+        }
+
         /// <summary>
         /// Writes a metadata profile (EXIF or XMP) to the stream.
         /// </summary>
@@ -128,6 +141,34 @@ protected void WriteMetadataProfile(Stream stream, byte[] metadataBytes, WebpChu
             }
         }
 
+        /// <summary>
+        /// Writes the alpha chunk to the stream.
+        /// </summary>
+        /// <param name="stream">The stream to write to.</param>
+        /// <param name="dataBytes">The alpha channel data bytes.</param>
+        protected void WriteAlphaChunk(Stream stream, byte[] dataBytes)
+        {
+            DebugGuard.NotNull(dataBytes, nameof(dataBytes));
+
+            uint size = (uint)dataBytes.Length + 1;
+            Span<byte> buf = this.scratchBuffer.AsSpan(0, 4);
+            BinaryPrimitives.WriteUInt32BigEndian(buf, (uint)WebpChunkType.Alpha);
+            stream.Write(buf);
+            BinaryPrimitives.WriteUInt32LittleEndian(buf, size);
+            stream.Write(buf);
+
+            // Write flags, all zero for now.
+            stream.WriteByte(0);
+
+            stream.Write(dataBytes);
+
+            // Add padding byte if needed.
+            if ((size & 1) == 1)
+            {
+                stream.WriteByte(0);
+            }
+        }
+
         /// <summary>
         /// Writes a VP8X header to the stream.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
index 4e91bedb0b..3f16fc89bc 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
@@ -409,7 +409,8 @@ private void Flush()
         /// <param name="width">The width of the image.</param>
         /// <param name="height">The height of the image.</param>
         /// <param name="hasAlpha">Flag indicating, if a alpha channel is present.</param>
-        public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, XmpProfile xmpProfile, uint width, uint height, bool hasAlpha)
+        /// <param name="alphaData">The alpha channel data.</param>
+        public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, XmpProfile xmpProfile, uint width, uint height, bool hasAlpha, byte[] alphaData)
         {
             bool isVp8X = false;
             byte[] exifBytes = null;
@@ -418,7 +419,6 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, Xm
             if (exifProfile != null)
             {
                 isVp8X = true;
-                riffSize += ExtendedFileChunkSize;
                 exifBytes = exifProfile.ToByteArray();
                 riffSize += this.MetadataChunkSize(exifBytes);
             }
@@ -426,11 +426,21 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, Xm
             if (xmpProfile != null)
             {
                 isVp8X = true;
-                riffSize += ExtendedFileChunkSize;
                 xmpBytes = xmpProfile.Data;
                 riffSize += this.MetadataChunkSize(xmpBytes);
             }
 
+            if (hasAlpha)
+            {
+                isVp8X = true;
+                riffSize += this.AlphaChunkSize(alphaData);
+            }
+
+            if (isVp8X)
+            {
+                riffSize += ExtendedFileChunkSize;
+            }
+
             this.Finish();
             uint numBytes = (uint)this.NumBytes();
             int mbSize = this.enc.Mbw * this.enc.Mbh;
@@ -451,7 +461,7 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, Xm
             riffSize += WebpConstants.TagSize + WebpConstants.ChunkHeaderSize + vp8Size;
 
             // Emit headers and partition #0
-            this.WriteWebpHeaders(stream, size0, vp8Size, riffSize, isVp8X, width, height, exifProfile, xmpProfile, hasAlpha);
+            this.WriteWebpHeaders(stream, size0, vp8Size, riffSize, isVp8X, width, height, exifProfile, xmpProfile, hasAlpha, alphaData);
             bitWriterPartZero.WriteToStream(stream);
 
             // Write the encoded image to the stream.
@@ -639,7 +649,18 @@ private void CodeIntraModes(Vp8BitWriter bitWriter)
             while (it.Next());
         }
 
-        private void WriteWebpHeaders(Stream stream, uint size0, uint vp8Size, uint riffSize, bool isVp8X, uint width, uint height, ExifProfile exifProfile, XmpProfile xmpProfile, bool hasAlpha)
+        private void WriteWebpHeaders(
+            Stream stream,
+            uint size0,
+            uint vp8Size,
+            uint riffSize,
+            bool isVp8X,
+            uint width,
+            uint height,
+            ExifProfile exifProfile,
+            XmpProfile xmpProfile,
+            bool hasAlpha,
+            byte[] alphaData)
         {
             this.WriteRiffHeader(stream, riffSize);
 
@@ -647,6 +668,10 @@ private void WriteWebpHeaders(Stream stream, uint size0, uint vp8Size, uint riff
             if (isVp8X)
             {
                 this.WriteVp8XHeader(stream, exifProfile, xmpProfile, width, height, hasAlpha);
+                if (hasAlpha)
+                {
+                    this.WriteAlphaChunk(stream, alphaData);
+                }
             }
 
             this.WriteVp8Header(stream, vp8Size);
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 0222320502..48af53960c 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -300,7 +300,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             Span<byte> y = this.Y.GetSpan();
             Span<byte> u = this.U.GetSpan();
             Span<byte> v = this.V.GetSpan();
-            YuvConversion.ConvertRgbToYuv(image, this.configuration, this.memoryAllocator, y, u, v);
+            bool hasAlpha = YuvConversion.ConvertRgbToYuv(image, this.configuration, this.memoryAllocator, y, u, v);
 
             int yStride = width;
             int uvStride = (yStride + 1) >> 1;
@@ -322,8 +322,13 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             int expectedSize = this.Mbw * this.Mbh * averageBytesPerMacroBlock;
             this.bitWriter = new Vp8BitWriter(expectedSize, this);
 
-            // TODO: EncodeAlpha();
-            bool hasAlpha = false;
+            // Extract and encode alpha data, if present.
+            byte[] alphaData = null;
+            if (hasAlpha)
+            {
+                // TODO: This can potentially run in an separate task.
+                alphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator);
+            }
 
             // Stats-collection loop.
             this.StatLoop(width, height, yStride, uvStride);
@@ -358,7 +363,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             // Write bytes from the bitwriter buffer to the stream.
             ImageMetadata metadata = image.Metadata;
             metadata.SyncProfiles();
-            this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha);
+            this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha, alphaData);
         }
 
         /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs b/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
index 7a731f4284..878bebd105 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/YuvConversion.cs
@@ -318,7 +318,8 @@ private static void PackAndStore(Vector128<byte> a, Vector128<byte> b, Vector128
         /// <param name="y">Span to store the luma component of the image.</param>
         /// <param name="u">Span to store the u component of the image.</param>
         /// <param name="v">Span to store the v component of the image.</param>
-        public static void ConvertRgbToYuv<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, Span<byte> y, Span<byte> u, Span<byte> v)
+        /// <returns>true, if the image contains alpha data.</returns>
+        public static bool ConvertRgbToYuv<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, Span<byte> y, Span<byte> u, Span<byte> v)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Buffer2D<TPixel> imageBuffer = image.Frames.RootFrame.PixelBuffer;
@@ -335,6 +336,7 @@ public static void ConvertRgbToYuv<TPixel>(Image<TPixel> image, Configuration co
             Span<Bgra32> bgraRow1 = bgraRow1Buffer.GetSpan();
             int uvRowIndex = 0;
             int rowIndex;
+            bool hasAlpha = false;
             for (rowIndex = 0; rowIndex < height - 1; rowIndex += 2)
             {
                 Span<TPixel> rowSpan = imageBuffer.DangerousGetRowSpan(rowIndex);
@@ -343,6 +345,10 @@ public static void ConvertRgbToYuv<TPixel>(Image<TPixel> image, Configuration co
                 PixelOperations<TPixel>.Instance.ToBgra32(configuration, nextRowSpan, bgraRow1);
 
                 bool rowsHaveAlpha = WebpCommonUtils.CheckNonOpaque(bgraRow0) && WebpCommonUtils.CheckNonOpaque(bgraRow1);
+                if (rowsHaveAlpha)
+                {
+                    hasAlpha = true;
+                }
 
                 // Downsample U/V planes, two rows at a time.
                 if (!rowsHaveAlpha)
@@ -375,10 +381,13 @@ public static void ConvertRgbToYuv<TPixel>(Image<TPixel> image, Configuration co
                 else
                 {
                     AccumulateRgba(bgraRow0, bgraRow0, tmpRgbSpan, width);
+                    hasAlpha = true;
                 }
 
                 ConvertRgbaToUv(tmpRgbSpan, u.Slice(uvRowIndex * uvWidth), v.Slice(uvRowIndex * uvWidth), uvWidth);
             }
+
+            return hasAlpha;
         }
 
         /// <summary>

From d1929412289d3c8bb5bc3974cc47e0b811f0e75f Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 10:23:08 +0100
Subject: [PATCH 2/8] Add lossless alpha compression

---
 src/ImageSharp/Formats/Webp/AlphaEncoder.cs   | 86 ++++++++++++++++++-
 .../Formats/Webp/BitWriter/BitWriterBase.cs   | 11 ++-
 .../Formats/Webp/BitWriter/Vp8BitWriter.cs    | 10 ++-
 .../Formats/Webp/Lossless/Vp8LEncoder.cs      | 31 ++++++-
 .../Formats/Webp/Lossy/Vp8Encoder.cs          | 14 +--
 .../Formats/Webp/WebpEncoderCore.cs           |  6 +-
 6 files changed, 134 insertions(+), 24 deletions(-)

diff --git a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
index 06c114c71f..571da5bb24 100644
--- a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
@@ -3,18 +3,98 @@
 
 using System;
 using System.Buffers;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Formats.Webp.Lossless;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp
 {
     /// <summary>
-    /// Encodes the alpha channel data.
-    /// Data is either compressed as lossless webp image or uncompressed.
+    /// Methods for encoding the alpha data of a VP8 image.
     /// </summary>
     internal static class AlphaEncoder
     {
-        public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator)
+        /// <summary>
+        /// Encodes the alpha channel data.
+        /// Data is either compressed as lossless webp image or uncompressed.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
+        /// <param name="configuration">The global configuration.</param>
+        /// <param name="memoryAllocator">The memory manager.</param>
+        /// <param name="compress">Indicates, if the data should be compressed with the lossless webp compression.</param>
+        /// <returns>The alpha data.</returns>
+        public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, bool compress)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            byte[] alphaData = ExtractAlphaChannel(image, configuration, memoryAllocator);
+            int width = image.Width;
+            int height = image.Height;
+            if (compress)
+            {
+                WebpEncodingMethod effort = WebpEncodingMethod.Default;
+                int quality = 8 * (int)effort;
+                using var lossLessEncoder = new Vp8LEncoder(
+                    memoryAllocator,
+                    configuration,
+                    width,
+                    height,
+                    quality,
+                    effort,
+                    WebpTransparentColorMode.Preserve,
+                    false,
+                    0);
+
+                // The transparency information will be stored in the green channel of the ARGB quadruplet.
+                // The green channel is allowed extra transformation steps in the specification -- unlike the other channels,
+                // that can improve compression.
+                using Image<Rgba32> alphaAsImage = DispatchAlphaToGreen(image, alphaData);
+
+                return lossLessEncoder.EncodeAlphaImageData(alphaAsImage);
+            }
+
+            return alphaData;
+        }
+
+        /// <summary>
+        /// Store the transparency in the green channel.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
+        /// <param name="alphaData">A byte sequence of length width * height, containing all the 8-bit transparency values in scan order.</param>
+        /// <returns>The transparency image.</returns>
+        private static Image<Rgba32> DispatchAlphaToGreen<TPixel>(Image<TPixel> image, byte[] alphaData)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int width = image.Width;
+            int height = image.Height;
+            var alphaAsImage = new Image<Rgba32>(width, height);
+
+            for (int y = 0; y < height; y++)
+            {
+                Memory<Rgba32> rowBuffer = alphaAsImage.DangerousGetPixelRowMemory(y);
+                Span<Rgba32> pixelRow = rowBuffer.Span;
+                Span<byte> alphaRow = alphaData.AsSpan(y * width, width);
+                for (int x = 0; x < width; x++)
+                {
+                    // Leave A/R/B channels zero'd.
+                    pixelRow[x] = new Rgba32(0, alphaRow[x], 0, 0);
+                }
+            }
+
+            return alphaAsImage;
+        }
+
+        /// <summary>
+        /// Extract the alpha data of the image.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
+        /// <param name="configuration">The global configuration.</param>
+        /// <param name="memoryAllocator">The memory manager.</param>
+        /// <returns>A byte sequence of length width * height, containing all the 8-bit transparency values in scan order.</returns>
+        private static byte[] ExtractAlphaChannel<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Buffer2D<TPixel> imageBuffer = image.Frames.RootFrame.PixelBuffer;
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
index b33f7987c1..84c9d3f133 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
@@ -146,7 +146,8 @@ protected void WriteMetadataProfile(Stream stream, byte[] metadataBytes, WebpChu
         /// </summary>
         /// <param name="stream">The stream to write to.</param>
         /// <param name="dataBytes">The alpha channel data bytes.</param>
-        protected void WriteAlphaChunk(Stream stream, byte[] dataBytes)
+        /// <param name="alphaDataIsCompressed">Indicates, if the alpha channel data is compressed.</param>
+        protected void WriteAlphaChunk(Stream stream, byte[] dataBytes, bool alphaDataIsCompressed)
         {
             DebugGuard.NotNull(dataBytes, nameof(dataBytes));
 
@@ -157,9 +158,13 @@ protected void WriteAlphaChunk(Stream stream, byte[] dataBytes)
             BinaryPrimitives.WriteUInt32LittleEndian(buf, size);
             stream.Write(buf);
 
-            // Write flags, all zero for now.
-            stream.WriteByte(0);
+            byte flags = 0;
+            if (alphaDataIsCompressed)
+            {
+                flags |= 1;
+            }
 
+            stream.WriteByte(flags);
             stream.Write(dataBytes);
 
             // Add padding byte if needed.
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
index 3f16fc89bc..577a87e6a1 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
@@ -410,7 +410,8 @@ private void Flush()
         /// <param name="height">The height of the image.</param>
         /// <param name="hasAlpha">Flag indicating, if a alpha channel is present.</param>
         /// <param name="alphaData">The alpha channel data.</param>
-        public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, XmpProfile xmpProfile, uint width, uint height, bool hasAlpha, byte[] alphaData)
+        /// <param name="alphaDataIsCompressed">Indicates, if the alpha data is compressed.</param>
+        public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, XmpProfile xmpProfile, uint width, uint height, bool hasAlpha, byte[] alphaData, bool alphaDataIsCompressed)
         {
             bool isVp8X = false;
             byte[] exifBytes = null;
@@ -461,7 +462,7 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, Xm
             riffSize += WebpConstants.TagSize + WebpConstants.ChunkHeaderSize + vp8Size;
 
             // Emit headers and partition #0
-            this.WriteWebpHeaders(stream, size0, vp8Size, riffSize, isVp8X, width, height, exifProfile, xmpProfile, hasAlpha, alphaData);
+            this.WriteWebpHeaders(stream, size0, vp8Size, riffSize, isVp8X, width, height, exifProfile, xmpProfile, hasAlpha, alphaData, alphaDataIsCompressed);
             bitWriterPartZero.WriteToStream(stream);
 
             // Write the encoded image to the stream.
@@ -660,7 +661,8 @@ private void WriteWebpHeaders(
             ExifProfile exifProfile,
             XmpProfile xmpProfile,
             bool hasAlpha,
-            byte[] alphaData)
+            byte[] alphaData,
+            bool alphaDataIsCompressed)
         {
             this.WriteRiffHeader(stream, riffSize);
 
@@ -670,7 +672,7 @@ private void WriteWebpHeaders(
                 this.WriteVp8XHeader(stream, exifProfile, xmpProfile, width, height, hasAlpha);
                 if (hasAlpha)
                 {
-                    this.WriteAlphaChunk(stream, alphaData);
+                    this.WriteAlphaChunk(stream, alphaData, alphaDataIsCompressed);
                 }
             }
 
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
index e9dce913a3..797d0794f9 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
@@ -228,7 +228,7 @@ public Vp8LEncoder(
         public Vp8LHashChain HashChain { get; }
 
         /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
+        /// Encodes the image as lossless webp to the specified stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
@@ -236,10 +236,12 @@ public Vp8LEncoder(
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            image.Metadata.SyncProfiles();
             int width = image.Width;
             int height = image.Height;
 
+            ImageMetadata metadata = image.Metadata;
+            metadata.SyncProfiles();
+
             // Convert image pixels to bgra array.
             bool hasAlpha = this.ConvertPixelsToBgra(image, width, height);
 
@@ -253,11 +255,32 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             this.EncodeStream(image);
 
             // Write bytes from the bitwriter buffer to the stream.
-            ImageMetadata metadata = image.Metadata;
-            metadata.SyncProfiles();
             this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha);
         }
 
+        /// <summary>
+        /// Encodes the alpha image data using the webp lossless compression.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+        /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
+        /// <returns>The encoded alpha stream.</returns>
+        public byte[] EncodeAlphaImageData<TPixel>(Image<TPixel> image)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            int width = image.Width;
+            int height = image.Height;
+
+            // Convert image pixels to bgra array.
+            this.ConvertPixelsToBgra(image, width, height);
+
+            // The image-stream does NOT contain any headers describing the image dimension, the dimension is already known.
+            this.EncodeStream(image);
+            this.bitWriter.Finish();
+            using var ms = new MemoryStream();
+            this.bitWriter.WriteToStream(ms);
+            return ms.ToArray();
+        }
+
         /// <summary>
         /// Writes the image size to the bitwriter buffer.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 48af53960c..d8bd8f759c 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -71,10 +71,7 @@ internal class Vp8Encoder : IDisposable
         /// </summary>
         private int uvAlpha;
 
-        /// <summary>
-        /// Scratch buffer to reduce allocations.
-        /// </summary>
-        private readonly int[] scratch = new int[16];
+        private readonly bool alphaCompression;
 
         private readonly byte[] averageBytesPerMb = { 50, 24, 16, 9, 7, 5, 3, 2 };
 
@@ -105,6 +102,7 @@ internal class Vp8Encoder : IDisposable
         /// <param name="entropyPasses">Number of entropy-analysis passes (in [1..10]).</param>
         /// <param name="filterStrength">The filter the strength of the deblocking filter, between 0 (no filtering) and 100 (maximum filtering).</param>
         /// <param name="spatialNoiseShaping">The spatial noise shaping. 0=off, 100=maximum.</param>
+        /// <param name="alphaCompression">If true, the alpha channel will be compressed with the lossless compression.</param>
         public Vp8Encoder(
             MemoryAllocator memoryAllocator,
             Configuration configuration,
@@ -114,7 +112,8 @@ public Vp8Encoder(
             WebpEncodingMethod method,
             int entropyPasses,
             int filterStrength,
-            int spatialNoiseShaping)
+            int spatialNoiseShaping,
+            bool alphaCompression)
         {
             this.memoryAllocator = memoryAllocator;
             this.configuration = configuration;
@@ -125,6 +124,7 @@ public Vp8Encoder(
             this.entropyPasses = Numerics.Clamp(entropyPasses, 1, 10);
             this.filterStrength = Numerics.Clamp(filterStrength, 0, 100);
             this.spatialNoiseShaping = Numerics.Clamp(spatialNoiseShaping, 0, 100);
+            this.alphaCompression = alphaCompression;
             this.rdOptLevel = method is WebpEncodingMethod.BestQuality ? Vp8RdLevel.RdOptTrellisAll
                 : method >= WebpEncodingMethod.Level5 ? Vp8RdLevel.RdOptTrellis
                 : method >= WebpEncodingMethod.Level3 ? Vp8RdLevel.RdOptBasic
@@ -327,7 +327,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             if (hasAlpha)
             {
                 // TODO: This can potentially run in an separate task.
-                alphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator);
+                alphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression);
             }
 
             // Stats-collection loop.
@@ -363,7 +363,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             // Write bytes from the bitwriter buffer to the stream.
             ImageMetadata metadata = image.Metadata;
             metadata.SyncProfiles();
-            this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha, alphaData);
+            this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha, alphaData, this.alphaCompression);
         }
 
         /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
index 195fa62bdc..deed08b729 100644
--- a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
@@ -22,7 +22,6 @@ internal sealed class WebpEncoderCore : IImageEncoderInternals
         private readonly MemoryAllocator memoryAllocator;
 
         /// <summary>
-        /// TODO: not used at the moment.
         /// Indicating whether the alpha plane should be compressed with Webp lossless format.
         /// </summary>
         private readonly bool alphaCompression;
@@ -100,7 +99,7 @@ public WebpEncoderCore(IWebpEncoderOptions options, MemoryAllocator memoryAlloca
         }
 
         /// <summary>
-        /// Encodes the image to the specified stream from the <see cref="ImageFrame{TPixel}"/>.
+        /// Encodes the image as webp to the specified stream.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
@@ -149,7 +148,8 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                     this.method,
                     this.entropyPasses,
                     this.filterStrength,
-                    this.spatialNoiseShaping);
+                    this.spatialNoiseShaping,
+                    this.alphaCompression);
                 enc.Encode(image, stream);
             }
         }

From 8b8993dadc37a8a7970d4bcf26b1f043b860df60 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 11:19:40 +0100
Subject: [PATCH 3/8] Add encode lossy webp with alpha tests

---
 .../Formats/WebP/WebpEncoderTests.cs          | 40 +++++++++++++------
 tests/ImageSharp.Tests/TestImages.cs          |  1 +
 tests/Images/Input/Png/transparency.png       |  3 ++
 3 files changed, 32 insertions(+), 12 deletions(-)
 create mode 100644 tests/Images/Input/Png/transparency.png

diff --git a/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
index 7043549b22..7c74429edc 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/WebpEncoderTests.cs
@@ -167,18 +167,6 @@ public void Encode_Lossless_WithPreserveTransparentColor_Works<TPixel>(TestImage
             image.VerifyEncoder(provider, "webp", testOutputDetails, encoder);
         }
 
-        [Theory]
-        [WithFile(TestPatternOpaque, PixelTypes.Rgba32)]
-        [WithFile(TestPatternOpaqueSmall, PixelTypes.Rgba32)]
-        public void Encode_Lossless_WorksWithTestPattern<TPixel>(TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            using Image<TPixel> image = provider.GetImage();
-
-            var encoder = new WebpEncoder() { FileFormat = WebpFileFormatType.Lossless };
-            image.VerifyEncoder(provider, "webp", string.Empty, encoder);
-        }
-
         [Fact]
         public void Encode_Lossless_OneByOnePixel_Works()
         {
@@ -279,6 +267,34 @@ public void Encode_Lossy_WithDifferentMethodsAndQuality_Works<TPixel>(TestImageP
             image.VerifyEncoder(provider, "webp", testOutputDetails, encoder, customComparer: GetComparer(quality));
         }
 
+        [Theory]
+        [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, false)]
+        [WithFile(TestImages.Png.Transparency, PixelTypes.Rgba32, true)]
+        public void Encode_Lossy_WithAlpha_Works<TPixel>(TestImageProvider<TPixel> provider, bool compressed)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            var encoder = new WebpEncoder()
+            {
+                FileFormat = WebpFileFormatType.Lossy,
+                UseAlphaCompression = compressed
+            };
+
+            using Image<TPixel> image = provider.GetImage();
+            image.VerifyEncoder(provider, "webp", $"with_alpha_compressed_{compressed}", encoder, ImageComparer.Tolerant(0.04f));
+        }
+
+        [Theory]
+        [WithFile(TestPatternOpaque, PixelTypes.Rgba32)]
+        [WithFile(TestPatternOpaqueSmall, PixelTypes.Rgba32)]
+        public void Encode_Lossless_WorksWithTestPattern<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            using Image<TPixel> image = provider.GetImage();
+
+            var encoder = new WebpEncoder() { FileFormat = WebpFileFormatType.Lossless };
+            image.VerifyEncoder(provider, "webp", string.Empty, encoder);
+        }
+
         [Theory]
         [WithFile(TestPatternOpaque, PixelTypes.Rgba32)]
         [WithFile(TestPatternOpaqueSmall, PixelTypes.Rgba32)]
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index bce22799da..a73d262433 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -15,6 +15,7 @@ public static class TestImages
     {
         public static class Png
         {
+            public const string Transparency = "Png/transparency.png";
             public const string P1 = "Png/pl.png";
             public const string Pd = "Png/pd.png";
             public const string Blur = "Png/blur.png";
diff --git a/tests/Images/Input/Png/transparency.png b/tests/Images/Input/Png/transparency.png
new file mode 100644
index 0000000000..26de0f2d1a
--- /dev/null
+++ b/tests/Images/Input/Png/transparency.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:843bea4db378f52935e2f19f60d289df8ebe20ddde3977c63225f1d58a10bd62
+size 48119

From d398ae744555d87cf71da22a02ed8fb50127ff00 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 11:25:03 +0100
Subject: [PATCH 4/8] Default alpha compression to true

---
 src/ImageSharp/Formats/Webp/IWebpEncoderOptions.cs | 1 +
 src/ImageSharp/Formats/Webp/WebpEncoder.cs         | 2 +-
 src/ImageSharp/Formats/Webp/WebpEncoderCore.cs     | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/ImageSharp/Formats/Webp/IWebpEncoderOptions.cs b/src/ImageSharp/Formats/Webp/IWebpEncoderOptions.cs
index d119d3031f..57ec32753d 100644
--- a/src/ImageSharp/Formats/Webp/IWebpEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Webp/IWebpEncoderOptions.cs
@@ -31,6 +31,7 @@ internal interface IWebpEncoderOptions
 
         /// <summary>
         /// Gets a value indicating whether the alpha plane should be compressed with Webp lossless format.
+        /// Defaults to true.
         /// </summary>
         bool UseAlphaCompression { get; }
 
diff --git a/src/ImageSharp/Formats/Webp/WebpEncoder.cs b/src/ImageSharp/Formats/Webp/WebpEncoder.cs
index bdcbb194b1..d0b60d18cd 100644
--- a/src/ImageSharp/Formats/Webp/WebpEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/WebpEncoder.cs
@@ -24,7 +24,7 @@ public sealed class WebpEncoder : IImageEncoder, IWebpEncoderOptions
         public WebpEncodingMethod Method { get; set; } = WebpEncodingMethod.Default;
 
         /// <inheritdoc/>
-        public bool UseAlphaCompression { get; set; }
+        public bool UseAlphaCompression { get; set; } = true;
 
         /// <inheritdoc/>
         public int EntropyPasses { get; set; } = 1;
diff --git a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
index deed08b729..0fbff81fe4 100644
--- a/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpEncoderCore.cs
@@ -23,6 +23,7 @@ internal sealed class WebpEncoderCore : IImageEncoderInternals
 
         /// <summary>
         /// Indicating whether the alpha plane should be compressed with Webp lossless format.
+        /// Defaults to true.
         /// </summary>
         private readonly bool alphaCompression;
 

From cf672b99aeaa80d734edfa0a7ca0e2e36b590526 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 12:10:19 +0100
Subject: [PATCH 5/8] Use memory allocator for alpha data

---
 src/ImageSharp/Formats/Webp/AlphaEncoder.cs   | 26 ++++++++++++-------
 .../Formats/Webp/BitWriter/BitWriterBase.cs   | 12 ++++++---
 .../Formats/Webp/BitWriter/Vp8BitWriter.cs    | 12 +++++++--
 .../Formats/Webp/Lossless/Vp8LEncoder.cs      | 13 +++++-----
 .../Formats/Webp/Lossy/Vp8Encoder.cs          | 22 +++++++++++++---
 5 files changed, 59 insertions(+), 26 deletions(-)

diff --git a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
index 571da5bb24..38497281ff 100644
--- a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
@@ -24,13 +24,15 @@ internal static class AlphaEncoder
         /// <param name="configuration">The global configuration.</param>
         /// <param name="memoryAllocator">The memory manager.</param>
         /// <param name="compress">Indicates, if the data should be compressed with the lossless webp compression.</param>
-        /// <returns>The alpha data.</returns>
-        public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, bool compress)
+        /// <param name="size">The size in bytes of the alpha data.</param>
+        /// <returns>The encoded alpha data.</returns>
+        public static IMemoryOwner<byte> EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, bool compress, out int size)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            byte[] alphaData = ExtractAlphaChannel(image, configuration, memoryAllocator);
             int width = image.Width;
             int height = image.Height;
+            IMemoryOwner<byte> alphaData = ExtractAlphaChannel(image, configuration, memoryAllocator);
+
             if (compress)
             {
                 WebpEncodingMethod effort = WebpEncodingMethod.Default;
@@ -49,11 +51,14 @@ public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration conf
                 // The transparency information will be stored in the green channel of the ARGB quadruplet.
                 // The green channel is allowed extra transformation steps in the specification -- unlike the other channels,
                 // that can improve compression.
-                using Image<Rgba32> alphaAsImage = DispatchAlphaToGreen(image, alphaData);
+                using Image<Rgba32> alphaAsImage = DispatchAlphaToGreen(image, alphaData.GetSpan());
+
+                size = lossLessEncoder.EncodeAlphaImageData(alphaAsImage, alphaData);
 
-                return lossLessEncoder.EncodeAlphaImageData(alphaAsImage);
+                return alphaData;
             }
 
+            size = width * height;
             return alphaData;
         }
 
@@ -64,7 +69,7 @@ public static byte[] EncodeAlpha<TPixel>(Image<TPixel> image, Configuration conf
         /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to encode from.</param>
         /// <param name="alphaData">A byte sequence of length width * height, containing all the 8-bit transparency values in scan order.</param>
         /// <returns>The transparency image.</returns>
-        private static Image<Rgba32> DispatchAlphaToGreen<TPixel>(Image<TPixel> image, byte[] alphaData)
+        private static Image<Rgba32> DispatchAlphaToGreen<TPixel>(Image<TPixel> image, Span<byte> alphaData)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = image.Width;
@@ -75,7 +80,7 @@ private static Image<Rgba32> DispatchAlphaToGreen<TPixel>(Image<TPixel> image, b
             {
                 Memory<Rgba32> rowBuffer = alphaAsImage.DangerousGetPixelRowMemory(y);
                 Span<Rgba32> pixelRow = rowBuffer.Span;
-                Span<byte> alphaRow = alphaData.AsSpan(y * width, width);
+                Span<byte> alphaRow = alphaData.Slice(y * width, width);
                 for (int x = 0; x < width; x++)
                 {
                     // Leave A/R/B channels zero'd.
@@ -94,13 +99,14 @@ private static Image<Rgba32> DispatchAlphaToGreen<TPixel>(Image<TPixel> image, b
         /// <param name="configuration">The global configuration.</param>
         /// <param name="memoryAllocator">The memory manager.</param>
         /// <returns>A byte sequence of length width * height, containing all the 8-bit transparency values in scan order.</returns>
-        private static byte[] ExtractAlphaChannel<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator)
+        private static IMemoryOwner<byte> ExtractAlphaChannel<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             Buffer2D<TPixel> imageBuffer = image.Frames.RootFrame.PixelBuffer;
             int height = image.Height;
             int width = image.Width;
-            byte[] alphaData = new byte[width * height];
+            IMemoryOwner<byte> alphaDataBuffer = memoryAllocator.Allocate<byte>(width * height);
+            Span<byte> alphaData = alphaDataBuffer.GetSpan();
 
             using IMemoryOwner<Rgba32> rowBuffer = memoryAllocator.Allocate<Rgba32>(width);
             Span<Rgba32> rgbaRow = rowBuffer.GetSpan();
@@ -116,7 +122,7 @@ private static byte[] ExtractAlphaChannel<TPixel>(Image<TPixel> image, Configura
                 }
             }
 
-            return alphaData;
+            return alphaDataBuffer;
         }
     }
 }
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
index 84c9d3f133..fc1accfdee 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
@@ -47,6 +47,12 @@ internal abstract class BitWriterBase
         /// <param name="stream">The stream to write to.</param>
         public void WriteToStream(Stream stream) => stream.Write(this.Buffer.AsSpan(0, this.NumBytes()));
 
+        /// <summary>
+        /// Writes the encoded bytes of the image to the given buffer. Call Finish() before this.
+        /// </summary>
+        /// <param name="dest">The destination buffer.</param>
+        public void WriteToBuffer(Span<byte> dest) => this.Buffer.AsSpan(0, this.NumBytes()).CopyTo(dest);
+
         /// <summary>
         /// Resizes the buffer to write to.
         /// </summary>
@@ -108,7 +114,7 @@ protected uint MetadataChunkSize(byte[] metadataBytes)
         /// </summary>
         /// <param name="alphaBytes">The alpha chunk bytes.</param>
         /// <returns>The alpha data chunk size in bytes.</returns>
-        protected uint AlphaChunkSize(byte[] alphaBytes)
+        protected uint AlphaChunkSize(Span<byte> alphaBytes)
         {
             uint alphaSize = (uint)alphaBytes.Length + 1;
             uint alphaChunkSize = WebpConstants.ChunkHeaderSize + alphaSize + (alphaSize & 1);
@@ -147,10 +153,8 @@ protected void WriteMetadataProfile(Stream stream, byte[] metadataBytes, WebpChu
         /// <param name="stream">The stream to write to.</param>
         /// <param name="dataBytes">The alpha channel data bytes.</param>
         /// <param name="alphaDataIsCompressed">Indicates, if the alpha channel data is compressed.</param>
-        protected void WriteAlphaChunk(Stream stream, byte[] dataBytes, bool alphaDataIsCompressed)
+        protected void WriteAlphaChunk(Stream stream, Span<byte> dataBytes, bool alphaDataIsCompressed)
         {
-            DebugGuard.NotNull(dataBytes, nameof(dataBytes));
-
             uint size = (uint)dataBytes.Length + 1;
             Span<byte> buf = this.scratchBuffer.AsSpan(0, 4);
             BinaryPrimitives.WriteUInt32BigEndian(buf, (uint)WebpChunkType.Alpha);
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
index 577a87e6a1..fa6e09d875 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs
@@ -411,7 +411,15 @@ private void Flush()
         /// <param name="hasAlpha">Flag indicating, if a alpha channel is present.</param>
         /// <param name="alphaData">The alpha channel data.</param>
         /// <param name="alphaDataIsCompressed">Indicates, if the alpha data is compressed.</param>
-        public void WriteEncodedImageToStream(Stream stream, ExifProfile exifProfile, XmpProfile xmpProfile, uint width, uint height, bool hasAlpha, byte[] alphaData, bool alphaDataIsCompressed)
+        public void WriteEncodedImageToStream(
+            Stream stream,
+            ExifProfile exifProfile,
+            XmpProfile xmpProfile,
+            uint width,
+            uint height,
+            bool hasAlpha,
+            Span<byte> alphaData,
+            bool alphaDataIsCompressed)
         {
             bool isVp8X = false;
             byte[] exifBytes = null;
@@ -661,7 +669,7 @@ private void WriteWebpHeaders(
             ExifProfile exifProfile,
             XmpProfile xmpProfile,
             bool hasAlpha,
-            byte[] alphaData,
+            Span<byte> alphaData,
             bool alphaDataIsCompressed)
         {
             this.WriteRiffHeader(stream, riffSize);
diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
index 797d0794f9..ece9aefd0f 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
@@ -263,8 +263,9 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
         /// </summary>
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
-        /// <returns>The encoded alpha stream.</returns>
-        public byte[] EncodeAlphaImageData<TPixel>(Image<TPixel> image)
+        /// <param name="alphaData">The destination buffer to write the encoded alpha data to.</param>
+        /// <returns>The size of the data in bytes.</returns>
+        public int EncodeAlphaImageData<TPixel>(Image<TPixel> image, IMemoryOwner<byte> alphaData)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = image.Width;
@@ -273,12 +274,12 @@ public byte[] EncodeAlphaImageData<TPixel>(Image<TPixel> image)
             // Convert image pixels to bgra array.
             this.ConvertPixelsToBgra(image, width, height);
 
-            // The image-stream does NOT contain any headers describing the image dimension, the dimension is already known.
+            // The image-stream will NOT contain any headers describing the image dimension, the dimension is already known.
             this.EncodeStream(image);
             this.bitWriter.Finish();
-            using var ms = new MemoryStream();
-            this.bitWriter.WriteToStream(ms);
-            return ms.ToArray();
+            int size = this.bitWriter.NumBytes();
+            this.bitWriter.WriteToBuffer(alphaData.GetSpan());
+            return size;
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index d8bd8f759c..4b7f3f5c88 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -241,6 +241,11 @@ public Vp8Encoder(
 
         public int DqUvDc { get; private set; }
 
+        /// <summary>
+        /// Gets or sets the alpha data.
+        /// </summary>
+        private IMemoryOwner<byte> AlphaData { get; set; }
+
         /// <summary>
         /// Gets the luma component.
         /// </summary>
@@ -322,12 +327,12 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             int expectedSize = this.Mbw * this.Mbh * averageBytesPerMacroBlock;
             this.bitWriter = new Vp8BitWriter(expectedSize, this);
 
-            // Extract and encode alpha data, if present.
-            byte[] alphaData = null;
+            // Extract and encode alpha channel data, if present.
+            int alphaDataSize = 0;
             if (hasAlpha)
             {
                 // TODO: This can potentially run in an separate task.
-                alphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression);
+                this.AlphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression, out alphaDataSize);
             }
 
             // Stats-collection loop.
@@ -363,7 +368,15 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             // Write bytes from the bitwriter buffer to the stream.
             ImageMetadata metadata = image.Metadata;
             metadata.SyncProfiles();
-            this.bitWriter.WriteEncodedImageToStream(stream, metadata.ExifProfile, metadata.XmpProfile, (uint)width, (uint)height, hasAlpha, alphaData, this.alphaCompression);
+            this.bitWriter.WriteEncodedImageToStream(
+                stream,
+                metadata.ExifProfile,
+                metadata.XmpProfile,
+                (uint)width,
+                (uint)height,
+                hasAlpha,
+                hasAlpha ? this.AlphaData.GetSpan().Slice(0, alphaDataSize) : Span<byte>.Empty,
+                this.alphaCompression);
         }
 
         /// <inheritdoc/>
@@ -372,6 +385,7 @@ public void Dispose()
             this.Y.Dispose();
             this.U.Dispose();
             this.V.Dispose();
+            this.AlphaData?.Dispose();
         }
 
         /// <summary>

From b12ad7596e3e1b5c91d87332f167afe340f65226 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 12:50:28 +0100
Subject: [PATCH 6/8] Leave alpha data uncompressed, if compression does not
 yield in smaller data

---
 src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs | 11 ++++++++++-
 src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs     |  9 ++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
index ece9aefd0f..30d65562ae 100644
--- a/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossless/Vp8LEncoder.cs
@@ -264,12 +264,15 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
         /// <typeparam name="TPixel">The type of the pixel.</typeparam>
         /// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
         /// <param name="alphaData">The destination buffer to write the encoded alpha data to.</param>
-        /// <returns>The size of the data in bytes.</returns>
+        /// <returns>The size of the compressed data in bytes.
+        /// If the size of the data is the same as the pixel count, the compression would not yield in smaller data and is left uncompressed.
+        /// </returns>
         public int EncodeAlphaImageData<TPixel>(Image<TPixel> image, IMemoryOwner<byte> alphaData)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = image.Width;
             int height = image.Height;
+            int pixelCount = width * height;
 
             // Convert image pixels to bgra array.
             this.ConvertPixelsToBgra(image, width, height);
@@ -278,6 +281,12 @@ public int EncodeAlphaImageData<TPixel>(Image<TPixel> image, IMemoryOwner<byte>
             this.EncodeStream(image);
             this.bitWriter.Finish();
             int size = this.bitWriter.NumBytes();
+            if (size >= pixelCount)
+            {
+                // Compressing would not yield in smaller data -> leave the data uncompressed.
+                return pixelCount;
+            }
+
             this.bitWriter.WriteToBuffer(alphaData.GetSpan());
             return size;
         }
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 4b7f3f5c88..60bdee362c 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -302,6 +302,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
         {
             int width = image.Width;
             int height = image.Height;
+            int pixelCount = width * height;
             Span<byte> y = this.Y.GetSpan();
             Span<byte> u = this.U.GetSpan();
             Span<byte> v = this.V.GetSpan();
@@ -329,10 +330,16 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
 
             // Extract and encode alpha channel data, if present.
             int alphaDataSize = 0;
+            bool alphaCompressionSucceeded = false;
             if (hasAlpha)
             {
                 // TODO: This can potentially run in an separate task.
                 this.AlphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression, out alphaDataSize);
+                if (alphaDataSize < pixelCount)
+                {
+                    // Only use compressed data, if the compressed data is actually smaller then the uncompressed data.
+                    alphaCompressionSucceeded = true;
+                }
             }
 
             // Stats-collection loop.
@@ -376,7 +383,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 (uint)height,
                 hasAlpha,
                 hasAlpha ? this.AlphaData.GetSpan().Slice(0, alphaDataSize) : Span<byte>.Empty,
-                this.alphaCompression);
+                this.alphaCompression && alphaCompressionSucceeded);
         }
 
         /// <inheritdoc/>

From 192cfb03f9a35282eb62f99aa42c3bae91869181 Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 13:33:04 +0100
Subject: [PATCH 7/8] Move disposing the alpha data to the AlphaEncoder

---
 src/ImageSharp/Formats/Webp/AlphaEncoder.cs   | 19 ++++++++++++-------
 .../Formats/Webp/Lossy/Vp8Encoder.cs          | 13 +++++--------
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
index 38497281ff..1019073d87 100644
--- a/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
+++ b/src/ImageSharp/Formats/Webp/AlphaEncoder.cs
@@ -13,8 +13,10 @@ namespace SixLabors.ImageSharp.Formats.Webp
     /// <summary>
     /// Methods for encoding the alpha data of a VP8 image.
     /// </summary>
-    internal static class AlphaEncoder
+    internal class AlphaEncoder : IDisposable
     {
+        private IMemoryOwner<byte> alphaData;
+
         /// <summary>
         /// Encodes the alpha channel data.
         /// Data is either compressed as lossless webp image or uncompressed.
@@ -26,12 +28,12 @@ internal static class AlphaEncoder
         /// <param name="compress">Indicates, if the data should be compressed with the lossless webp compression.</param>
         /// <param name="size">The size in bytes of the alpha data.</param>
         /// <returns>The encoded alpha data.</returns>
-        public static IMemoryOwner<byte> EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, bool compress, out int size)
+        public IMemoryOwner<byte> EncodeAlpha<TPixel>(Image<TPixel> image, Configuration configuration, MemoryAllocator memoryAllocator, bool compress, out int size)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             int width = image.Width;
             int height = image.Height;
-            IMemoryOwner<byte> alphaData = ExtractAlphaChannel(image, configuration, memoryAllocator);
+            this.alphaData = ExtractAlphaChannel(image, configuration, memoryAllocator);
 
             if (compress)
             {
@@ -51,15 +53,15 @@ public static IMemoryOwner<byte> EncodeAlpha<TPixel>(Image<TPixel> image, Config
                 // The transparency information will be stored in the green channel of the ARGB quadruplet.
                 // The green channel is allowed extra transformation steps in the specification -- unlike the other channels,
                 // that can improve compression.
-                using Image<Rgba32> alphaAsImage = DispatchAlphaToGreen(image, alphaData.GetSpan());
+                using Image<Rgba32> alphaAsImage = DispatchAlphaToGreen(image, this.alphaData.GetSpan());
 
-                size = lossLessEncoder.EncodeAlphaImageData(alphaAsImage, alphaData);
+                size = lossLessEncoder.EncodeAlphaImageData(alphaAsImage, this.alphaData);
 
-                return alphaData;
+                return this.alphaData;
             }
 
             size = width * height;
-            return alphaData;
+            return this.alphaData;
         }
 
         /// <summary>
@@ -124,5 +126,8 @@ private static IMemoryOwner<byte> ExtractAlphaChannel<TPixel>(Image<TPixel> imag
 
             return alphaDataBuffer;
         }
+
+        /// <inheritdoc/>
+        public void Dispose() => this.alphaData?.Dispose();
     }
 }
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 60bdee362c..927b04c0cf 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -241,11 +241,6 @@ public Vp8Encoder(
 
         public int DqUvDc { get; private set; }
 
-        /// <summary>
-        /// Gets or sets the alpha data.
-        /// </summary>
-        private IMemoryOwner<byte> AlphaData { get; set; }
-
         /// <summary>
         /// Gets the luma component.
         /// </summary>
@@ -331,10 +326,13 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             // Extract and encode alpha channel data, if present.
             int alphaDataSize = 0;
             bool alphaCompressionSucceeded = false;
+            using var alphaEncoder = new AlphaEncoder();
+            Span<byte> alphaData = Span<byte>.Empty;
             if (hasAlpha)
             {
                 // TODO: This can potentially run in an separate task.
-                this.AlphaData = AlphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression, out alphaDataSize);
+                IMemoryOwner<byte> encodedAlphaData = alphaEncoder.EncodeAlpha(image, this.configuration, this.memoryAllocator, this.alphaCompression, out alphaDataSize);
+                alphaData = encodedAlphaData.GetSpan();
                 if (alphaDataSize < pixelCount)
                 {
                     // Only use compressed data, if the compressed data is actually smaller then the uncompressed data.
@@ -382,7 +380,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
                 (uint)width,
                 (uint)height,
                 hasAlpha,
-                hasAlpha ? this.AlphaData.GetSpan().Slice(0, alphaDataSize) : Span<byte>.Empty,
+                alphaData,
                 this.alphaCompression && alphaCompressionSucceeded);
         }
 
@@ -392,7 +390,6 @@ public void Dispose()
             this.Y.Dispose();
             this.U.Dispose();
             this.V.Dispose();
-            this.AlphaData?.Dispose();
         }
 
         /// <summary>

From 2491b6ab626f4329a40b9363e4058d5857d8567d Mon Sep 17 00:00:00 2001
From: Brian Popow <popow@gmx.de>
Date: Tue, 1 Feb 2022 16:16:35 +0100
Subject: [PATCH 8/8] Change AverageBytesPerMb to ReadOnlySpan<byte>

---
 src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
index 927b04c0cf..695359e5ea 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8Encoder.cs
@@ -73,8 +73,6 @@ internal class Vp8Encoder : IDisposable
 
         private readonly bool alphaCompression;
 
-        private readonly byte[] averageBytesPerMb = { 50, 24, 16, 9, 7, 5, 3, 2 };
-
         private const int NumMbSegments = 4;
 
         private const int MaxItersKMeans = 6;
@@ -174,6 +172,9 @@ public Vp8Encoder(
             this.ResetBoundaryPredictions();
         }
 
+        // This uses C#'s optimization to refer to the static data segment of the assembly, no allocation occurs.
+        private static ReadOnlySpan<byte> AverageBytesPerMb => new byte[] { 50, 24, 16, 9, 7, 5, 3, 2 };
+
         public int BaseQuant { get; set; }
 
         /// <summary>
@@ -319,7 +320,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             this.SetLoopParams(this.quality);
 
             // Initialize the bitwriter.
-            int averageBytesPerMacroBlock = this.averageBytesPerMb[this.BaseQuant >> 4];
+            int averageBytesPerMacroBlock = AverageBytesPerMb[this.BaseQuant >> 4];
             int expectedSize = this.Mbw * this.Mbh * averageBytesPerMacroBlock;
             this.bitWriter = new Vp8BitWriter(expectedSize, this);