Add span-based Deflate, ZLib and GZip encoder/decoder APIs

src/libraries/Common/src/Interop/Interop.zlib.cs

@@ -37,5 +37,8 @@ internal static unsafe partial ZLibNative.ErrorCode DeflateInit2_(
 
         [LibraryImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_Crc32")]
         internal static unsafe partial uint crc32(uint crc, byte* buffer, int len);
+
+        [LibraryImport(Libraries.CompressionNative, EntryPoint = "CompressionNative_CompressBound")]
+        internal static partial uint compressBound(uint sourceLen);
     }
 }

src/libraries/Common/src/System/IO/Compression/ZLibNative.cs

@@ -108,6 +108,41 @@ public enum CompressionMethod : int
         /// </summary>
         public const int GZip_DefaultWindowBits = 31;
 
+        /// <summary>
+        /// The minimum value for the base-2 logarithm of the history buffer (window) size.
+        /// A value of 8 corresponds to a 256-byte window.
+        /// </summary>
+        public const int MinWindowLog = 8;
+
+        /// <summary>
+        /// The maximum value for the base-2 logarithm of the history buffer (window) size.
+        /// A value of 15 corresponds to a 32KB window, which provides the best compression ratio.
+        /// </summary>
+        public const int MaxWindowLog = 15;
+
+        /// <summary>
+        /// The default value for the base-2 logarithm of the history buffer (window) size.
+        /// Defaults to <see cref="MaxWindowLog"/> (15) for optimal compression.
+        /// </summary>
+        public const int DefaultWindowLog = MaxWindowLog;
+
+        /// <summary>
+        /// The minimum compression quality level. A value of 0 means no compression (store only).
+        /// </summary>
+        public const int MinQuality = 0;
+
+        /// <summary>
+        /// The maximum compression quality level. A value of 9 provides the best compression ratio
+        /// but is the slowest.
+        /// </summary>
+        public const int MaxQuality = 9;
+
+        /// <summary>
+        /// The default compression quality level. A value of 6 provides a good balance between
+        /// compression ratio and speed.
+        /// </summary>
+        public const int DefaultQuality = 6;
+
         /// <summary>
         /// <para><strong>From the ZLib manual:</strong><br />
         /// The <c>memLevel</c> parameter specifies how much memory should be allocated for the internal compression state.

src/libraries/Common/tests/System/IO/Compression/CompressionStreamUnitTestBase.cs

@@ -812,6 +812,36 @@ private async Task TestStreamRewindsOnlyOnce(bool useAsync)
             }
         }
 
+        [Theory]
+        [InlineData(8)]
+        [InlineData(10)]
+        [InlineData(15)]
+        [InlineData(-1)]
+        public void RoundTrip_WithWindowLog(int windowLog)
+        {
+            byte[] input = new byte[1024];
+            Random.Shared.NextBytes(input);
+
+            var options = new ZLibCompressionOptions
+            {
+                CompressionLevel = 6,
+                WindowLog = windowLog
+            };
+
+            using var compressed = new MemoryStream();
+            using (var compressor = CreateStream(compressed, options, leaveOpen: true))
+            {
+                compressor.Write(input);
+            }
+
+            compressed.Position = 0;
+            using var decompressor = CreateStream(compressed, CompressionMode.Decompress);
+            using var decompressed = new MemoryStream();
+            decompressor.CopyTo(decompressed);
+
+            Assert.Equal(input, decompressed.ToArray());
+        }
+
     }
 
     public enum TestScenario

src/libraries/Common/tests/System/IO/Compression/EncoderDecoderTestBase.cs

@@ -24,6 +24,10 @@ public abstract class EncoderDecoderTestBase
 
         protected abstract int ValidQuality { get; }
         protected abstract int ValidWindowLog { get; }
+        protected abstract int MinQuality { get; }
+        protected abstract int MaxQuality { get; }
+        protected abstract int MinWindowLog { get; }
+        protected abstract int MaxWindowLog { get; }
         protected abstract int InvalidQualityTooLow { get; }
         protected abstract int InvalidQualityTooHigh { get; }
         protected abstract int InvalidWindowLogTooLow { get; }
@@ -262,20 +266,14 @@ public void TryDecompress_WithEmptyDestination_ReturnsFalse()
             Assert.Equal(0, bytesWritten);
         }
 
-        [Theory]
-        [MemberData(nameof(BooleanTestData))]
-        public void TryDecompress_RandomData_ReturnsFalse(bool useDictionary)
+        [Fact]
+        public void TryDecompress_InvalidData_ReturnsFalse()
         {
-            if (useDictionary && !SupportsDictionaries)
-                return;
-
+            // 0xFF is an invalid first byte for all supported compression formats.
             Span<byte> source = new byte[100];
+            source.Fill(0xFF);
             Span<byte> destination = new byte[5 * source.Length];
 
-            // deterministic random data that should not match any valid compressed format
-            Random rng = new Random(42);
-            rng.NextBytes(source);
-
             Assert.False(TryDecompress(source, destination, out int bytesWritten), "TryDecompress completed successfully but should have failed");
             Assert.Equal(0, bytesWritten);
         }
@@ -664,6 +662,56 @@ public void RoundTrip_Chunks()
             }
         }
 
+        [Fact]
+        public void RoundTrip_AllCompressionLevels()
+        {
+            byte[] input = CreateTestData();
+
+            for (int quality = MinQuality; quality <= MaxQuality; quality++)
+            {
+                byte[] compressed = new byte[GetMaxCompressedLength(input.Length)];
+                using var encoder = CreateEncoder(quality, ValidWindowLog);
+                OperationStatus compressStatus = encoder.Compress(input, compressed, out int bytesConsumed, out int compressedSize, isFinalBlock: true);
+
+                Assert.Equal(OperationStatus.Done, compressStatus);
+                Assert.Equal(input.Length, bytesConsumed);
+
+                byte[] decompressed = new byte[input.Length];
+                using var decoder = CreateDecoder();
+                OperationStatus decompressStatus = decoder.Decompress(compressed.AsSpan(0, compressedSize), decompressed, out int decompressConsumed, out int decompressWritten);
+
+                Assert.Equal(OperationStatus.Done, decompressStatus);
+                Assert.Equal(compressedSize, decompressConsumed);
+                Assert.Equal(input.Length, decompressWritten);
+                Assert.Equal(input, decompressed);
+            }
+        }
+
+        [Fact]
+        public void RoundTrip_AllWindowLogs()
+        {
+            byte[] input = CreateTestData();
+
+            for (int windowLog = MinWindowLog; windowLog <= MaxWindowLog; windowLog++)
+            {
+                byte[] compressed = new byte[GetMaxCompressedLength(input.Length)];
+                using var encoder = CreateEncoder(ValidQuality, windowLog);
+                OperationStatus compressStatus = encoder.Compress(input, compressed, out int bytesConsumed, out int compressedSize, isFinalBlock: true);
+
+                Assert.Equal(OperationStatus.Done, compressStatus);
+                Assert.Equal(input.Length, bytesConsumed);
+
+                byte[] decompressed = new byte[input.Length];
+                using var decoder = CreateDecoder();
+                OperationStatus decompressStatus = decoder.Decompress(compressed.AsSpan(0, compressedSize), decompressed, out int decompressConsumed, out int decompressWritten);
+
+                Assert.Equal(OperationStatus.Done, decompressStatus);
+                Assert.Equal(compressedSize, decompressConsumed);
+                Assert.Equal(input.Length, decompressWritten);
+                Assert.Equal(input, decompressed);
+            }
+        }
+
         public static byte[] CreateTestData(int size = 1000)
         {
             // Create test data of specified size

src/libraries/System.IO.Compression.Brotli/tests/BrotliEncoderDecoderTests.cs

@@ -18,7 +18,10 @@ public class BrotliEncoderDecoderTests : EncoderDecoderTestBase
 
         protected override int ValidQuality => 3;
         protected override int ValidWindowLog => 10;
-
+        protected override int MinQuality => 0;
+        protected override int MaxQuality => 11;
+        protected override int MinWindowLog => 10;
+        protected override int MaxWindowLog => 24;
         protected override int InvalidQualityTooLow => -1;
         protected override int InvalidQualityTooHigh => 12;
         protected override int InvalidWindowLogTooLow => 9;

src/libraries/System.IO.Compression/ref/System.IO.Compression.cs

@@ -18,6 +18,27 @@ public enum CompressionMode
         Decompress = 0,
         Compress = 1,
     }
+    public sealed partial class DeflateDecoder : System.IDisposable
+    {
+        public DeflateDecoder() { }
+        public System.Buffers.OperationStatus Decompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten) { throw null; }
+        public void Dispose() { }
+        public static bool TryDecompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public sealed partial class DeflateEncoder : System.IDisposable
+    {
+        public DeflateEncoder() { }
+        public DeflateEncoder(int quality) { }
+        public DeflateEncoder(int quality, int windowLog) { }
+        public DeflateEncoder(System.IO.Compression.ZLibCompressionOptions options) { }
+        public System.Buffers.OperationStatus Compress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) { throw null; }
+        public void Dispose() { }
+        public System.Buffers.OperationStatus Flush(System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static long GetMaxCompressedLength(long inputLength) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality, int windowLog) { throw null; }
+    }
     public partial class DeflateStream : System.IO.Stream
     {
         public DeflateStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel) { }
@@ -54,6 +75,27 @@ public override void Write(System.ReadOnlySpan<byte> buffer) { }
         public override System.Threading.Tasks.ValueTask WriteAsync(System.ReadOnlyMemory<byte> buffer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public override void WriteByte(byte value) { }
     }
+    public sealed partial class GZipDecoder : System.IDisposable
+    {
+        public GZipDecoder() { }
+        public System.Buffers.OperationStatus Decompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten) { throw null; }
+        public void Dispose() { }
+        public static bool TryDecompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public sealed partial class GZipEncoder : System.IDisposable
+    {
+        public GZipEncoder() { }
+        public GZipEncoder(int quality) { }
+        public GZipEncoder(int quality, int windowLog) { }
+        public GZipEncoder(System.IO.Compression.ZLibCompressionOptions options) { }
+        public System.Buffers.OperationStatus Compress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) { throw null; }
+        public void Dispose() { }
+        public System.Buffers.OperationStatus Flush(System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static long GetMaxCompressedLength(long inputLength) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality, int windowLog) { throw null; }
+    }
     public partial class GZipStream : System.IO.Stream
     {
         public GZipStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel) { }
@@ -146,9 +188,13 @@ public enum ZipCompressionMethod
     }
     public sealed partial class ZLibCompressionOptions
     {
+        public static int DefaultWindowLog { get { throw null; } }
+        public static int MaxWindowLog { get { throw null; } }
+        public static int MinWindowLog { get { throw null; } }
         public ZLibCompressionOptions() { }
         public int CompressionLevel { get { throw null; } set { } }
         public System.IO.Compression.ZLibCompressionStrategy CompressionStrategy { get { throw null; } set { } }
+        public int WindowLog { get { throw null; } set { } }
     }
     public enum ZLibCompressionStrategy
     {
@@ -158,6 +204,27 @@ public enum ZLibCompressionStrategy
         RunLengthEncoding = 3,
         Fixed = 4,
     }
+    public sealed partial class ZLibDecoder : System.IDisposable
+    {
+        public ZLibDecoder() { }
+        public System.Buffers.OperationStatus Decompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten) { throw null; }
+        public void Dispose() { }
+        public static bool TryDecompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+    }
+    public sealed partial class ZLibEncoder : System.IDisposable
+    {
+        public ZLibEncoder() { }
+        public ZLibEncoder(int quality) { }
+        public ZLibEncoder(int quality, int windowLog) { }
+        public ZLibEncoder(System.IO.Compression.ZLibCompressionOptions options) { }
+        public System.Buffers.OperationStatus Compress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) { throw null; }
+        public void Dispose() { }
+        public System.Buffers.OperationStatus Flush(System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static long GetMaxCompressedLength(long inputLength) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality) { throw null; }
+        public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality, int windowLog) { throw null; }
+    }
     public sealed partial class ZLibStream : System.IO.Stream
     {
         public ZLibStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel) { }

src/libraries/System.IO.Compression/src/System.IO.Compression.csproj

@@ -47,12 +47,19 @@
           Link="Common\System\IO\Compression\ZLibNative.CompressionLevel.cs" />
     <Compile Include="$(CommonPath)System\IO\Compression\ZLibNative.ZStream.cs"
              Link="Common\System\IO\Compression\ZLibNative.ZStream.cs" />
+    <Compile Include="System\IO\Compression\CompressionFormat.cs" />
     <Compile Include="System\IO\Compression\CompressionLevel.cs" />
     <Compile Include="System\IO\Compression\CompressionMode.cs" />
     <Compile Include="System\IO\Compression\Crc32Helper.ZLib.cs" />
     <Compile Include="System\IO\Compression\GZipStream.cs" />
     <Compile Include="System\IO\Compression\PositionPreservingWriteOnlyStreamWrapper.cs" />
+    <Compile Include="System\IO\Compression\DeflateDecoder.cs" />
+    <Compile Include="System\IO\Compression\DeflateEncoder.cs" />
+    <Compile Include="System\IO\Compression\GZipDecoder.cs" />
+    <Compile Include="System\IO\Compression\GZipEncoder.cs" />
     <Compile Include="System\IO\Compression\ZLibCompressionOptions.cs" />
+    <Compile Include="System\IO\Compression\ZLibDecoder.cs" />
+    <Compile Include="System\IO\Compression\ZLibEncoder.cs" />
     <Compile Include="System\IO\Compression\ZLibStream.cs" />
     <Compile Include="System\IO\Compression\ZipCompressionMethod.cs" />
     <Compile Include="$(CommonPath)System\Obsoletions.cs"

src/libraries/System.IO.Compression/src/System/IO/Compression/CompressionFormat.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.IO.Compression
+{
+    /// <summary>
+    /// Specifies the compression format for zlib-based encoders.
+    /// </summary>
+    internal enum CompressionFormat
+    {
+        /// <summary>Raw deflate format (no header/trailer).</summary>
+        Deflate,
+        /// <summary>ZLib format (zlib header/trailer).</summary>
+        ZLib,
+        /// <summary>GZip format (gzip header/trailer).</summary>
+        GZip
+    }
+
+    internal static class CompressionFormatHelper
+    {
+        /// <summary>
+        /// Resolves a windowLog value (8-15) to the windowBits parameter expected by zlib,
+        /// based on the compression format. A windowLog of -1 is resolved to the default (15).
+        /// </summary>
+        /// <remarks>
+        /// zlib-ng rejects windowBits 8 for raw deflate and gzip; classic zlib silently upgrades to 9.
+        /// This method clamps to 9 for Deflate and GZip formats to match classic zlib behavior.
+        /// </remarks>
+        internal static int ResolveWindowBits(int windowLog, CompressionFormat format)
+        {
+            if (windowLog == -1)
+            {
+                windowLog = ZLibNative.DefaultWindowLog;
+            }
+
+            if (format != CompressionFormat.ZLib)
+            {
+                windowLog = Math.Max(windowLog, 9);
+            }
+
+            return format switch
+            {
+                CompressionFormat.Deflate => -windowLog,
+                CompressionFormat.ZLib => windowLog,
+                CompressionFormat.GZip => windowLog + 16,
+                _ => throw new ArgumentOutOfRangeException(nameof(format))
+            };
+        }
+    }
+}