Add LZMA Decompression Support

src/VCDiff.Tests/ExternDiffTests.cs

@@ -20,6 +20,7 @@ public class ExternDiffTests
         [InlineData("sample.xdelta")]
         [InlineData("sample_nosmallstr.xdelta")]
         [InlineData("sample_appheader.xdelta")]
+        [InlineData("a-to-b-lzma-compression.xdelta")]
 
         public async Task ExternTest_ImplAsync(string patchfile)
         {
@@ -53,6 +54,7 @@ public async Task ExternTest_ImplAsync(string patchfile)
         [InlineData("sample.xdelta")]
         [InlineData("sample_nosmallstr.xdelta")]
         [InlineData("sample_appheader.xdelta")]
+        [InlineData("a-to-b-lzma-compression.xdelta")]
 
         public void ExternTest_Impl(string patchfile)
         {

src/VCDiff/Compressors/ICompressor.cs

@@ -0,0 +1,16 @@
+using VCDiff.Includes;
+using VCDiff.Shared;
+
+namespace VCDiff.Compressors
+{
+    /// <summary>
+    /// A compression method for secondary compression, for use when <see cref="VCDiffCodeFlags.VCDDECOMPRESS"/> is enabled in the header and the appropriate <see cref="VCDiffCompressFlags"/> flag is enabled for the section in the window.
+    /// </summary>
+    /// <remarks>
+    /// Implementations are stateful, and a single instance must be used for the entire file for a single operation (compression or decompression).
+    /// </remarks>
+    internal interface ICompressor
+    {
+        PinnedArrayRental Decompress(WindowSectionType windowSectionType, PinnedArrayRental sectionData);
+    }
+}

src/VCDiff/Compressors/XzCompressor.cs

@@ -0,0 +1,82 @@
+using SharpCompress.Compressors.Xz;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using VCDiff.Shared;
+
+namespace VCDiff.Compressors
+{
+    internal class XzCompressor : ICompressor, IDisposable
+    {
+        public XzCompressor()
+        {
+            addRunCompressedBuffer = new();
+            instructionsCompressedBuffer = new();
+            addressesCompressedBuffer = new();
+
+            addRunDecompressor = new(addRunCompressedBuffer);
+            instructionsDecompressor = new(instructionsCompressedBuffer);
+            addressesDecompressor = new(addressesCompressedBuffer);
+        }
+
+        private readonly MemoryStream addRunCompressedBuffer;
+        private readonly MemoryStream instructionsCompressedBuffer;
+        private readonly MemoryStream addressesCompressedBuffer;
+        private readonly XZStream addRunDecompressor;
+        private readonly XZStream instructionsDecompressor;
+        private readonly XZStream addressesDecompressor;
+
+        public PinnedArrayRental Decompress(WindowSectionType windowSectionType, PinnedArrayRental sectionData)
+        {
+            if (sectionData.Data == null)
+            {
+                throw new ArgumentException("Cannot decompress null data");
+            }
+
+            MemoryStream memoryStream;
+            XZStream xzStream;
+            switch (windowSectionType)
+            {
+                case WindowSectionType.AddRunData:
+                    memoryStream = addRunCompressedBuffer;
+                    xzStream = addRunDecompressor;
+                    break;
+                case WindowSectionType.InstructionsAndSizes:
+                    memoryStream = instructionsCompressedBuffer;
+                    xzStream = instructionsDecompressor;
+                    break;
+                case WindowSectionType.AddressForCopy:
+                    memoryStream = addressesCompressedBuffer;
+                    xzStream = addressesDecompressor;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(windowSectionType));
+            }
+
+            var uncompressedLength = VarIntBE.ParseInt32(sectionData.AsSpan(), out int uncompressedLengthByteCount);
+            var compressedData = sectionData.AsSpan().Slice(uncompressedLengthByteCount);
+
+            // Each section in a window uses the same compression stream throughout the file
+            // If this is not the first window, reuse the same stream from before, just using different data
+            memoryStream.SetLength(compressedData.Length);
+            memoryStream.Position = 0;
+            memoryStream.Write(compressedData);
+            memoryStream.Position = 0;
+
+            var decompressedData = new PinnedArrayRental(uncompressedLength);
+            xzStream.ReadExactly(decompressedData.AsSpan());
+
+            return decompressedData;
+        }
+        public void Dispose()
+        {
+            addressesCompressedBuffer?.Dispose();
+            instructionsCompressedBuffer?.Dispose();
+            addressesCompressedBuffer?.Dispose();
+            addRunDecompressor?.Dispose();
+            instructionsDecompressor?.Dispose();
+            addressesDecompressor?.Dispose();
+        }
+    }
+}

src/VCDiff/Decoders/BodyDecoder.cs

@@ -2,7 +2,6 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.IO;
 using VCDiff.Includes;
 using VCDiff.Shared;
 
@@ -20,6 +19,7 @@ internal class BodyDecoder<TWindowDecoderByteBuffer, TSourceBuffer, TDeltaBuffer
         private AddressCache addressCache;
         private MemoryStream targetData;
         private CustomCodeTableDecoder? customTable;
+        private readonly bool disableChecksums;
 
         //the total bytes decoded
         public long TotalBytesDecoded { get; private set; }
@@ -32,7 +32,7 @@ internal class BodyDecoder<TWindowDecoderByteBuffer, TSourceBuffer, TDeltaBuffer
         /// <param name="delta">The delta</param>
         /// <param name="decodedTarget">the out stream</param>
         /// <param name="customTable">custom table if any. Default is null.</param>
-        public BodyDecoder(WindowDecoder<TWindowDecoderByteBuffer> w, TSourceBuffer source, TDeltaBuffer delta, Stream decodedTarget, CustomCodeTableDecoder? customTable = null)
+        public BodyDecoder(WindowDecoder<TWindowDecoderByteBuffer> w, TSourceBuffer source, TDeltaBuffer delta, Stream decodedTarget, CustomCodeTableDecoder? customTable = null, bool disableChecksums = false)
         {
             if (customTable != null)
             {
@@ -48,6 +48,7 @@ public BodyDecoder(WindowDecoder<TWindowDecoderByteBuffer> w, TSourceBuffer sour
             this.source = source;
             this.delta = delta;
             this.targetData = Pool.MemoryStreamManager.GetStream(nameof(BodyDecoder<TWindowDecoderByteBuffer, TSourceBuffer, TDeltaBuffer>), (int) w.TargetWindowLength);
+            this.disableChecksums = disableChecksums;
         }
 
         private VCDiffResult DecodeInterleaveCore()
@@ -254,7 +255,7 @@ private VCDiffResult DecodeCore()
             {
                 uint adler = Checksum.ComputeGoogleAdler32(targetData.GetBuffer().AsSpan(0, (int)targetData.Length));
 
-                if (adler != window.Checksum)
+                if (adler != window.Checksum && !disableChecksums)
                 {
                     result = VCDiffResult.ERROR;
                 }
@@ -263,7 +264,7 @@ private VCDiffResult DecodeCore()
             {
                 uint adler = Checksum.ComputeXdelta3Adler32(targetData.GetBuffer().AsSpan(0, (int)targetData.Length));
 
-                if (adler != window.Checksum)
+                if (adler != window.Checksum && !disableChecksums)
                 {
                     result = VCDiffResult.ERROR;
                 }

src/VCDiff/Decoders/SharedDecompressors.cs

@@ -0,0 +1,16 @@
+using SharpCompress.Compressors.Xz;
+using System.IO;
+
+namespace VCDiff.Decoders
+{
+    internal class SharedDecompressors
+    {
+        public XZStream? AddRunDecompressor;
+        public XZStream? InstructionsDecompressor;
+        public XZStream? AddressesDecompressor;
+
+        public MemoryStream? AddRunCompressedBuffer;
+        public MemoryStream? InstructionsCompressedBuffer;
+        public MemoryStream? AddressesCompressedBuffer;
+    }
+}