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

@@ -269,13 +269,14 @@ public void TryDecompress_RandomData_ReturnsFalse(bool useDictionary)
             if (useDictionary && !SupportsDictionaries)
                 return;
 
+            // 0xFF is an invalid first byte for all three formats:
+            // - GZip requires magic bytes 0x1F 0x8B
+            // - ZLib requires a valid CMF byte (0x78 for deflate with window size)
+            // - Deflate (raw) encodes BTYPE in bits 1-2; 0xFF sets BTYPE=11 which is a reserved invalid block type
             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);
         }
@@ -350,6 +351,20 @@ public void GetMaxCompressedLength_OutOfRangeInput_ThrowsArgumentOutOfRangeExcep
             Assert.Throws<ArgumentOutOfRangeException>(InputLengthParamName, () => GetMaxCompressedLength(-1));
         }
 
+        [Fact]
+        public void GetMaxCompressedLength_FitsActualOutput()
+        {
+            byte[] input = CreateTestData(10_000);
+            long maxLength = GetMaxCompressedLength(input.Length);
+            byte[] destination = new byte[maxLength];
+
+            using EncoderAdapter encoder = CreateEncoder();
+            OperationStatus status = encoder.Compress(input, destination, out _, out int written, isFinalBlock: true);
+
+            Assert.Equal(OperationStatus.Done, status);
+            Assert.True(written <= maxLength);
+        }
+
         [Fact]
         public void Decoder_Finalize()
         {
@@ -664,6 +679,25 @@ public void RoundTrip_Chunks()
             }
         }
 
+        [Fact]
+        public void RoundTrip_AllCompressionLevels()
+        {
+            byte[] input = CreateTestData();
+
+            for (int quality = 0; quality <= 9; quality++)
+            {
+                byte[] compressed = new byte[GetMaxCompressedLength(input.Length)];
+                using var encoder = CreateEncoder(quality, ValidWindowLog);
+                encoder.Compress(input, compressed, out _, out int compressedSize, isFinalBlock: true);
+
+                byte[] decompressed = new byte[input.Length];
+                using var decoder = CreateDecoder();
+                decoder.Decompress(compressed.AsSpan(0, compressedSize), decompressed, out _, out _);
+
+                Assert.Equal(input, decompressed);
+            }
+        }
+
         public static byte[] CreateTestData(int size = 1000)
         {
             // Create test data of specified size

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,18 @@
+// 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
+    }
+}