Fixed Xpress decompression

Author: LTRData

Library/DiscUtils.Core/Compression/XpressLz77.cs

@@ -1,11 +1,14 @@
 using System;
 using System.Buffers.Binary;
+using System.Diagnostics;
 using System.IO;
 
 namespace DiscUtils.Compression;
 
 public sealed class XpressLz77 : IBlockDecompressor
 {
+    public static XpressLz77 Default { get; } = new();
+
     int IBlockDecompressor.BlockSize { get; set; }
 
     bool IBlockDecompressor.TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> output, out int decompressedSize)
@@ -24,8 +27,9 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
         // Ref: MS-XCA §2.3.4 Processing (literal/match flags in 32-bit chunks; 16-bit match token). :contentReference[oaicite:3]{index=3}
 
         var expectedSize = output.Length;
-        int src = 0;
+        var src = 0;
         decompressedSize = 0;
+        var cachedLenNibble = -1; // -1 = empty; otherwise 0..15
 
         while (decompressedSize < expectedSize)
         {
@@ -35,17 +39,17 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
             }
 
             // Flags are processed MSB → LSB (we write them, then consume from the high bit).
-            uint flags = BinaryPrimitives.ReadUInt32LittleEndian(compressed.Slice(src, 4));
+            var flags = BinaryPrimitives.ReadUInt32LittleEndian(compressed.Slice(src, 4));
             src += 4;
 
-            for (int i = 0; i < 32; i++)
+            for (var i = 0; i < 32; i++)
             {
                 if (decompressedSize >= expectedSize)
                 {
                     break; // Done
                 }
 
-                bool isMatch = (flags & 0x8000_0000u) != 0;
+                var isMatch = (flags & 0x8000_0000u) != 0;
                 flags <<= 1;
 
                 if (!isMatch)
@@ -57,6 +61,7 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                     }
 
                     output[decompressedSize++] = compressed[src++];
+
                     continue;
                 }
 
@@ -66,11 +71,11 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                     return false;
                 }
 
-                ushort token = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
+                var token = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
                 src += 2;
 
-                int matchOffset = ((token >> 3) & 0x1FFF) + 1;   // 13 bits + bias
-                int lenMinus3 = (token & 0x7);                 // 3 low bits
+                var matchOffset = ((token >> 3) & 0x1FFF) + 1;   // 13 bits + bias
+                var lenMinus3 = (token & 0x7);                 // 3 low bits
                 int matchLen;
 
                 if (lenMinus3 < 7)
@@ -79,46 +84,39 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                 }
                 else
                 {
-                    // Extended length path: the next nibble (4 bits) comes in a packed scheme.
-                    // MS-XCA describes a “half-byte” reuse; we follow the encoder’s layout:
-                    // First we read a single byte that contributes 4 or 8 bits depending on reuse;
-                    // Simpler to implement decoder-side as: read a nibble from next byte,
-                    // If nibble==15, drop into the byte(s) extension path.
-
-                    // We read one “length control” byte that holds one or two 4-bit fields.
-                    if (src >= compressed.Length)
+                    // Extended length: consume a 4-bit nibble that is packed 2-per-byte.
+                    // We must reuse the high nibble on every second extended-length match.
+                    int nibble;
+                    if (cachedLenNibble >= 0)
                     {
-                        return false;
+                        nibble = cachedLenNibble;
+                        cachedLenNibble = -1;
                     }
+                    else
+                    {
+                        if (src >= compressed.Length)
+                        {
+                            return false;
+                        }
 
-                    byte lenCtl = compressed[src++];
-                    int lenNibbleLow = (lenCtl & 0x0F);
-
-                    // The encoder may pack two 4-bit values across matches;
-                    // to keep decoder robust, consume low nibble first, then high nibble
-                    // on the next long-length in the same flag run.
-                    // Many streams set only one nibble here per long length.
-                    // int lenNibbleHigh = (lenCtl >> 4) & 0x0F;
-
-                    // The encoder may pack two 4-bit values across matches; to keep decoder robust,
-                    // consume low nibble first, then high nibble on the *next* long-length in the same flag run.
-                    // Many streams set only one nibble here per long length. We handle both cases:
+                        var lenCtl = compressed[src++];
+                        nibble = lenCtl & 0x0F;
+                        cachedLenNibble = (lenCtl >> 4) & 0x0F;
+                    }
 
-                    int firstNibble = lenNibbleLow;
-                    if (firstNibble != 15)
+                    if (nibble != 15)
                     {
-                        matchLen = 3 + 7 + firstNibble;
+                        matchLen = 3 + 7 + nibble;
                     }
                     else
                     {
-                        // Need extra bytes:
-                        // Next: 1 byte (0..254) or 255 sentinel → then 2 bytes (or 4 on huge) per spec.
                         if (src >= compressed.Length)
                         {
                             return false;
                         }
 
                         int b = compressed[src++];
+
                         if (b != 255)
                         {
                             matchLen = 3 + 7 + 15 + b;
@@ -130,12 +128,13 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                                 return false;
                             }
 
-                            ushort len16 = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
+                            var len16 = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
                             src += 2;
 
                             if (len16 != 0)
                             {
-                                matchLen = len16; // already includes the + (3+7+15) per spec’s encoder logic
+                                // For XPRESS, this is effectively "length minus 3" in many emitters.
+                                matchLen = len16 + 3;
                             }
                             else
                             {
@@ -144,15 +143,12 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                                     return false;
                                 }
 
-                                matchLen = BinaryPrimitives.ReadInt32LittleEndian(compressed.Slice(src, 4));
+                                var len32 = BinaryPrimitives.ReadInt32LittleEndian(compressed.Slice(src, 4));
                                 src += 4;
+                                matchLen = len32 + 3;
                             }
                         }
                     }
-
-                    // Note: If your corpus actually uses the “reused high nibble” packing described in MS-XCA,
-                    // you can enhance this decoder to cache lenNibbleHigh and apply it to the next long length.
-                    // The above version is tolerant and works with standard Windows XPRESS emitters. :contentReference[oaicite:4]{index=4}
                 }
 
                 // Copy match
@@ -167,13 +163,13 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
                 }
 
                 // Bounds check (stream might claim more than remaining output)
-                int toCopy = matchLen;
+                var toCopy = matchLen;
                 if (decompressedSize + toCopy > expectedSize)
                 {
                     return false;
                 }
 
-                int srcPos = decompressedSize - matchOffset;
+                var srcPos = decompressedSize - matchOffset;
                 // Overlap-safe copy
                 while (toCopy-- > 0)
                 {
@@ -193,165 +189,9 @@ public static bool TryDecompress(ReadOnlySpan<byte> compressed, Span<byte> outpu
     /// <exception cref="InvalidDataException">On malformed input</exception>
     public static void Decompress(ReadOnlySpan<byte> compressed, Span<byte> output)
     {
-        // We implement the MS-XCA “fastest variant / Plain LZ77” decoder.
-        // Ref: MS-XCA §2.3.4 Processing (literal/match flags in 32-bit chunks; 16-bit match token). :contentReference[oaicite:3]{index=3}
-
-        var uncompressedSize = output.Length;
-        int src = 0, dst = 0;
-
-        while (dst < uncompressedSize)
+        if (!TryDecompress(compressed, output, out var decompressedSize) || decompressedSize != output.Length)
         {
-            if (src + 4 > compressed.Length)
-            {
-                throw new InvalidDataException("Unexpected end of input when reading flags.");
-            }
-
-            // Flags are processed MSB → LSB (we write them, then consume from the high bit).
-            uint flags = BinaryPrimitives.ReadUInt32LittleEndian(compressed.Slice(src, 4));
-            src += 4;
-
-            for (int i = 0; i < 32; i++)
-            {
-                if (dst >= uncompressedSize)
-                {
-                    break; // Done
-                }
-
-                bool isMatch = (flags & 0x8000_0000u) != 0;
-                flags <<= 1;
-
-                if (!isMatch)
-                {
-                    // Literal
-                    if (src >= compressed.Length)
-                    {
-                        throw new InvalidDataException("Unexpected end of input in literal.");
-                    }
-
-                    output[dst++] = compressed[src++];
-                    continue;
-                }
-
-                // Match: first 2 bytes are the primary token
-                if (src + 2 > compressed.Length)
-                {
-                    throw new InvalidDataException("Unexpected end of input in match token.");
-                }
-
-                ushort token = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
-                src += 2;
-
-                int matchOffset = ((token >> 3) & 0x1FFF) + 1;   // 13 bits + bias
-                int lenMinus3 = (token & 0x7);                 // 3 low bits
-                int matchLen;
-
-                if (lenMinus3 < 7)
-                {
-                    matchLen = lenMinus3 + 3;
-                }
-                else
-                {
-                    // Extended length path: the next nibble (4 bits) comes in a packed scheme.
-                    // MS-XCA describes a “half-byte” reuse; we follow the encoder’s layout:
-                    // First we read a single byte that contributes 4 or 8 bits depending on reuse;
-                    // Simpler to implement decoder-side as: read a nibble from next byte,
-                    // If nibble==15, drop into the byte(s) extension path.
-
-                    // We read one “length control” byte that holds one or two 4-bit fields.
-                    if (src >= compressed.Length)
-                    {
-                        throw new InvalidDataException("Unexpected end of input in length nibble.");
-                    }
-
-                    byte lenCtl = compressed[src++];
-                    int lenNibbleLow = (lenCtl & 0x0F);
-
-                    // The encoder may pack two 4-bit values across matches;
-                    // to keep decoder robust, consume low nibble first, then high nibble
-                    // on the next long-length in the same flag run.
-                    // Many streams set only one nibble here per long length.
-                    // int lenNibbleHigh = (lenCtl >> 4) & 0x0F;
-
-                    // The encoder may pack two 4-bit values across matches; to keep decoder robust,
-                    // consume low nibble first, then high nibble on the *next* long-length in the same flag run.
-                    // Many streams set only one nibble here per long length. We handle both cases:
-
-                    int firstNibble = lenNibbleLow;
-                    if (firstNibble != 15)
-                    {
-                        matchLen = 3 + 7 + firstNibble;
-                    }
-                    else
-                    {
-                        // Need extra bytes:
-                        // Next: 1 byte (0..254) or 255 sentinel → then 2 bytes (or 4 on huge) per spec.
-                        if (src >= compressed.Length)
-                        {
-                            throw new InvalidDataException("Unexpected end of input in length ext.");
-                        }
-
-                        int b = compressed[src++];
-                        if (b != 255)
-                        {
-                            matchLen = 3 + 7 + 15 + b;
-                        }
-                        else
-                        {
-                            if (src + 2 > compressed.Length)
-                            {
-                                throw new InvalidDataException("Unexpected end of input in length 16-bit.");
-                            }
-
-                            ushort len16 = BinaryPrimitives.ReadUInt16LittleEndian(compressed.Slice(src, 2));
-                            src += 2;
-
-                            if (len16 != 0)
-                            {
-                                matchLen = len16; // already includes the + (3+7+15) per spec’s encoder logic
-                            }
-                            else
-                            {
-                                if (src + 4 > compressed.Length)
-                                {
-                                    throw new InvalidDataException("Unexpected end of input in length 32-bit.");
-                                }
-
-                                matchLen = BinaryPrimitives.ReadInt32LittleEndian(compressed.Slice(src, 4));
-                                src += 4;
-                            }
-                        }
-                    }
-
-                    // Note: If your corpus actually uses the “reused high nibble” packing described in MS-XCA,
-                    // you can enhance this decoder to cache lenNibbleHigh and apply it to the next long length.
-                    // The above version is tolerant and works with standard Windows XPRESS emitters. :contentReference[oaicite:4]{index=4}
-                }
-
-                // Copy match
-                if (matchOffset <= 0 || matchOffset > 8192)
-                {
-                    throw new InvalidDataException($"Invalid match offset {matchOffset}.");
-                }
-
-                if (dst < matchOffset)
-                {
-                    throw new InvalidDataException("Match points before start of output.");
-                }
-
-                // Bounds check (stream might claim more than remaining output)
-                int toCopy = matchLen;
-                if (dst + toCopy > uncompressedSize)
-                {
-                    throw new InvalidDataException("Match overruns output buffer.");
-                }
-
-                int srcPos = dst - matchOffset;
-                // Overlap-safe copy
-                while (toCopy-- > 0)
-                {
-                    output[dst++] = output[srcPos++];
-                }
-            }
+            throw new InvalidDataException("Malformed XPRESS compressed data");
         }
     }
 }

Library/DiscUtils.Core/Compression/XpressStream.cs

@@ -187,7 +187,7 @@ private byte[] Buffer(int count)
                 len += 3;
 
                 // Simply do the copy
-                for (var i = 0; i < len; ++i)
+                for (var i = 0; i < len && numRead < count; ++i)
                 {
                     buffer[numRead] = buffer[numRead - offset - 1];
                     numRead++;