BOS.* -> BOS.*

BinaryObjectScanner.Compression/ADPCM/ADPCM_DATA.cs

@@ -0,0 +1,12 @@
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+    public unsafe struct ADPCM_DATA
+    {
+        public uint[] pValues;
+        public int BitCount;
+        public int field_8;
+        public int field_C;
+        public int field_10;
+    }
+}

BinaryObjectScanner.Compression/ADPCM/Compressor.cs

@@ -0,0 +1,131 @@
+using static BinaryObjectScanner.Compression.ADPCM.Constants;
+using static BinaryObjectScanner.Compression.ADPCM.Helper;
+
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    public unsafe class Compressor
+    {
+        /// <summary>
+        /// Compression routine
+        /// </summary>
+        /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+        public int CompressADPCM(void* pvOutBuffer, int cbOutBuffer, void* pvInBuffer, int cbInBuffer, int ChannelCount, int CompressionLevel)
+        {
+            TADPCMStream os = new TADPCMStream(pvOutBuffer, cbOutBuffer);      // The output stream
+            TADPCMStream @is = new TADPCMStream(pvInBuffer, cbInBuffer);        // The input stream
+            byte BitShift = (byte)(CompressionLevel - 1);
+            short[] PredictedSamples = new short[MAX_ADPCM_CHANNEL_COUNT];// Predicted samples for each channel
+            short[] StepIndexes = new short[MAX_ADPCM_CHANNEL_COUNT];     // Step indexes for each channel
+            short InputSample = 0;                              // Input sample for the current channel
+            int TotalStepSize;
+            int ChannelIndex;
+            int AbsDifference;
+            int Difference;
+            int MaxBitMask;
+            int StepSize;
+
+            // First byte in the output stream contains zero. The second one contains the compression level
+            os.WriteByteSample(0);
+            if (!os.WriteByteSample(BitShift))
+                return 2;
+
+            // Set the initial step index for each channel
+            PredictedSamples[0] = PredictedSamples[1] = 0;
+            StepIndexes[0] = StepIndexes[1] = INITIAL_ADPCM_STEP_INDEX;
+
+            // Next, InitialSample value for each channel follows
+            for (int i = 0; i < ChannelCount; i++)
+            {
+                // Get the initial sample from the input stream
+                if (!@is.ReadWordSample(ref InputSample))
+                    return os.LengthProcessed(pvOutBuffer);
+
+                // Store the initial sample to our sample array
+                PredictedSamples[i] = InputSample;
+
+                // Also store the loaded sample to the output stream
+                if (!os.WriteWordSample(InputSample))
+                    return os.LengthProcessed(pvOutBuffer);
+            }
+
+            // Get the initial index
+            ChannelIndex = ChannelCount - 1;
+
+            // Now keep reading the input data as long as there is something in the input buffer
+            while (@is.ReadWordSample(ref InputSample))
+            {
+                int EncodedSample = 0;
+
+                // If we have two channels, we need to flip the channel index
+                ChannelIndex = (ChannelIndex + 1) % ChannelCount;
+
+                // Get the difference from the previous sample.
+                // If the difference is negative, set the sign bit to the encoded sample
+                AbsDifference = InputSample - PredictedSamples[ChannelIndex];
+                if (AbsDifference < 0)
+                {
+                    AbsDifference = -AbsDifference;
+                    EncodedSample |= 0x40;
+                }
+
+                // If the difference is too low (higher that difference treshold),
+                // write a step index modifier marker
+                StepSize = StepSizeTable[StepIndexes[ChannelIndex]];
+                if (AbsDifference < (StepSize >> CompressionLevel))
+                {
+                    if (StepIndexes[ChannelIndex] != 0)
+                        StepIndexes[ChannelIndex]--;
+
+                    os.WriteByteSample(0x80);
+                }
+                else
+                {
+                    // If the difference is too high, write marker that
+                    // indicates increase in step size
+                    while (AbsDifference > (StepSize << 1))
+                    {
+                        if (StepIndexes[ChannelIndex] >= 0x58)
+                            break;
+
+                        // Modify the step index
+                        StepIndexes[ChannelIndex] += 8;
+                        if (StepIndexes[ChannelIndex] > 0x58)
+                            StepIndexes[ChannelIndex] = 0x58;
+
+                        // Write the "modify step index" marker
+                        StepSize = StepSizeTable[StepIndexes[ChannelIndex]];
+                        os.WriteByteSample(0x81);
+                    }
+
+                    // Get the limit bit value
+                    MaxBitMask = (1 << (BitShift - 1));
+                    MaxBitMask = (MaxBitMask > 0x20) ? 0x20 : MaxBitMask;
+                    Difference = StepSize >> BitShift;
+                    TotalStepSize = 0;
+
+                    for (int BitVal = 0x01; BitVal <= MaxBitMask; BitVal <<= 1)
+                    {
+                        if ((TotalStepSize + StepSize) <= AbsDifference)
+                        {
+                            TotalStepSize += StepSize;
+                            EncodedSample |= BitVal;
+                        }
+                        StepSize >>= 1;
+                    }
+
+                    PredictedSamples[ChannelIndex] = (short)UpdatePredictedSample(PredictedSamples[ChannelIndex],
+                                                                                  EncodedSample,
+                                                                                  Difference + TotalStepSize);
+                    // Write the encoded sample to the output stream
+                    if (!os.WriteByteSample((byte)EncodedSample))
+                        break;
+
+                    // Calculates the step index to use for the next encode
+                    StepIndexes[ChannelIndex] = GetNextStepIndex(StepIndexes[ChannelIndex], (uint)EncodedSample);
+                }
+            }
+
+            return os.LengthProcessed(pvOutBuffer);
+        }
+    }
+}

BinaryObjectScanner.Compression/ADPCM/Constants.cs

@@ -0,0 +1,51 @@
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.h"/>
+    public static class Constants
+    {
+        public const int MAX_ADPCM_CHANNEL_COUNT = 2;
+
+        public const byte INITIAL_ADPCM_STEP_INDEX = 0x2C;
+
+        #region Tables necessary for decompression
+
+        public static readonly int[] NextStepTable =
+        {
+            -1, 0, -1, 4, -1, 2, -1, 6,
+            -1, 1, -1, 5, -1, 3, -1, 7,
+            -1, 1, -1, 5, -1, 3, -1, 7,
+            -1, 2, -1, 4, -1, 6, -1, 8
+        };
+
+        public static readonly int[] StepSizeTable =
+        {
+            7,     8,     9,    10,     11,    12,    13,    14,
+            16,    17,    19,    21,     23,    25,    28,    31,
+            34,    37,    41,    45,     50,    55,    60,    66,
+            73,    80,    88,    97,    107,   118,   130,   143,
+            157,   173,   190,   209,    230,   253,   279,   307,
+            337,   371,   408,   449,    494,   544,   598,   658,
+            724,   796,   876,   963,   1060,  1166,  1282,  1411,
+            1552,  1707,  1878,  2066,   2272,  2499,  2749,  3024,
+            3327,  3660,  4026,  4428,   4871,  5358,  5894,  6484,
+            7132,  7845,  8630,  9493,  10442, 11487, 12635, 13899,
+            15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
+            32767
+        };
+
+        #endregion
+
+        #region ADPCM decompression present in Starcraft I BETA
+
+        public static readonly uint[] adpcm_values_2 = { 0x33, 0x66 };
+        public static readonly uint[] adpcm_values_3 = { 0x3A, 0x3A, 0x50, 0x70 };
+        public static readonly uint[] adpcm_values_4 = { 0x3A, 0x3A, 0x3A, 0x3A, 0x4D, 0x66, 0x80, 0x9A };
+        public static readonly uint[] adpcm_values_6 =
+        {
+            0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A,
+            0x46, 0x53, 0x60, 0x6D, 0x7A, 0x86, 0x93, 0xA0, 0xAD, 0xBA, 0xC6, 0xD3, 0xE0, 0xED, 0xFA, 0x106
+        };
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/ADPCM/Decompressor.cs

@@ -0,0 +1,205 @@
+using static BinaryObjectScanner.Compression.ADPCM.Constants;
+using static BinaryObjectScanner.Compression.ADPCM.Helper;
+
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    public unsafe class Decompressor
+    {
+        /// <summary>
+        /// Decompression routine
+        /// </summary>
+        /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+        public int DecompressADPCM(void* pvOutBuffer, int cbOutBuffer, void* pvInBuffer, int cbInBuffer, int ChannelCount)
+        {
+            TADPCMStream os = new TADPCMStream(pvOutBuffer, cbOutBuffer);          // Output stream
+            TADPCMStream @is = new TADPCMStream(pvInBuffer, cbInBuffer);            // Input stream
+            byte EncodedSample = 0;
+            byte BitShift = 0;
+            short[] PredictedSamples = new short[MAX_ADPCM_CHANNEL_COUNT];    // Predicted sample for each channel
+            short[] StepIndexes = new short[MAX_ADPCM_CHANNEL_COUNT];         // Predicted step index for each channel
+            int ChannelIndex;                                   // Current channel index
+
+            // Initialize the StepIndex for each channel
+            PredictedSamples[0] = PredictedSamples[1] = 0;
+            StepIndexes[0] = StepIndexes[1] = INITIAL_ADPCM_STEP_INDEX;
+
+            // The first byte is always zero, the second one contains bit shift (compression level - 1)
+            @is.ReadByteSample(ref BitShift);
+            @is.ReadByteSample(ref BitShift);
+
+            // Next, InitialSample value for each channel follows
+            for (int i = 0; i < ChannelCount; i++)
+            {
+                // Get the initial sample from the input stream
+                short InitialSample = 0;
+
+                // Attempt to read the initial sample
+                if (!@is.ReadWordSample(ref InitialSample))
+                    return os.LengthProcessed(pvOutBuffer);
+
+                // Store the initial sample to our sample array
+                PredictedSamples[i] = InitialSample;
+
+                // Also store the loaded sample to the output stream
+                if (!os.WriteWordSample(InitialSample))
+                    return os.LengthProcessed(pvOutBuffer);
+            }
+
+            // Get the initial index
+            ChannelIndex = ChannelCount - 1;
+
+            // Keep reading as long as there is something in the input buffer
+            while (@is.ReadByteSample(ref EncodedSample))
+            {
+                // If we have two channels, we need to flip the channel index
+                ChannelIndex = (ChannelIndex + 1) % ChannelCount;
+
+                if (EncodedSample == 0x80)
+                {
+                    if (StepIndexes[ChannelIndex] != 0)
+                        StepIndexes[ChannelIndex]--;
+
+                    if (!os.WriteWordSample(PredictedSamples[ChannelIndex]))
+                        return os.LengthProcessed(pvOutBuffer);
+                }
+                else if (EncodedSample == 0x81)
+                {
+                    // Modify the step index
+                    StepIndexes[ChannelIndex] += 8;
+                    if (StepIndexes[ChannelIndex] > 0x58)
+                        StepIndexes[ChannelIndex] = 0x58;
+
+                    // Next pass, keep going on the same channel
+                    ChannelIndex = (ChannelIndex + 1) % ChannelCount;
+                }
+                else
+                {
+                    int StepIndex = StepIndexes[ChannelIndex];
+                    int StepSize = StepSizeTable[StepIndex];
+
+                    // Encode one sample
+                    PredictedSamples[ChannelIndex] = (short)DecodeSample(PredictedSamples[ChannelIndex],
+                                                                         EncodedSample,
+                                                                         StepSize,
+                                                                         StepSize >> BitShift);
+
+                    // Write the decoded sample to the output stream
+                    if (!os.WriteWordSample(PredictedSamples[ChannelIndex]))
+                        break;
+
+                    // Calculates the step index to use for the next encode
+                    StepIndexes[ChannelIndex] = GetNextStepIndex(StepIndex, EncodedSample);
+                }
+            }
+
+            // Return total bytes written since beginning of the output buffer
+            return os.LengthProcessed(pvOutBuffer);
+        }
+
+        /// <summary>
+        /// ADPCM decompression present in Starcraft I BETA
+        /// </summary>
+        /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+        public int DecompressADPCM_SC1B(void* pvOutBuffer, int cbOutBuffer, void* pvInBuffer, int cbInBuffer, int ChannelCount)
+        {
+            TADPCMStream os = new TADPCMStream(pvOutBuffer, cbOutBuffer);          // Output stream
+            TADPCMStream @is = new TADPCMStream(pvInBuffer, cbInBuffer);            // Input stream
+            ADPCM_DATA AdpcmData = new ADPCM_DATA();
+            int[] LowBitValues = new int[MAX_ADPCM_CHANNEL_COUNT];
+            int[] UpperBits = new int[MAX_ADPCM_CHANNEL_COUNT];
+            int[] BitMasks = new int[MAX_ADPCM_CHANNEL_COUNT];
+            int[] PredictedSamples = new int[MAX_ADPCM_CHANNEL_COUNT];
+            int ChannelIndex;
+            int ChannelIndexMax;
+            int OutputSample;
+            byte BitCount = 0;
+            byte EncodedSample = 0;
+            short InputValue16 = 0;
+            int reg_eax;
+            int Difference;
+
+            // The first byte contains number of bits
+            if (!@is.ReadByteSample(ref BitCount))
+                return os.LengthProcessed(pvOutBuffer);
+            if (InitAdpcmData(AdpcmData, BitCount) == null)
+                return os.LengthProcessed(pvOutBuffer);
+            
+            //assert(AdpcmData.pValues != NULL);
+
+            // Init bit values
+            for (int i = 0; i < ChannelCount; i++)
+            {
+                byte OneByte = 0;
+
+                if (!@is.ReadByteSample(ref OneByte))
+                    return os.LengthProcessed(pvOutBuffer);
+                LowBitValues[i] = OneByte & 0x01;
+                UpperBits[i] = OneByte >> 1;
+            }
+
+            //
+            for (int i = 0; i < ChannelCount; i++)
+            {
+                if (!@is.ReadWordSample(ref InputValue16))
+                    return os.LengthProcessed(pvOutBuffer);
+                BitMasks[i] = InputValue16 << AdpcmData.BitCount;
+            }
+
+            // Next, InitialSample value for each channel follows
+            for (int i = 0; i < ChannelCount; i++)
+            {
+                if (!@is.ReadWordSample(ref InputValue16))
+                    return os.LengthProcessed(pvOutBuffer);
+
+                PredictedSamples[i] = InputValue16;
+                os.WriteWordSample(InputValue16);
+            }
+
+            // Get the initial index
+            ChannelIndexMax = ChannelCount - 1;
+            ChannelIndex = 0;
+
+            // Keep reading as long as there is something in the input buffer
+            while (@is.ReadByteSample(ref EncodedSample))
+            {
+                reg_eax = ((PredictedSamples[ChannelIndex] * 3) << 3) - PredictedSamples[ChannelIndex];
+                PredictedSamples[ChannelIndex] = ((reg_eax * 10) + 0x80) >> 8;
+
+                Difference = (((EncodedSample >> 1) + 1) * BitMasks[ChannelIndex] + AdpcmData.field_10) >> AdpcmData.BitCount;
+
+                PredictedSamples[ChannelIndex] = UpdatePredictedSample(PredictedSamples[ChannelIndex], EncodedSample, Difference, 0x01);
+
+                BitMasks[ChannelIndex] = (int)((AdpcmData.pValues[EncodedSample >> 1] * BitMasks[ChannelIndex] + 0x80) >> 6);
+                if (BitMasks[ChannelIndex] < AdpcmData.field_8)
+                    BitMasks[ChannelIndex] = AdpcmData.field_8;
+
+                if (BitMasks[ChannelIndex] > AdpcmData.field_C)
+                    BitMasks[ChannelIndex] = AdpcmData.field_C;
+
+                reg_eax = (cbInBuffer - @is.LengthProcessed(pvInBuffer)) >> ChannelIndexMax;
+                OutputSample = PredictedSamples[ChannelIndex];
+                if (reg_eax < UpperBits[ChannelIndex])
+                {
+                    if (LowBitValues[ChannelIndex] != 0)
+                    {
+                        OutputSample += (UpperBits[ChannelIndex] - reg_eax);
+                        if (OutputSample > 32767)
+                            OutputSample = 32767;
+                    }
+                    else
+                    {
+                        OutputSample += (reg_eax - UpperBits[ChannelIndex]);
+                        if (OutputSample < -32768)
+                            OutputSample = -32768;
+                    }
+                }
+
+                // Write the word sample and swap channel
+                os.WriteWordSample((short)(OutputSample));
+                ChannelIndex = (ChannelIndex + 1) % ChannelCount;
+            }
+
+            return os.LengthProcessed(pvOutBuffer);
+        }
+    }
+}

BinaryObjectScanner.Compression/ADPCM/Helper.cs

@@ -0,0 +1,104 @@
+using static BinaryObjectScanner.Compression.ADPCM.Constants;
+
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+    internal static unsafe class Helper
+    {
+        #region Local functions
+
+        public static short GetNextStepIndex(int StepIndex, uint EncodedSample)
+        {
+            // Get the next step index
+            StepIndex = StepIndex + NextStepTable[EncodedSample & 0x1F];
+
+            // Don't make the step index overflow
+            if (StepIndex < 0)
+                StepIndex = 0;
+            else if (StepIndex > 88)
+                StepIndex = 88;
+
+            return (short)StepIndex;
+        }
+
+        public static int UpdatePredictedSample(int PredictedSample, int EncodedSample, int Difference, int BitMask = 0x40)
+        {
+            // Is the sign bit set?
+            if ((EncodedSample & BitMask) != 0)
+            {
+                PredictedSample -= Difference;
+                if (PredictedSample <= -32768)
+                    PredictedSample = -32768;
+            }
+            else
+            {
+                PredictedSample += Difference;
+                if (PredictedSample >= 32767)
+                    PredictedSample = 32767;
+            }
+
+            return PredictedSample;
+        }
+
+        public static int DecodeSample(int PredictedSample, int EncodedSample, int StepSize, int Difference)
+        {
+            if ((EncodedSample & 0x01) != 0)
+                Difference += (StepSize >> 0);
+
+            if ((EncodedSample & 0x02) != 0)
+                Difference += (StepSize >> 1);
+
+            if ((EncodedSample & 0x04) != 0)
+                Difference += (StepSize >> 2);
+
+            if ((EncodedSample & 0x08) != 0)
+                Difference += (StepSize >> 3);
+
+            if ((EncodedSample & 0x10) != 0)
+                Difference += (StepSize >> 4);
+
+            if ((EncodedSample & 0x20) != 0)
+                Difference += (StepSize >> 5);
+
+            return UpdatePredictedSample(PredictedSample, EncodedSample, Difference);
+        }
+
+        #endregion
+
+        #region ADPCM decompression present in Starcraft I BETA
+
+        public static uint[] InitAdpcmData(ADPCM_DATA pData, byte BitCount)
+        {
+            switch (BitCount)
+            {
+                case 2:
+                    pData.pValues = adpcm_values_2;
+                    break;
+
+                case 3:
+                    pData.pValues = adpcm_values_3;
+                    break;
+
+                case 4:
+                    pData.pValues = adpcm_values_4;
+                    break;
+
+                default:
+                    pData.pValues = null;
+                    break;
+
+                case 6:
+                    pData.pValues = adpcm_values_6;
+                    break;
+            }
+
+            pData.BitCount = BitCount;
+            pData.field_C = 0x20000;
+            pData.field_8 = 1 << BitCount;
+            pData.field_10 = (1 << BitCount) / 2;
+            return pData.pValues;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/ADPCM/TADPCMStream.cs

@@ -0,0 +1,67 @@
+namespace BinaryObjectScanner.Compression.ADPCM
+{
+    /// <summary>
+    /// Helper class for writing output ADPCM data
+    /// </summary>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/adpcm/adpcm.cpp"/>
+    public unsafe class TADPCMStream
+    {
+        private byte* pbBufferEnd;
+        private byte* pbBuffer;
+
+        public TADPCMStream(void* pvBuffer, int cbBuffer)
+        {
+            pbBufferEnd = (byte*)pvBuffer + cbBuffer;
+            pbBuffer = (byte*)pvBuffer;
+        }
+
+        public bool ReadByteSample(ref byte ByteSample)
+        {
+            // Check if there is enough space in the buffer
+            if (pbBuffer >= pbBufferEnd)
+                return false;
+
+            ByteSample = *pbBuffer++;
+            return true;
+        }
+
+        public bool WriteByteSample(byte ByteSample)
+        {
+            // Check if there is enough space in the buffer
+            if (pbBuffer >= pbBufferEnd)
+                return false;
+
+            *pbBuffer++ = ByteSample;
+            return true;
+        }
+
+        public bool ReadWordSample(ref short OneSample)
+        {
+            // Check if we have enough space in the output buffer
+            if ((int)(pbBufferEnd - pbBuffer) < sizeof(short))
+                return false;
+
+            // Write the sample
+            OneSample = (short)(pbBuffer[0] + ((pbBuffer[1]) << 0x08));
+            pbBuffer += sizeof(short);
+            return true;
+        }
+
+        public bool WriteWordSample(short OneSample)
+        {
+            // Check if we have enough space in the output buffer
+            if ((int)(pbBufferEnd - pbBuffer) < sizeof(short))
+                return false;
+
+            // Write the sample
+            *pbBuffer++ = (byte)(OneSample & 0xFF);
+            *pbBuffer++ = (byte)(OneSample >> 0x08);
+            return true;
+        }
+
+        public int LengthProcessed(void* pvOutBuffer)
+        {
+            return (int)((byte*)pbBuffer - (byte*)pvOutBuffer);
+        }
+    }
+}

BinaryObjectScanner.Compression/BinaryObjectScanner.Compression.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net6.0;net7.0</TargetFrameworks>
+    <RuntimeIdentifiers>win-x86;win-x64;linux-x64;osx-x64</RuntimeIdentifiers>
+    <Title>BinaryObjectScanner.Compression</Title>
+    <AssemblyName>BinaryObjectScanner.Compression</AssemblyName>
+    <Authors>Matt Nadareski</Authors>
+    <Product>BurnOutSharp</Product>
+    <Copyright>Copyright (c)2022 Matt Nadareski</Copyright>
+    <RepositoryUrl>https://github.com/mnadareski/BurnOutSharp</RepositoryUrl>
+    <Version>2.7</Version>
+    <AssemblyVersion>2.7</AssemblyVersion>
+    <FileVersion>2.7</FileVersion>
+    <IncludeSource>true</IncludeSource>
+    <IncludeSymbols>true</IncludeSymbols>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SharpCompress" Version="0.32.2" />
+    <PackageReference Include="SharpZipLib" Version="1.4.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BinaryObjectScanner.Models\BinaryObjectScanner.Models.csproj" />
+    <ProjectReference Include="..\BinaryObjectScanner.Utilities\BinaryObjectScanner.Utilities.csproj" />
+  </ItemGroup>
+
+</Project>

BinaryObjectScanner.Compression/LZ.cs

@@ -0,0 +1,525 @@
+using System.IO;
+using System.Linq;
+using System.Text;
+using BinaryObjectScanner.Models.Compression.LZ;
+using BinaryObjectScanner.Utilities;
+using static BinaryObjectScanner.Models.Compression.LZ.Constants;
+
+namespace BinaryObjectScanner.Compression
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/kernel32/lzexpand.c"/>
+    public class LZ
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public LZ() { }
+
+        #endregion
+
+        #region Static Methods
+
+        /// <summary>
+        /// Decompress LZ-compressed data
+        /// </summary>
+        /// <param name="compressed">Byte array representing the compressed data</param>
+        /// <returns>Decompressed data as a byte array, null on error</returns>
+        public static byte[] Decompress(byte[] compressed)
+        {
+            // If we have and invalid input
+            if (compressed == null || compressed.Length == 0)
+                return null;
+
+            // Create a memory stream for the input and decompress that
+            var compressedStream = new MemoryStream(compressed);
+            return Decompress(compressedStream);
+        }
+
+        /// <summary>
+        /// Decompress LZ-compressed data
+        /// </summary>
+        /// <param name="compressed">Stream representing the compressed data</param>
+        /// <returns>Decompressed data as a byte array, null on error</returns>
+        public static byte[] Decompress(Stream compressed)
+        {
+            // If we have and invalid input
+            if (compressed == null || compressed.Length == 0)
+                return null;
+
+            // Create a new LZ for decompression
+            var lz = new LZ();
+
+            // Open the input data
+            var sourceState = lz.Open(compressed, out _);
+            if (sourceState?.Window == null)
+                return null;
+
+            // Create the output data and open it
+            var decompressedStream = new MemoryStream();
+            var destState = lz.Open(decompressedStream, out _);
+            if (destState == null)
+                return null;
+
+            // Decompress the data by copying
+            long read = lz.CopyTo(sourceState, destState, out LZERROR error);
+
+            // Copy the data to the buffer
+            byte[] decompressed;
+            if (read == 0 || (error != LZERROR.LZERROR_OK && error != LZERROR.LZERROR_NOT_LZ))
+            {
+                decompressed = null;
+            }
+            else
+            {
+                int dataEnd = (int)decompressedStream.Position;
+                decompressedStream.Seek(0, SeekOrigin.Begin);
+                decompressed = decompressedStream.ReadBytes(dataEnd);
+            }
+
+            // Close the streams
+            lz.Close(sourceState);
+            lz.Close(destState);
+
+            return decompressed;
+        }
+
+        /// <summary>
+        /// Reconstructs the full filename of the compressed file
+        /// </summary>
+        public static string GetExpandedName(string input, out LZERROR error)
+        {
+            // Try to open the file as a compressed stream
+            var fileStream = File.Open(input, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var state = new LZ().Open(fileStream, out error);
+            if (state?.Window == null)
+                return null;
+
+            // Get the extension for modification
+            string inputExtension = Path.GetExtension(input).TrimStart('.');
+
+            // If we have no extension
+            if (string.IsNullOrWhiteSpace(inputExtension))
+                return Path.GetFileNameWithoutExtension(input);
+
+            // If we have an extension of length 1
+            if (inputExtension.Length == 1)
+            {
+                if (inputExtension == "_")
+                    return $"{Path.GetFileNameWithoutExtension(input)}.{char.ToLower(state.LastChar)}";
+                else
+                    return Path.GetFileNameWithoutExtension(input);
+            }
+
+            // If we have an extension that doesn't end in an underscore
+            if (!inputExtension.EndsWith("_"))
+                return Path.GetFileNameWithoutExtension(input);
+
+            // Build the new filename
+            bool isLowerCase = char.IsUpper(input[0]);
+            char replacementChar = isLowerCase ? char.ToLower(state.LastChar) : char.ToUpper(state.LastChar);
+            string outputExtension = inputExtension.Substring(0, inputExtension.Length - 1) + replacementChar;
+            return $"{Path.GetFileNameWithoutExtension(input)}.{outputExtension}";
+        }
+
+        #endregion
+
+        #region State Management
+
+        /// <summary>
+        /// Opens a stream and creates a state from it
+        /// </summary>
+        /// <param name="stream">Source stream to create a state from</stream>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>An initialized State, null on error</returns>
+        /// <remarks>Uncompressed streams are represented by a State with no buffer</remarks>
+        public State Open(Stream stream, out LZERROR error)
+        {
+            State lzs = Init(stream, out error);
+            if (error == LZERROR.LZERROR_OK || error == LZERROR.LZERROR_NOT_LZ)
+                return lzs;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Closes a state by invalidating the source
+        /// </summary>
+        /// <param name="stream">State object to close</stream>
+        public void Close(State state)
+        {
+            try
+            {
+                state?.Source?.Close();
+            }
+            catch { }
+        }
+
+        /// <summary>
+        /// Initializes internal decompression buffers
+        /// </summary>
+        /// <param name="source">Input stream to create a state from</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>An initialized State, null on error</returns>
+        /// <remarks>Uncompressed streams are represented by a State with no buffer</remarks>
+        public State Init(Stream source, out LZERROR error)
+        {
+            // If we have an invalid source
+            if (source == null)
+            {
+                error = LZERROR.LZERROR_BADVALUE;
+                return null;
+            }
+
+            // Attempt to read the header
+            var fileHeader = ParseFileHeader(source, out error);
+
+            // If we had a valid but uncompressed stream
+            if (error == LZERROR.LZERROR_NOT_LZ)
+            {
+                source.Seek(0, SeekOrigin.Begin);
+                return new State { Source = source };
+            }
+
+            // If we had any error
+            else if (error != LZERROR.LZERROR_OK)
+            {
+                source.Seek(0, SeekOrigin.Begin);
+                return null;
+            }
+
+            // Initialize the table with all spaces
+            byte[] table = Enumerable.Repeat((byte)' ', LZ_TABLE_SIZE).ToArray();
+
+            // Build the state
+            var state = new State
+            {
+                Source = source,
+                LastChar = fileHeader.LastChar,
+                RealLength = fileHeader.RealLength,
+
+                Window = new byte[GETLEN],
+                WindowLength = 0,
+                WindowCurrent = 0,
+
+                Table = table,
+                CurrentTableEntry = 0xff0,
+            };
+
+            // Return the state
+            return state;
+        }
+
+        #endregion
+
+        #region Stream Functionality
+
+        /// <summary>
+        /// Attempt to read the specified number of bytes from the State
+        /// </summary>
+        /// <param name="source">Source State to read from</param>
+        /// <param name="buffer">Byte buffer to read into</param>
+        /// <param name="offset">Offset within the buffer to read</param>
+        /// <param name="count">Number of bytes to read</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>The number of bytes read, if possible</returns>
+        /// <remarks>
+        /// If the source data is compressed, this will decompress the data.
+        /// If the source data is uncompressed, it is copied directly
+        /// </remarks>
+        public int Read(State source, byte[] buffer, int offset, int count, out LZERROR error)
+        {
+            // If we have an uncompressed input
+            if (source.Window == null)
+            {
+                error = LZERROR.LZERROR_NOT_LZ;
+                return source.Source.Read(buffer, offset, count);
+            }
+
+            // If seeking has occurred, we need to perform the seek
+            if (source.RealCurrent != source.RealWanted)
+            {
+                // If the requested position is before the current, we need to reset
+                if (source.RealCurrent > source.RealWanted)
+                {
+                    // Reset the decompressor state
+                    source.Source.Seek(LZ_HEADER_LEN, SeekOrigin.Begin);
+                    FlushWindow(source);
+                    source.RealCurrent = 0;
+                    source.ByteType = 0;
+                    source.StringLength = 0;
+                    source.Table = Enumerable.Repeat((byte)' ', LZ_TABLE_SIZE).ToArray();
+                    source.CurrentTableEntry = 0xFF0;
+                }
+
+                // While we are not at the right offset
+                while (source.RealCurrent < source.RealWanted)
+                {
+                    _ = DecompressByte(source, out error);
+                    if (error != LZERROR.LZERROR_OK)
+                        return 0;
+                }
+            }
+
+            int bytesRemaining = count;
+            while (bytesRemaining > 0)
+            {
+                byte b = DecompressByte(source, out error);
+                if (error != LZERROR.LZERROR_OK)
+                    return count - bytesRemaining;
+
+                source.RealWanted++;
+                buffer[offset++] = b;
+                bytesRemaining--;
+            }
+
+            error = LZERROR.LZERROR_OK;
+            return count;
+        }
+
+        /// <summary>
+        /// Perform a seek on the source data
+        /// </summary>
+        /// <param name="state">State to seek within</param>
+        /// <param name="offset">Data offset to seek to</state>
+        /// <param name="seekOrigin">SeekOrigin representing how to seek</state>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>The position that was seeked to, -1 on error</returns>
+        public long Seek(State state, long offset, SeekOrigin seekOrigin, out LZERROR error)
+        {
+            // If we have an invalid state
+            if (state == null)
+            {
+                error = LZERROR.LZERROR_BADVALUE;
+                return -1;
+            }
+
+            // If we have an uncompressed input
+            if (state.Window == null)
+            {
+                error = LZERROR.LZERROR_NOT_LZ;
+                return state.Source.Seek(offset, seekOrigin);
+            }
+
+            // Otherwise, generate the new offset
+            long newWanted = state.RealWanted;
+            switch (seekOrigin)
+            {
+                case SeekOrigin.Current:
+                    newWanted += offset;
+                    break;
+                case SeekOrigin.End:
+                    newWanted = state.RealLength - offset;
+                    break;
+                default:
+                    newWanted = offset;
+                    break;
+            }
+
+            // If we have an invalid new offset
+            if (newWanted < 0 && newWanted > state.RealLength)
+            {
+                error = LZERROR.LZERROR_BADVALUE;
+                return -1;
+            }
+
+            error = LZERROR.LZERROR_OK;
+            state.RealWanted = (uint)newWanted;
+            return newWanted;
+        }
+
+        /// <summary>
+        /// Copies all data from the source to the destination
+        /// </summary>
+        /// <param name="source">Source State to read from</param>
+        /// <param name="dest">Destination state to write to</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>The number of bytes written, -1 on error</returns>
+        /// <remarks>
+        /// If the source data is compressed, this will decompress the data.
+        /// If the source data is uncompressed, it is copied directly
+        /// </remarks>
+        public long CopyTo(State source, State dest, out LZERROR error)
+        {
+            error = LZERROR.LZERROR_OK;
+
+            // If we have an uncompressed input
+            if (source.Window == null)
+            {
+                source.Source.CopyTo(dest.Source);
+                return source.Source.Length;
+            }
+
+            // Loop until we have read everything
+            long length = 0;
+            while (true)
+            {
+                // Read at most 1000 bytes
+                byte[] buf = new byte[1000];
+                int read = Read(source, buf, 0, buf.Length, out error);
+
+                // If we had an error
+                if (read == 0)
+                {
+                    if (error == LZERROR.LZERROR_NOT_LZ)
+                    {
+                        error = LZERROR.LZERROR_OK;
+                        break;
+                    }
+                    else if (error != LZERROR.LZERROR_OK)
+                    {
+                        error = LZERROR.LZERROR_READ;
+                        return 0;
+                    }
+                }
+
+                // Otherwise, append the length read and write the data
+                length += read;
+                dest.Source.Write(buf, 0, read);
+            }
+
+            return length;
+        }
+
+        /// <summary>
+        /// Decompress a single byte of data from the source State
+        /// </summary>
+        /// <param name="source">Source State to read from</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>The read byte, if possible</returns>
+        private byte DecompressByte(State source, out LZERROR error)
+        {
+            byte b;
+
+            if (source.StringLength != 0)
+            {
+                b = source.Table[source.StringPosition];
+                source.StringPosition = (source.StringPosition + 1) & 0xFFF;
+                source.StringLength--;
+            }
+            else
+            {
+                if ((source.ByteType & 0x100) == 0)
+                {
+                    b = ReadByte(source, out error);
+                    if (error != LZERROR.LZERROR_OK)
+                        return 0;
+
+                    source.ByteType = (ushort)(b | 0xFF00);
+                }
+                if ((source.ByteType & 1) != 0)
+                {
+                    b = ReadByte(source, out error);
+                    if (error != LZERROR.LZERROR_OK)
+                        return 0;
+                }
+                else
+                {
+                    byte b1 = ReadByte(source, out error);
+                    if (error != LZERROR.LZERROR_OK)
+                        return 0;
+
+                    byte b2 = ReadByte(source, out error);
+                    if (error != LZERROR.LZERROR_OK)
+                        return 0;
+
+                    // Format:
+                    // b1 b2
+                    // AB CD
+                    // where CAB is the stringoffset in the table
+                    // and D+3 is the len of the string
+                    source.StringPosition = (uint)(b1 | ((b2 & 0xf0) << 4));
+                    source.StringLength = (byte)((b2 & 0xf) + 2);
+
+                    // 3, but we use a byte already below...
+                    b = source.Table[source.StringPosition];
+                    source.StringPosition = (source.StringPosition + 1) & 0xFFF;
+                }
+
+                source.ByteType >>= 1;
+            }
+
+            // Store b in table
+            source.Table[source.CurrentTableEntry++] = b;
+            source.CurrentTableEntry &= 0xFFF;
+            source.RealCurrent++;
+
+            error = LZERROR.LZERROR_OK;
+            return b;
+        }
+
+        /// <summary>
+        /// Reads one compressed byte, including buffering
+        /// </summary>
+        /// <param name="state">State to read using</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>Byte value that was read, if possible</returns>
+        private byte ReadByte(State state, out LZERROR error)
+        {
+            // If we have enough data in the buffer
+            if (state.WindowCurrent < state.WindowLength)
+            {
+                error = LZERROR.LZERROR_OK;
+                return state.Window[state.WindowCurrent++];
+            }
+
+            // Otherwise, read from the source
+            int ret = state.Source.Read(state.Window, 0, GETLEN);
+            if (ret == 0)
+            {
+                error = LZERROR.LZERROR_NOT_LZ;
+                return 0;
+            }
+
+            // Reset the window state
+            state.WindowLength = (uint)ret;
+            state.WindowCurrent = 1;
+            error = LZERROR.LZERROR_OK;
+            return state.Window[0];
+        }
+
+        /// <summary>
+        /// Reset the current window position to the length
+        /// </summary>
+        /// <param name="state">State to flush</param>
+        private void FlushWindow(State state)
+        {
+            state.WindowCurrent = state.WindowLength;
+        }
+
+        /// <summary>
+        /// Parse a Stream into a file header
+        /// </summary>
+        /// <param name="data">Stream to parse</param>
+        /// <param name="error">Output representing the last error</param>
+        /// <returns>Filled file header on success, null on error</returns>
+        private FileHeaader ParseFileHeader(Stream data, out LZERROR error)
+        {
+            error = LZERROR.LZERROR_OK;
+            FileHeaader fileHeader = new FileHeaader();
+
+            byte[] magic = data.ReadBytes(LZ_MAGIC_LEN);
+            fileHeader.Magic = Encoding.ASCII.GetString(magic);
+            if (fileHeader.Magic != MagicString)
+            {
+                error = LZERROR.LZERROR_NOT_LZ;
+                return null;
+            }
+
+            fileHeader.CompressionType = data.ReadByteValue();
+            if (fileHeader.CompressionType != (byte)'A')
+            {
+                error = LZERROR.LZERROR_UNKNOWNALG;
+                return null;
+            }
+
+            fileHeader.LastChar = (char)data.ReadByteValue();
+            fileHeader.RealLength = data.ReadUInt32();
+
+            return fileHeader;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/LZX/Bits.cs

@@ -0,0 +1,12 @@
+namespace BinaryObjectScanner.Compression.LZX
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
+    public class Bits
+    {
+        public uint BitBuffer;
+
+        public int BitsLeft;
+
+        public int InputPosition; //byte*
+    }
+}

BinaryObjectScanner.Compression/LZX/Decompressor.cs

@@ -0,0 +1,759 @@
+using System;
+using BinaryObjectScanner.Compression.LZX;
+using static BinaryObjectScanner.Models.Compression.LZX.Constants;
+using static BinaryObjectScanner.Models.MicrosoftCabinet.Constants;
+
+namespace BinaryObjectScanner.Compression.LZX
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/fdi.c"/>
+    public class Decompressor
+    {
+        /// <summary>
+        /// Initialize an LZX decompressor state
+        /// </summary>
+        public static bool Init(int window, State state)
+        {
+            uint wndsize = (uint)(1 << window);
+            int posn_slots;
+
+            /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
+            /* if a previously allocated window is big enough, keep it     */
+            if (window < 15 || window > 21)
+                return false;
+
+            if (state.actual_size < wndsize)
+                state.window = null;
+
+            if (state.window == null)
+            {
+                state.window = new byte[wndsize];
+                state.actual_size = wndsize;
+            }
+
+            state.window_size = wndsize;
+
+            /* calculate required position slots */
+            if (window == 20) posn_slots = 42;
+            else if (window == 21) posn_slots = 50;
+            else posn_slots = window << 1;
+
+            /*posn_slots=i=0; while (i < wndsize) i += 1 << CAB(extra_bits)[posn_slots++]; */
+
+            state.R0 = state.R1 = state.R2 = 1;
+            state.main_elements = (ushort)(LZX_NUM_CHARS + (posn_slots << 3));
+            state.header_read = 0;
+            state.frames_read = 0;
+            state.block_remaining = 0;
+            state.block_type = LZX_BLOCKTYPE_INVALID;
+            state.intel_curpos = 0;
+            state.intel_started = 0;
+            state.window_posn = 0;
+
+            /* initialize tables to 0 (because deltas will be applied to them) */
+            // memset(state.MAINTREE_len, 0, sizeof(state.MAINTREE_len));
+            // memset(state.LENGTH_len, 0, sizeof(state.LENGTH_len));
+
+            return true;
+        }
+
+        /// <summary>
+        /// Decompress a byte array using a given State
+        /// </summary>
+        public static bool Decompress(State state, int inlen, byte[] inbuf, int outlen, byte[] outbuf)
+        {
+            int inpos = 0; // inbuf[0];
+            int endinp = inpos + inlen;
+            int window = 0; // state.window[0];
+            int runsrc, rundest; // byte*
+
+            uint window_posn = state.window_posn;
+            uint window_size = state.window_size;
+            uint R0 = state.R0;
+            uint R1 = state.R1;
+            uint R2 = state.R2;
+
+            uint match_offset, i, j, k; /* ijk used in READ_HUFFSYM macro */
+            Bits lb = new Bits(); /* used in READ_LENGTHS macro */
+
+            int togo = outlen, this_run, main_element, aligned_bits;
+            int match_length, copy_length, length_footer, extra, verbatim_bits;
+
+            INIT_BITSTREAM(out int bitsleft, out uint bitbuf);
+
+            /* read header if necessary */
+            if (state.header_read == 0)
+            {
+                i = j = 0;
+                k = READ_BITS(1, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                if (k != 0)
+                {
+                    i = READ_BITS(16, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    j = READ_BITS(16, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                }
+
+                state.intel_filesize = (int)((i << 16) | j); /* or 0 if not encoded */
+                state.header_read = 1;
+            }
+
+            /* main decoding loop */
+            while (togo > 0)
+            {
+                /* last block finished, new block expected */
+                if (state.block_remaining == 0)
+                {
+                    if (state.block_type == LZX_BLOCKTYPE_UNCOMPRESSED)
+                    {
+                        if ((state.block_length & 1) != 0)
+                            inpos++; /* realign bitstream to word */
+
+                        INIT_BITSTREAM(out bitsleft, out bitbuf);
+                    }
+
+                    state.block_type = (ushort)READ_BITS(3, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    i = READ_BITS(16, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    j = READ_BITS(8, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    state.block_remaining = state.block_length = (i << 8) | j;
+
+                    switch (state.block_type)
+                    {
+                        case LZX_BLOCKTYPE_ALIGNED:
+                            for (i = 0; i < 8; i++)
+                            {
+                                j = READ_BITS(3, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                state.tblALIGNED_len[i] = (byte)j;
+                            }
+
+                            make_decode_table(LZX_ALIGNED_MAXSYMBOLS, LZX_ALIGNED_TABLEBITS, state.tblALIGNED_len, state.tblALIGNED_table);
+
+                            /* rest of aligned header is same as verbatim */
+                            goto case LZX_BLOCKTYPE_VERBATIM;
+
+                        case LZX_BLOCKTYPE_VERBATIM:
+                            READ_LENGTHS(state.tblMAINTREE_len, 0, 256, lb, state, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                            READ_LENGTHS(state.tblMAINTREE_len, 256, state.main_elements, lb, state, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                            make_decode_table(LZX_MAINTREE_MAXSYMBOLS, LZX_MAINTREE_TABLEBITS, state.tblMAINTREE_len, state.tblMAINTREE_table);
+                            if (state.tblMAINTREE_len[0xE8] != 0)
+                                state.intel_started = 1;
+
+                            READ_LENGTHS(state.tblLENGTH_len, 0, LZX_NUM_SECONDARY_LENGTHS, lb, state, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                            make_decode_table(LZX_LENGTH_MAXSYMBOLS, LZX_LENGTH_TABLEBITS, state.tblLENGTH_len, state.tblLENGTH_table);
+                            break;
+
+                        case LZX_BLOCKTYPE_UNCOMPRESSED:
+                            state.intel_started = 1; /* because we can't assume otherwise */
+                            ENSURE_BITS(16, inbuf, ref inpos, ref bitsleft, ref bitbuf); /* get up to 16 pad bits into the buffer */
+
+                            /* and align the bitstream! */
+                            if (bitsleft > 16)
+                                inpos -= 2;
+
+                            R0 = (uint)(inbuf[inpos + 0] | (inbuf[inpos + 1] << 8) | (inbuf[inpos + 2] << 16) | (inbuf[inpos + 3] << 24)); inpos += 4;
+                            R1 = (uint)(inbuf[inpos + 0] | (inbuf[inpos + 1] << 8) | (inbuf[inpos + 2] << 16) | (inbuf[inpos + 3] << 24)); inpos += 4;
+                            R2 = (uint)(inbuf[inpos + 0] | (inbuf[inpos + 1] << 8) | (inbuf[inpos + 2] << 16) | (inbuf[inpos + 3] << 24)); inpos += 4;
+                            break;
+
+                        default:
+                            return false;
+                    }
+                }
+
+                /* buffer exhaustion check */
+                if (inpos > endinp)
+                {
+                    /* it's possible to have a file where the next run is less than
+                     * 16 bits in size. In this case, the READ_HUFFSYM() macro used
+                     * in building the tables will exhaust the buffer, so we should
+                     * allow for this, but not allow those accidentally read bits to
+                     * be used (so we check that there are at least 16 bits
+                     * remaining - in this boundary case they aren't really part of
+                     * the compressed data)
+                     */
+                    if (inpos > (endinp + 2) || bitsleft < 16)
+                        return false;
+                }
+
+                while ((this_run = (int)state.block_remaining) > 0 && togo > 0)
+                {
+                    if (this_run > togo) this_run = togo;
+                    togo -= this_run;
+                    state.block_remaining -= (uint)this_run;
+
+                    /* apply 2^x-1 mask */
+                    window_posn &= window_size - 1;
+
+                    /* runs can't straddle the window wraparound */
+                    if ((window_posn + this_run) > window_size)
+                        return false;
+
+                    switch (state.block_type)
+                    {
+
+                        case LZX_BLOCKTYPE_VERBATIM:
+                            while (this_run > 0)
+                            {
+                                main_element = READ_HUFFSYM(state.tblMAINTREE_table, state.tblMAINTREE_len, LZX_MAINTREE_TABLEBITS, LZX_MAINTREE_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                if (main_element < LZX_NUM_CHARS)
+                                {
+                                    /* literal: 0 to LZX_NUM_CHARS-1 */
+                                    state.window[window + window_posn++] = (byte)main_element;
+                                    this_run--;
+                                }
+                                else
+                                {
+                                    /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+                                    main_element -= LZX_NUM_CHARS;
+
+                                    match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+                                    if (match_length == LZX_NUM_PRIMARY_LENGTHS)
+                                    {
+                                        length_footer = READ_HUFFSYM(state.tblLENGTH_table, state.tblLENGTH_len, LZX_LENGTH_TABLEBITS, LZX_LENGTH_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                        match_length += length_footer;
+                                    }
+
+                                    match_length += LZX_MIN_MATCH;
+                                    match_offset = (uint)(main_element >> 3);
+
+                                    if (match_offset > 2)
+                                    {
+                                        /* not repeated offset */
+                                        if (match_offset != 3)
+                                        {
+                                            extra = state.ExtraBits[match_offset];
+                                            verbatim_bits = (int)READ_BITS(extra, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                            match_offset = (uint)(state.PositionSlotBases[match_offset] - 2 + verbatim_bits);
+                                        }
+                                        else
+                                        {
+                                            match_offset = 1;
+                                        }
+
+                                        /* update repeated offset LRU queue */
+                                        R2 = R1; R1 = R0; R0 = match_offset;
+                                    }
+                                    else if (match_offset == 0)
+                                    {
+                                        match_offset = R0;
+                                    }
+                                    else if (match_offset == 1)
+                                    {
+                                        match_offset = R1;
+                                        R1 = R0; R0 = match_offset;
+                                    }
+                                    else /* match_offset == 2 */
+                                    {
+                                        match_offset = R2;
+                                        R2 = R0; R0 = match_offset;
+                                    }
+
+                                    rundest = (int)(window + window_posn);
+                                    this_run -= match_length;
+
+                                    /* copy any wrapped around source data */
+                                    if (window_posn >= match_offset)
+                                    {
+                                        /* no wrap */
+                                        runsrc = (int)(rundest - match_offset);
+                                    }
+                                    else
+                                    {
+                                        runsrc = (int)(rundest + (window_size - match_offset));
+                                        copy_length = (int)(match_offset - window_posn);
+                                        if (copy_length < match_length)
+                                        {
+                                            match_length -= copy_length;
+                                            window_posn += (uint)copy_length;
+                                            while (copy_length-- > 0)
+                                            {
+                                                state.window[rundest++] = state.window[runsrc++];
+                                            }
+
+                                            runsrc = window;
+                                        }
+                                    }
+
+                                    window_posn += (uint)match_length;
+
+                                    /* copy match data - no worries about destination wraps */
+                                    while (match_length-- > 0)
+                                    {
+                                        state.window[rundest++] = state.window[runsrc++];
+                                    }
+                                }
+                            }
+                            break;
+
+                        case LZX_BLOCKTYPE_ALIGNED:
+                            while (this_run > 0)
+                            {
+                                main_element = READ_HUFFSYM(state.tblMAINTREE_table, state.tblMAINTREE_len, LZX_MAINTREE_TABLEBITS, LZX_MAINTREE_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+
+                                if (main_element < LZX_NUM_CHARS)
+                                {
+                                    /* literal: 0 to LZX_NUM_CHARS-1 */
+                                    state.window[window + window_posn++] = (byte)main_element;
+                                    this_run--;
+                                }
+                                else
+                                {
+                                    /* mverbatim_bitsatch: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+                                    main_element -= LZX_NUM_CHARS;
+
+                                    match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+                                    if (match_length == LZX_NUM_PRIMARY_LENGTHS)
+                                    {
+                                        length_footer = READ_HUFFSYM(state.tblLENGTH_table, state.tblLENGTH_len, LZX_LENGTH_TABLEBITS, LZX_LENGTH_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                        match_length += length_footer;
+                                    }
+                                    match_length += LZX_MIN_MATCH;
+
+                                    match_offset = (uint)(main_element >> 3);
+
+                                    if (match_offset > 2)
+                                    {
+                                        /* not repeated offset */
+                                        extra = state.ExtraBits[match_offset];
+                                        match_offset = state.PositionSlotBases[match_offset] - 2;
+                                        if (extra > 3)
+                                        {
+                                            /* verbatim and aligned bits */
+                                            extra -= 3;
+                                            verbatim_bits = (int)READ_BITS(extra, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                            match_offset += (uint)(verbatim_bits << 3);
+                                            aligned_bits = READ_HUFFSYM(state.tblALIGNED_table, state.tblALIGNED_len, LZX_ALIGNED_TABLEBITS, LZX_ALIGNED_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                            match_offset += (uint)aligned_bits;
+                                        }
+                                        else if (extra == 3)
+                                        {
+                                            /* aligned bits only */
+                                            aligned_bits = READ_HUFFSYM(state.tblALIGNED_table, state.tblALIGNED_len, LZX_ALIGNED_TABLEBITS, LZX_ALIGNED_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                            match_offset += (uint)aligned_bits;
+                                        }
+                                        else if (extra > 0)
+                                        {
+                                            /* extra==1, extra==2 */
+                                            /* verbatim bits only */
+                                            verbatim_bits = (int)READ_BITS(extra, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                                            match_offset += (uint)verbatim_bits;
+                                        }
+                                        else /* extra == 0 */
+                                        {
+                                            /* ??? */
+                                            match_offset = 1;
+                                        }
+
+                                        /* update repeated offset LRU queue */
+                                        R2 = R1; R1 = R0; R0 = match_offset;
+                                    }
+                                    else if (match_offset == 0)
+                                    {
+                                        match_offset = R0;
+                                    }
+                                    else if (match_offset == 1)
+                                    {
+                                        match_offset = R1;
+                                        R1 = R0; R0 = match_offset;
+                                    }
+                                    else /* match_offset == 2 */
+                                    {
+                                        match_offset = R2;
+                                        R2 = R0; R0 = match_offset;
+                                    }
+
+                                    rundest = (int)(window + window_posn);
+                                    this_run -= match_length;
+
+                                    /* copy any wrapped around source data */
+                                    if (window_posn >= match_offset)
+                                    {
+                                        /* no wrap */
+                                        runsrc = (int)(rundest - match_offset);
+                                    }
+                                    else
+                                    {
+                                        runsrc = (int)(rundest + (window_size - match_offset));
+                                        copy_length = (int)(match_offset - window_posn);
+                                        if (copy_length < match_length)
+                                        {
+                                            match_length -= copy_length;
+                                            window_posn += (uint)copy_length;
+                                            while (copy_length-- > 0)
+                                            {
+                                                state.window[rundest++] = state.window[runsrc++];
+                                            }
+
+                                            runsrc = window;
+                                        }
+                                    }
+
+                                    window_posn += (uint)match_length;
+
+                                    /* copy match data - no worries about destination wraps */
+                                    while (match_length-- > 0)
+                                    {
+                                        state.window[rundest++] = state.window[runsrc++];
+                                    }
+                                }
+                            }
+                            break;
+
+                        case LZX_BLOCKTYPE_UNCOMPRESSED:
+                            if ((inpos + this_run) > endinp)
+                                return false;
+                            
+                            Array.Copy(inbuf, inpos, state.window, window + window_posn, this_run);
+                            inpos += this_run;
+                            window_posn += (uint)this_run;
+                            break;
+
+                        default:
+                            return false; /* might as well */
+                    }
+
+                }
+            }
+
+            if (togo != 0)
+                return false;
+
+            Array.Copy(state.window, window + ((window_posn == 0) ? window_size : window_posn) - outlen, outbuf, 0, outlen);
+
+            state.window_posn = window_posn;
+            state.R0 = R0;
+            state.R1 = R1;
+            state.R2 = R2;
+
+            /* intel E8 decoding */
+            if ((state.frames_read++ < 32768) && state.intel_filesize != 0)
+            {
+                if (outlen <= 6 || state.intel_started == 0)
+                {
+                    state.intel_curpos += outlen;
+                }
+                else
+                {
+                    int data = 0; // outbuf[0];
+                    int dataend = data + outlen - 10;
+                    int curpos = state.intel_curpos;
+                    int filesize = state.intel_filesize;
+                    int abs_off, rel_off;
+
+                    state.intel_curpos = curpos + outlen;
+
+                    while (data < dataend)
+                    {
+                        if (outbuf[data++] != 0xE8)
+                        {
+                            curpos++;
+                            continue;
+                        }
+
+                        abs_off = outbuf[data + 0] | (outbuf[data + 1] << 8) | (outbuf[data + 2] << 16) | (outbuf[data + 3] << 24);
+                        if ((abs_off >= -curpos) && (abs_off < filesize))
+                        {
+                            rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
+                            outbuf[data + 0] = (byte)rel_off;
+                            outbuf[data + 1] = (byte)(rel_off >> 8);
+                            outbuf[data + 2] = (byte)(rel_off >> 16);
+                            outbuf[data + 3] = (byte)(rel_off >> 24);
+                        }
+                        data += 4;
+                        curpos += 5;
+                    }
+                }
+            }
+            
+            return true;
+        }
+        /// <summary>
+        /// Read and build the Huffman tree from the lengths
+        /// </summary>
+        private static int ReadLengths(byte[] lengths, uint first, uint last, Bits lb, State state, byte[] inbuf)
+        {
+            uint x, y;
+            uint bitbuf = lb.BitBuffer;
+            int bitsleft = lb.BitsLeft;
+            int inpos = lb.InputPosition;
+
+            for (x = 0; x < 20; x++)
+            {
+                y = READ_BITS(4, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                state.tblPRETREE_len[x] = (byte)y;
+            }
+
+            make_decode_table(LZX_PRETREE_MAXSYMBOLS, LZX_PRETREE_TABLEBITS, state.tblPRETREE_len, state.tblPRETREE_table);
+
+            for (x = first; x < last;)
+            {
+                int z = READ_HUFFSYM(state.tblPRETREE_table, state.tblPRETREE_len, LZX_PRETREE_TABLEBITS, LZX_PRETREE_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                if (z == 17)
+                {
+                    y = READ_BITS(4, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    y += 4;
+                    while (y-- > 0)
+                    {
+                        lengths[x++] = 0;
+                    }
+                }
+                else if (z == 18)
+                {
+                    y = READ_BITS(5, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    y += 20;
+                    while (y-- > 0)
+                    {
+                        lengths[x++] = 0;
+                    }
+                }
+                else if (z == 19)
+                {
+                    y = READ_BITS(1, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    y += 4;
+
+                    z = READ_HUFFSYM(state.tblPRETREE_table, state.tblPRETREE_len, LZX_PRETREE_TABLEBITS, LZX_PRETREE_MAXSYMBOLS, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                    z = lengths[x] - z;
+                    if (z < 0)
+                        z += 17;
+
+                    while (y-- > 0)
+                    {
+                        lengths[x++] = (byte)z;
+                    }
+                }
+                else
+                {
+                    z = lengths[x] - z;
+                    if (z < 0)
+                        z += 17;
+
+                    lengths[x++] = (byte)z;
+                }
+            }
+
+            lb.BitBuffer = bitbuf;
+            lb.BitsLeft = bitsleft;
+            lb.InputPosition = inpos;
+            return 0;
+        }
+
+        // Bitstream reading macros (LZX / intel little-endian byte order)
+        #region Bitstream Reading Macros
+
+        /*
+        * These bit access routines work by using the area beyond the MSB and the
+        * LSB as a free source of zeroes. This avoids having to mask any bits.
+        * So we have to know the bit width of the bitbuffer variable.
+        */
+
+        /// <summary>
+        /// Should be used first to set up the system
+        /// </summary>
+        private static void INIT_BITSTREAM(out int bitsleft, out uint bitbuf)
+        {
+            bitsleft = 0;
+            bitbuf = 0;
+        }
+
+        /// <summary>
+        /// Ensures there are at least N bits in the bit buffer. It can guarantee
+        // up to 17 bits (i.e. it can read in 16 new bits when there is down to
+        /// 1 bit in the buffer, and it can read 32 bits when there are 0 bits in
+        /// the buffer).
+        /// </summary>
+        /// <remarks>Quantum reads bytes in normal order; LZX is little-endian order</remarks>
+        private static void ENSURE_BITS(int n, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            while (bitsleft < n)
+            {
+                byte b0 = inpos + 0 < inbuf.Length ? inbuf[inpos + 0] : (byte)0;
+                byte b1 = inpos + 1 < inbuf.Length ? inbuf[inpos + 1] : (byte)0;
+
+                bitbuf |= (uint)(((b1 << 8) | b0) << (16 - bitsleft));
+                bitsleft += 16;
+                inpos += 2;
+            }
+        }
+
+        /// <summary>
+        /// Extracts (without removing) N bits from the bit buffer
+        /// </summary>
+        private static uint PEEK_BITS(int n, uint bitbuf)
+        {
+            return bitbuf >> (32 - n);
+        }
+
+        /// <summary>
+        /// Removes N bits from the bit buffer
+        /// </summary>
+        private static void REMOVE_BITS(int n, ref int bitsleft, ref uint bitbuf)
+        {
+            bitbuf <<= n;
+            bitsleft -= n;
+        }
+
+        /// <summary>
+        /// Takes N bits from the buffer and puts them in v.
+        /// </summary>
+        private static uint READ_BITS(int n, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            uint v = 0;
+            if (n > 0)
+            {
+                ENSURE_BITS(n, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                v = PEEK_BITS(n, bitbuf);
+                REMOVE_BITS(n, ref bitsleft, ref bitbuf);
+            }
+
+            return v;
+        }
+
+        #endregion
+
+        #region Huffman Methods
+
+        /// <summary>
+        /// This function was coded by David Tritscher. It builds a fast huffman
+        /// decoding table out of just a canonical huffman code lengths table.
+        /// </summary>
+        /// <param name="nsyms">Total number of symbols in this huffman tree.</param>
+        /// <param name="nbits">
+        /// Any symbols with a code length of nbits or less can be decoded
+        /// in one lookup of the table.
+        /// </param>
+        /// <param name="length">A table to get code lengths from [0 to syms-1]</param>
+        /// <param name="table">The table to fill up with decoded symbols and pointers.</param>
+        /// <returns>
+        /// OK:    0
+        /// error: 1
+        /// </returns>
+        private static int make_decode_table(uint nsyms, uint nbits, byte[] length, ushort[] table)
+        {
+            ushort sym;
+            uint leaf;
+            byte bit_num = 1;
+            uint fill;
+            uint pos = 0; /* the current position in the decode table */
+            uint table_mask = (uint)(1 << (int)nbits);
+            uint bit_mask = table_mask >> 1; /* don't do 0 length codes */
+            uint next_symbol = bit_mask; /* base of allocation for long codes */
+
+            /* fill entries for codes short enough for a direct mapping */
+            while (bit_num <= nbits)
+            {
+                for (sym = 0; sym < nsyms; sym++)
+                {
+                    if (length[sym] == bit_num)
+                    {
+                        leaf = pos;
+
+                        if ((pos += bit_mask) > table_mask) return 1; /* table overrun */
+
+                        /* fill all possible lookups of this symbol with the symbol itself */
+                        fill = bit_mask;
+                        while (fill-- > 0) table[leaf++] = sym;
+                    }
+                }
+                bit_mask >>= 1;
+                bit_num++;
+            }
+
+            /* if there are any codes longer than nbits */
+            if (pos != table_mask)
+            {
+                /* clear the remainder of the table */
+                for (sym = (ushort)pos; sym < table_mask; sym++) table[sym] = 0;
+
+                /* give ourselves room for codes to grow by up to 16 more bits */
+                pos <<= 16;
+                table_mask <<= 16;
+                bit_mask = 1 << 15;
+
+                while (bit_num <= 16)
+                {
+                    for (sym = 0; sym < nsyms; sym++)
+                    {
+                        if (length[sym] == bit_num)
+                        {
+                            leaf = pos >> 16;
+                            for (fill = 0; fill < bit_num - nbits; fill++)
+                            {
+                                /* if this path hasn't been taken yet, 'allocate' two entries */
+                                if (table[leaf] == 0)
+                                {
+                                    table[(next_symbol << 1)] = 0;
+                                    table[(next_symbol << 1) + 1] = 0;
+                                    table[leaf] = (ushort)next_symbol++;
+                                }
+                                /* follow the path and select either left or right for next bit */
+                                leaf = (uint)(table[leaf] << 1);
+                                if (((pos >> (int)(15 - fill)) & 1) != 0) leaf++;
+                            }
+                            table[leaf] = sym;
+
+                            if ((pos += bit_mask) > table_mask) return 1; /* table overflow */
+                        }
+                    }
+                    bit_mask >>= 1;
+                    bit_num++;
+                }
+            }
+
+            /* full table? */
+            if (pos == table_mask) return 0;
+
+            /* either erroneous table, or all elements are 0 - let's find out. */
+            for (sym = 0; sym < nsyms; sym++) if (length[sym] != 0) return 1;
+            return 0;
+        }
+
+        #endregion
+
+        // Huffman macros
+        #region Huffman Macros
+
+        /// <summary>
+        /// Decodes one huffman symbol from the bitstream using the stated table and
+        /// puts it in v.
+        /// </summary>
+        private static int READ_HUFFSYM(ushort[] hufftbl, byte[] lentable, int tablebits, int maxsymbols, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            int v = 0, i, j = 0;
+            ENSURE_BITS(16, inbuf, ref inpos, ref bitsleft, ref bitbuf);
+            if ((i = hufftbl[PEEK_BITS(tablebits, bitbuf)]) >= maxsymbols)
+            {
+                j = 1 << (32 - tablebits);
+                do
+                {
+                    j >>= 1;
+                    i <<= 1;
+                    i |= (bitbuf & j) != 0 ? 1 : 0;
+                    if (j == 0)
+                        throw new System.Exception();
+                } while ((i = hufftbl[i]) >= maxsymbols);
+            }
+
+            j = lentable[v = i];
+            REMOVE_BITS(j, ref bitsleft, ref bitbuf);
+            return v;
+        }
+
+        /// <summary>
+        /// Reads in code lengths for symbols first to last in the given table. The
+        /// code lengths are stored in their own special LZX way.
+        /// </summary>
+        private static bool READ_LENGTHS(byte[] lentable, uint first, uint last, Bits lb, State state, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            lb.BitBuffer = bitbuf;
+            lb.BitsLeft = bitsleft;
+            lb.InputPosition = inpos;
+
+            if (ReadLengths(lentable, first, last, lb, state, inbuf) != 0)
+                return false;
+
+            bitbuf = lb.BitBuffer;
+            bitsleft = lb.BitsLeft;
+            inpos = lb.InputPosition;
+            return true;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/LZX/State.cs

@@ -0,0 +1,119 @@
+using static BinaryObjectScanner.Models.Compression.LZX.Constants;
+
+namespace BinaryObjectScanner.Compression.LZX
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
+    public class State
+    {
+        /// <summary>
+        /// the actual decoding window
+        /// </summary>
+        public byte[] window;
+
+        /// <summary>
+        /// window size (32Kb through 2Mb)
+        /// </summary>
+        public uint window_size;
+
+        /// <summary>
+        /// window size when it was first allocated
+        /// </summary>
+        public uint actual_size;
+
+        /// <summary>
+        /// current offset within the window
+        /// </summary>
+        public uint window_posn;
+
+        /// <summary>
+        /// for the LRU offset system
+        /// </summary>
+        public uint R0, R1, R2;
+
+        /// <summary>
+        /// number of main tree elements
+        /// </summary>
+        public ushort main_elements;
+
+        /// <summary>
+        /// have we started decoding at all yet?
+        /// </summary>
+        public int header_read;
+
+        /// <summary>
+        /// type of this block
+        /// </summary>
+        public ushort block_type;
+
+        /// <summary>
+        /// uncompressed length of this block
+        /// </summary>
+        public uint block_length;
+
+        /// <summary>
+        /// uncompressed bytes still left to decode
+        /// </summary>
+        public uint block_remaining;
+
+        /// <summary>
+        /// the number of CFDATA blocks processed
+        /// </summary>
+        public uint frames_read;
+
+        /// <summary>
+        /// magic header value used for transform
+        /// </summary>
+        public int intel_filesize;
+
+        /// <summary>
+        /// current offset in transform space
+        /// </summary>
+        public int intel_curpos;
+
+        /// <summary>
+        /// have we seen any translatable data yet?
+        /// </summary>
+        public int intel_started;
+
+        public ushort[] tblPRETREE_table = new ushort[(1 << LZX_PRETREE_TABLEBITS) + (LZX_PRETREE_MAXSYMBOLS << 1)];
+        public byte[] tblPRETREE_len = new byte[LZX_PRETREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+
+        public ushort[] tblMAINTREE_table = new ushort[(1 << LZX_MAINTREE_TABLEBITS) + (LZX_MAINTREE_MAXSYMBOLS << 1)];
+        public byte[] tblMAINTREE_len = new byte[LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+
+        public ushort[] tblLENGTH_table = new ushort[(1 << LZX_LENGTH_TABLEBITS) + (LZX_LENGTH_MAXSYMBOLS << 1)];
+        public byte[] tblLENGTH_len = new byte[LZX_LENGTH_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+
+        public ushort[] tblALIGNED_table = new ushort[(1 << LZX_ALIGNED_TABLEBITS) + (LZX_ALIGNED_MAXSYMBOLS << 1)];
+        public byte[] tblALIGNED_len = new byte[LZX_ALIGNED_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+
+        #region Decompression Tables
+
+        /// <summary>
+        /// An index to the position slot bases
+        /// </summary>
+        public uint[] PositionSlotBases = new uint[]
+        {
+            0,       1,       2,       3,       4,       6,       8,      12,
+            16,      24,      32,      48,      64,      96,     128,     192,
+            256,     384,     512,     768,    1024,    1536,    2048,    3072,
+            4096,    6144,    8192,   12288,   16384,   24576,   32768,   49152,
+            65536,   98304,  131072,  196608,  262144,  393216,  524288,  655360,
+            786432,  917504, 1048576, 1179648, 1310720, 1441792, 1572864, 1703936,
+            1835008, 1966080, 2097152
+        };
+
+        /// <summary>
+        /// How many bits of offset-from-base data is needed
+        /// </summary>
+        public byte[] ExtraBits = new byte[]
+        {
+            0,  0,  0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,
+            7,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14,
+            15, 15, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+            17, 17, 17
+        };
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/MSZIP/Decompressor.cs

@@ -0,0 +1,636 @@
+using System;
+using System.Runtime.InteropServices;
+using BinaryObjectScanner.Models.Compression.MSZIP;
+using static BinaryObjectScanner.Models.Compression.MSZIP.Constants;
+
+namespace BinaryObjectScanner.Compression.MSZIP
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/fdi.c"/>
+    public unsafe class Decompressor
+    {
+        /// <summary>
+        /// Decompress a byte array using a given State
+        /// </summary>
+        public static bool Decompress(State state, int inlen, byte[] inbuf, int outlen, byte[] outbuf)
+        {
+            fixed (byte* inpos = inbuf)
+            {
+                state.inpos = inpos;
+                state.bb = state.bk = state.window_posn = 0;
+                if (outlen > ZIPWSIZE)
+                    return false;
+
+                //  CK = Chris Kirmse, official Microsoft purloiner
+                if (state.inpos[0] != 0x43 || state.inpos[1] != 0x48)
+                    return false;
+
+                state.inpos += 2;
+
+                int lastBlockFlag = 0;
+                do
+                {
+                    if (InflateBlock(&lastBlockFlag, state, inbuf, outbuf) != 0)
+                        return false;
+                } while (lastBlockFlag == 0);
+
+                // Return success
+                return true;
+            }
+
+        }
+
+        /// <summary>
+        /// Decompress a deflated block
+        /// </summary>
+        private static uint InflateBlock(int* e, State state, byte[] inbuf, byte[] outbuf)
+        {
+            // Make local bit buffer
+            uint b = state.bb;
+            uint k = state.bk;
+
+            // Read the deflate block header
+            var header = new DeflateBlockHeader();
+
+            // Read in last block bit
+            ZIPNEEDBITS(1, state, ref b, ref k);
+            header.BFINAL = (*e = (int)b & 1) != 0;
+            ZIPDUMPBITS(1, ref b, ref k);
+
+            // Read in block type
+            ZIPNEEDBITS(2, state, ref b, ref k);
+            header.BTYPE = (CompressionType)(b & 3);
+            ZIPDUMPBITS(2, ref b, ref k);
+
+            // Restore the global bit buffer
+            state.bb = b;
+            state.bk = k;
+
+            // Inflate that block type
+            switch (header.BTYPE)
+            {
+                case CompressionType.NoCompression:
+                    return (uint)DecompressStored(state, inbuf, outbuf);
+                case CompressionType.FixedHuffman:
+                    return (uint)DecompressFixed(state, inbuf, outbuf);
+                case CompressionType.DynamicHuffman:
+                    return (uint)DecompressDynamic(state, inbuf, outbuf);
+
+                // Bad block type
+                case CompressionType.Reserved:
+                default:
+                    return 2;
+            }
+        }
+
+        /// <summary>
+        /// "Decompress" a stored block
+        /// </summary>
+        private static int DecompressStored(State state, byte[] inbuf, byte[] outbuf)
+        {
+            // Make local copies of globals
+            uint b = state.bb;
+            uint k = state.bk;
+            uint w = state.window_posn;
+
+            // Go to byte boundary
+            int n = (int)(k & 7);
+            ZIPDUMPBITS(n, ref b, ref k);
+
+            // Read the stored block header
+            var header = new NonCompressedBlockHeader();
+
+            // Get the length and its compliment
+            ZIPNEEDBITS(16, state, ref b, ref k);
+            header.LEN = (ushort)(b & 0xffff);
+            ZIPDUMPBITS(16, ref b, ref k);
+
+            ZIPNEEDBITS(16, state, ref b, ref k);
+            header.NLEN = (ushort)(b & 0xffff);
+
+            if (header.LEN != (~header.NLEN & 0xffff))
+                return 1; // Error in compressed data
+
+            ZIPDUMPBITS(16, ref b, ref k);
+
+            // Read and output the compressed data
+            while (n-- > 0)
+            {
+                ZIPNEEDBITS(8, state, ref b, ref k);
+                outbuf[w++] = (byte)b;
+                ZIPDUMPBITS(8, ref b, ref k);
+            }
+
+            // Restore the globals from the locals
+            state.window_posn = w;
+            state.bb = b;
+            state.bk = k;
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Decompress a block originally compressed with fixed Huffman codes
+        /// </summary>
+        private static int DecompressFixed(State state, byte[] inbuf, byte[] outbuf)
+        {
+            // Create the block header
+            FixedHuffmanCompressedBlockHeader header = new FixedHuffmanCompressedBlockHeader();
+
+            fixed (uint* l = state.ll)
+            fixed (ushort* Zipcplens = CopyLengths)
+            fixed (ushort* Zipcplext = LiteralExtraBits)
+            fixed (ushort* Zipcpdist = CopyOffsets)
+            fixed (ushort* Zipcpdext = DistanceExtraBits)
+            {
+                // Assign the literal lengths
+                state.ll = header.LiteralLengths;
+                HuffmanNode* fixed_tl;
+                int fixed_bl = 7;
+
+                // Build the literal length tree
+                int i = BuildHuffmanTree(l, 288, 257, Zipcplens, Zipcplext, &fixed_tl, &fixed_bl, state);
+                if (i != 0)
+                    return i;
+
+                // Assign the distance codes
+                state.ll = header.DistanceCodes;
+                HuffmanNode* fixed_td;
+                int fixed_bd = 5;
+
+                // Build the distance code tree
+                i = BuildHuffmanTree(l, 30, 0, Zipcpdist, Zipcpdext, &fixed_td, &fixed_bd, state);
+                if (i != 0)
+                    return i;
+
+                // Decompress until an end-of-block code
+                return InflateCodes(fixed_tl, fixed_td, fixed_bl, fixed_bd, state, inbuf, outbuf);
+            }
+        }
+
+        /// <summary>
+        /// Decompress a block originally compressed with dynamic Huffman codes
+        /// </summary>
+        private static int DecompressDynamic(State state, byte[] inbuf, byte[] outbuf)
+        {
+            int i;                  /* temporary variables */
+            uint j;
+            uint l;                 /* last length */
+            uint m;                 /* mask for bit lengths table */
+            uint n;                 /* number of lengths to get */
+            HuffmanNode* tl;        /* literal/length code table */
+            HuffmanNode* td;        /* distance code table */
+            int bl;                 /* lookup bits for tl */
+            int bd;                 /* lookup bits for td */
+            uint nb;                /* number of bit length codes */
+            uint nl;                /* number of literal/length codes */
+            uint nd;                /* number of distance codes */
+            uint b;                 /* bit buffer */
+            uint k;                 /* number of bits in bit buffer */
+
+            /* make local bit buffer */
+            b = state.bb;
+            k = state.bk;
+
+            fixed (uint* ll = state.ll)
+            {
+                /* read in table lengths */
+                ZIPNEEDBITS(5, state, ref b, ref k);
+                nl = 257 + (b & 0x1f);      /* number of literal/length codes */
+                ZIPDUMPBITS(5, ref b, ref k);
+
+                ZIPNEEDBITS(5, state, ref b, ref k);
+                nd = 1 + (b & 0x1f);        /* number of distance codes */
+                ZIPDUMPBITS(5, ref b, ref k);
+
+                ZIPNEEDBITS(4, state, ref b, ref k);
+                nb = 4 + (b & 0xf);         /* number of bit length codes */
+                ZIPDUMPBITS(4, ref b, ref k);
+                if (nl > 288 || nd > 32)
+                    return 1;                   /* bad lengths */
+
+                /* read in bit-length-code lengths */
+                for (j = 0; j < nb; j++)
+                {
+                    ZIPNEEDBITS(3, state, ref b, ref k);
+                    state.ll[BitLengthOrder[j]] = b & 7;
+                    ZIPDUMPBITS(3, ref b, ref k);
+                }
+                for (; j < 19; j++)
+                    state.ll[BitLengthOrder[j]] = 0;
+
+                /* build decoding table for trees--single level, 7 bit lookup */
+                bl = 7;
+                if ((i = BuildHuffmanTree(ll, 19, 19, null, null, &tl, &bl, state)) != 0)
+                    return i;                   /* incomplete code set */
+
+                /* read in literal and distance code lengths */
+                n = nl + nd;
+                m = BitMasks[bl];
+                i = (int)(l = 0);
+                while ((uint)i < n)
+                {
+                    ZIPNEEDBITS(bl, state, ref b, ref k);
+                    j = (td = tl + (b & m))->b;
+                    ZIPDUMPBITS((int)j, ref b, ref k);
+                    j = td->n;
+                    if (j < 16)                 /* length of code in bits (0..15) */
+                    {
+                        state.ll[i++] = l = j;          /* save last length in l */
+                    }
+                    else if (j == 16)           /* repeat last length 3 to 6 times */
+                    {
+                        ZIPNEEDBITS(2, state, ref b, ref k);
+                        j = 3 + (b & 3);
+                        ZIPDUMPBITS(2, ref b, ref k);
+                        if ((uint)i + j > n)
+                            return 1;
+                        while (j-- > 0)
+                        {
+                            state.ll[i++] = l;
+                        }
+                    }
+                    else if (j == 17)           /* 3 to 10 zero length codes */
+                    {
+                        ZIPNEEDBITS(3, state, ref b, ref k);
+                        j = 3 + (b & 7);
+                        ZIPDUMPBITS(3, ref b, ref k);
+                        if ((uint)i + j > n)
+                            return 1;
+                        while (j-- > 0)
+                            state.ll[i++] = 0;
+                        l = 0;
+                    }
+                    else                        /* j == 18: 11 to 138 zero length codes */
+                    {
+                        ZIPNEEDBITS(7, state, ref b, ref k);
+                        j = 11 + (b & 0x7f);
+                        ZIPDUMPBITS(7, ref b, ref k);
+                        if ((uint)i + j > n)
+                            return 1;
+                        while (j-- > 0)
+                            state.ll[i++] = 0;
+                        l = 0;
+                    }
+                }
+
+                /* restore the global bit buffer */
+                state.bb = b;
+                state.bk = k;
+
+                fixed (ushort* Zipcplens = CopyLengths)
+                fixed (ushort* Zipcplext = LiteralExtraBits)
+                fixed (ushort* Zipcpdist = CopyOffsets)
+                fixed (ushort* Zipcpdext = DistanceExtraBits)
+                {
+                    /* build the decoding tables for literal/length and distance codes */
+                    bl = ZIPLBITS;
+                    if ((i = BuildHuffmanTree(ll, nl, 257, Zipcplens, Zipcplext, &tl, &bl, state)) != 0)
+                    {
+                        return i;                   /* incomplete code set */
+                    }
+                    bd = ZIPDBITS;
+                    BuildHuffmanTree(ll + nl, nd, 0, Zipcpdist, Zipcpdext, &td, &bd, state);
+
+                    /* decompress until an end-of-block code */
+                    if (InflateCodes(tl, td, bl, bd, state, inbuf, outbuf) != 0)
+                        return 1;
+
+                    return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Build a Huffman tree from a set of lengths
+        /// </summary>
+        private static int BuildHuffmanTree(uint* b, uint n, uint s, ushort* d, ushort* e, HuffmanNode** t, int* m, State state)
+        {
+            uint a;                    /* counter for codes of length k */
+            uint el;                   /* length of EOB code (value 256) */
+            uint f;                    /* i repeats in table every f entries */
+            int g;                     /* maximum code length */
+            int h;                     /* table level */
+            uint i;                    /* counter, current code */
+            uint j;                    /* counter */
+            int k;                     /* number of bits in current code */
+            int* l;                    /* stack of bits per table */
+            uint* p;                   /* pointer into state.c[],state.b[],state.v[] */
+            HuffmanNode* q;            /* points to current table */
+            HuffmanNode r = new HuffmanNode();  /* table entry for structure assignment */
+            int w;                     /* bits before this table == (l * h) */
+            uint* xp;                  /* pointer into x */
+            int y;                     /* number of dummy codes added */
+            uint z;                    /* number of entries in current table */
+
+            fixed (int* state_lx_ptr = state.lx)
+            {
+                l = state_lx_ptr + 1;
+
+                /* Generate counts for each bit length */
+                el = n > 256 ? b[256] : ZIPBMAX; /* set length of EOB code, if any */
+
+                for (i = 0; i < ZIPBMAX + 1; ++i)
+                    state.c[i] = 0;
+                p = b; i = n;
+                do
+                {
+                    state.c[*p]++; p++;               /* assume all entries <= ZIPBMAX */
+                } while (--i > 0);
+
+                if (state.c[0] == n)                /* null input--all zero length codes */
+                {
+                    *t = null;
+                    *m = 0;
+                    return 0;
+                }
+
+                /* Find minimum and maximum length, bound *m by those */
+                for (j = 1; j <= ZIPBMAX; j++)
+                {
+                    if (state.c[j] > 0)
+                        break;
+                }
+
+                k = (int)j;                        /* minimum code length */
+                if ((uint)*m < j)
+                    *m = (int)j;
+
+                for (i = ZIPBMAX; i > 0; i--)
+                {
+                    if (state.c[i] > 0)
+                        break;
+                }
+
+                g = (int)i;                        /* maximum code length */
+                if ((uint)*m > i)
+                    *m = (int)i;
+
+                /* Adjust last length count to fill out codes, if needed */
+                for (y = 1 << (int)j; j < i; j++, y <<= 1)
+                {
+                    if ((y -= (int)state.c[j]) < 0)
+                        return 2;                 /* bad input: more codes than bits */
+                }
+
+                if ((y -= (int)state.c[i]) < 0)
+                    return 2;
+
+                state.c[i] += (uint)y;
+
+                /* Generate starting offsets LONGo the value table for each length */
+                state.x[1] = j = 0;
+
+                fixed (uint* state_c_ptr = state.c)
+                fixed (uint* state_x_ptr = state.x)
+                {
+                    p = state_c_ptr + 1;
+                    xp = state_x_ptr + 2;
+                    while (--i > 0)
+                    {
+                        /* note that i == g from above */
+                        *xp++ = (j += *p++);
+                    }
+                }
+
+                /* Make a table of values in order of bit lengths */
+                p = b; i = 0;
+                do
+                {
+                    if ((j = *p++) != 0)
+                        state.v[state.x[j]++] = i;
+                } while (++i < n);
+
+                /* Generate the Huffman codes and for each, make the table entries */
+                state.x[0] = i = 0;                 /* first Huffman code is zero */
+
+                fixed (uint* state_v_ptr = state.v)
+                {
+                    p = state_v_ptr;                    /* grab values in bit order */
+                    h = -1;                             /* no tables yet--level -1 */
+                    w = l[-1] = 0;                      /* no bits decoded yet */
+                    state.u[0] = default;               /* just to keep compilers happy */
+                    q = null;                           /* ditto */
+                    z = 0;                              /* ditto */
+
+                    /* go through the bit lengths (k already is bits in shortest code) */
+                    for (; k <= g; k++)
+                    {
+                        a = state.c[k];
+                        while (a-- > 0)
+                        {
+                            /* here i is the Huffman code of length k bits for value *p */
+                            /* make tables up to required level */
+                            while (k > w + l[h])
+                            {
+                                w += l[h++];            /* add bits already decoded */
+
+                                /* compute minimum size table less than or equal to *m bits */
+                                if ((z = (uint)(g - w)) > (uint)*m)    /* upper limit */
+                                    z = (uint)*m;
+
+                                if ((f = (uint)(1 << (int)(j = (uint)(k - w)))) > a + 1)     /* try a k-w bit table */
+                                {                       /* too few codes for k-w bit table */
+                                    f -= a + 1;           /* deduct codes from patterns left */
+                                    fixed (uint* state_c_ptr = state.c)
+                                    {
+                                        xp = state_c_ptr + k;
+                                        while (++j < z)       /* try smaller tables up to z bits */
+                                        {
+                                            if ((f <<= 1) <= *++xp)
+                                                break;            /* enough codes to use up j bits */
+                                            f -= *xp;           /* else deduct codes from patterns */
+                                        }
+                                    }
+                                }
+
+                                if ((uint)w + j > el && (uint)w < el)
+                                    j = (uint)(el - w);           /* make EOB code end at table */
+
+                                z = (uint)(1 << (int)j);             /* table entries for j-bit table */
+                                l[h] = (int)j;               /* set table size in stack */
+
+                                /* allocate and link in new table */
+                                q = (HuffmanNode*)Marshal.AllocHGlobal((int)((z + 1) * sizeof(HuffmanNode)));
+                                *t = q + 1;             /* link to list for HuffmanNode_free() */
+                                *(t = &(*q).t) = null;
+                                state.u[h] = ++q;             /* table starts after link */
+
+                                /* connect to last table, if there is one */
+                                if (h > 0)
+                                {
+                                    state.x[h] = i;              /* save pattern for backing up */
+                                    r.b = (byte)l[h - 1];        /* bits to dump before this table */
+                                    r.e = (byte)(16 + j);        /* bits in this table */
+                                    r.t = q;                     /* pointer to this table */
+                                    j = (uint)((i & ((1 << w) - 1)) >> (w - l[h - 1]));
+                                    state.u[h - 1][j] = r;       /* connect to last table */
+                                }
+                            }
+
+                            /* set up table entry in r */
+                            r.b = (byte)(k - w);
+
+                            fixed (uint* state_v_ptr_comp = state.v)
+                            {
+                                if (p >= state_v_ptr_comp + n)
+                                {
+                                    r.e = 99;               /* out of values--invalid code */
+                                }
+                                else if (*p < s)
+                                {
+                                    r.e = (byte)(*p < 256 ? 16 : 15);    /* 256 is end-of-block code */
+                                    r.n = (ushort)*p++;           /* simple code is just the value */
+                                }
+                                else
+                                {
+                                    r.e = (byte)e[*p - s];   /* non-simple--look up in lists */
+                                    r.n = d[*p++ - s];
+                                }
+                            }
+
+                            /* fill code-like entries with r */
+                            f = (uint)(1 << (k - w));
+                            for (j = i >> w; j < z; j += f)
+                            {
+                                q[j] = r;
+                            }
+
+                            /* backwards increment the k-bit code i */
+                            for (j = (uint)(1 << (k - 1)); (i & j) != 0; j >>= 1)
+                            {
+                                i ^= j;
+                            }
+
+                            i ^= j;
+
+                            /* backup over finished tables */
+                            while ((i & ((1 << w) - 1)) != state.x[h])
+                                w -= l[--h];            /* don't need to update q */
+                        }
+                    }
+                }
+
+                /* return actual size of base table */
+                *m = l[0];
+            }
+
+            /* Return true (1) if we were given an incomplete table */
+            return y != 0 && g != 1 ? 1 : 0;
+        }
+
+        /// <summary>
+        /// Inflate codes into Huffman trees
+        /// </summary>
+        private static int InflateCodes(HuffmanNode* tl, HuffmanNode* td, int bl, int bd, State state, byte[] inbuf, byte[] outbuf)
+        {
+            uint e;              /* table entry flag/number of extra bits */
+            uint n, d;           /* length and index for copy */
+            uint w;              /* current window position */
+            HuffmanNode* t;      /* pointer to table entry */
+            uint ml, md;         /* masks for bl and bd bits */
+            uint b;              /* bit buffer */
+            uint k;              /* number of bits in bit buffer */
+
+            /* make local copies of globals */
+            b = state.bb;                       /* initialize bit buffer */
+            k = state.bk;
+            w = state.window_posn;                       /* initialize window position */
+
+            /* inflate the coded data */
+            ml = BitMasks[bl];               /* precompute masks for speed */
+            md = BitMasks[bd];
+
+            for (; ; )
+            {
+                ZIPNEEDBITS(bl, state, ref b, ref k);
+                if ((e = (t = tl + (b & ml))->e) > 16)
+                {
+                    do
+                    {
+                        if (e == 99)
+                            return 1;
+                        ZIPDUMPBITS(t->b, ref b, ref k);
+                        e -= 16;
+                        ZIPNEEDBITS((int)e, state, ref b, ref k);
+                    } while ((e = (*(t = t->t + (b & BitMasks[e]))).e) > 16);
+                }
+
+                ZIPDUMPBITS(t->b, ref b, ref k);
+                if (e == 16)                /* then it's a literal */
+                {
+                    outbuf[w++] = (byte)t->n;
+                }
+                else                        /* it's an EOB or a length */
+                {
+                    /* exit if end of block */
+                    if (e == 15)
+                        break;
+
+                    /* get length of block to copy */
+                    ZIPNEEDBITS((int)e, state, ref b, ref k);
+                    n = t->n + (b & BitMasks[e]);
+                    ZIPDUMPBITS((int)e, ref b, ref k);
+
+                    /* decode distance of block to copy */
+                    ZIPNEEDBITS(bd, state, ref b, ref k);
+
+                    if ((e = (*(t = td + (b & md))).e) > 16)
+                        do
+                        {
+                            if (e == 99)
+                                return 1;
+                            ZIPDUMPBITS(t->b, ref b, ref k);
+                            e -= 16;
+                            ZIPNEEDBITS((int)e, state, ref b, ref k);
+                        } while ((e = (*(t = t->t + (b & BitMasks[e]))).e) > 16);
+
+                    ZIPDUMPBITS(t->b, ref b, ref k);
+
+                    ZIPNEEDBITS((int)e, state, ref b, ref k);
+                    d = w - t->n - (b & BitMasks[e]);
+                    ZIPDUMPBITS((int)e, ref b, ref k);
+
+                    do
+                    {
+                        d &= ZIPWSIZE - 1;
+                        e = ZIPWSIZE - Math.Max(d, w);
+                        e = Math.Min(e, n);
+                        n -= e;
+                        do
+                        {
+                            outbuf[w++] = outbuf[d++];
+                        } while (--e > 0);
+                    } while (n > 0);
+                }
+            }
+
+            /* restore the globals from the locals */
+            state.window_posn = w;              /* restore global window pointer */
+            state.bb = b;                       /* restore global bit buffer */
+            state.bk = k;
+
+            /* done */
+            return 0;
+        }
+
+        #region Macros
+
+        private static void ZIPNEEDBITS(int n, State state, ref uint bitBuffer, ref uint bitCount)
+        {
+            while (bitCount < n)
+            {
+                int c = *state.inpos++;
+                bitBuffer |= (uint)(c << (int)bitCount);
+                bitCount += 8;
+            }
+        }
+
+        private static void ZIPDUMPBITS(int n, ref uint bitBuffer, ref uint bitCount)
+        {
+            bitBuffer >>= n;
+            bitCount -= (uint)n;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/MSZIP/HuffmanNode.cs

@@ -0,0 +1,29 @@
+namespace BinaryObjectScanner.Compression.MSZIP
+{
+    public unsafe struct HuffmanNode
+    {
+        /// <summary>
+        /// Number of extra bits or operation
+        /// </summary>
+        public byte e;
+
+        /// <summary>
+        /// Number of bits in this code or subcode
+        /// </summary>
+        public byte b;
+
+        #region v
+
+        /// <summary>
+        /// Literal, length base, or distance base
+        /// </summary>
+        public ushort n;
+
+        /// <summary>
+        /// Pointer to next level of table
+        /// </summary>
+        public HuffmanNode* t;
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/MSZIP/State.cs

@@ -0,0 +1,56 @@
+using static BinaryObjectScanner.Models.Compression.MSZIP.Constants;
+
+namespace BinaryObjectScanner.Compression.MSZIP
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
+    public unsafe class State
+    {
+        /// <summary>
+        /// Current offset within the window
+        /// </summary>
+        public uint window_posn;
+
+        /// <summary>
+        /// Bit buffer
+        /// </summary>
+        public uint bb;
+
+        /// <summary>
+        /// Bits in bit buffer
+        /// </summary>
+        public uint bk;
+
+        /// <summary>
+        /// Literal/length and distance code lengths
+        /// </summary>
+        public uint[] ll = new uint[288 + 32];
+
+        /// <summary>
+        /// Bit length count table
+        /// </summary>
+        public uint[] c = new uint[ZIPBMAX + 1];
+
+        /// <summary>
+        /// Memory for l[-1..ZIPBMAX-1]
+        /// </summary>
+        public int[] lx = new int[ZIPBMAX + 1];
+
+        /// <summary>
+        /// Table stack
+        /// </summary>
+        public HuffmanNode*[] u = new HuffmanNode*[ZIPBMAX];
+
+        /// <summary>
+        /// Values in order of bit length
+        /// </summary>
+        public uint[] v = new uint[ZIPN_MAX];
+
+        /// <summary>
+        /// Bit offsets, then code stack
+        /// </summary>
+        public uint[] x = new uint[ZIPBMAX + 1];
+
+        /// <remarks>byte*</remarks>
+        public byte* inpos;
+    }
+}

BinaryObjectScanner.Compression/Quantum/Decompressor.cs

@@ -0,0 +1,499 @@
+using System;
+using System.Linq;
+using BinaryObjectScanner.Models.Compression.Quantum;
+using BinaryObjectScanner.Models.MicrosoftCabinet;
+
+namespace BinaryObjectScanner.Compression.Quantum
+{
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/fdi.c"/>
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/include/fdi.h"/>
+    /// <see href="http://www.russotto.net/quantumcomp.html"/>
+    public static class Decompressor
+    {
+        /// <summary>
+        /// Decompress a byte array using a given State
+        /// </summary>
+        public static int Decompress(State state, int inlen, byte[] inbuf, int outlen, byte[] outbuf)
+        {
+            int inpos = 0, outpos = 0; // inbuf[0], outbuf[0]
+            int window = 0; // state.Window[0]
+            int runsrc, rundest;
+            uint windowPosition = state.WindowPosition;
+            uint windowSize = state.WindowSize;
+
+            int extra, togo = outlen, matchLength = 0, copyLength;
+            byte selector, sym;
+            uint matchOffset = 0;
+
+            // Make local copies of state variables
+            uint bitBuffer = state.BitBuffer;
+            int bitsLeft = state.BitsLeft;
+
+            ushort H = 0xFFFF, L = 0;
+
+            // Read initial value of C
+            ushort C = (ushort)Q_READ_BITS(16, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+
+            // Apply 2^x-1 mask
+            windowPosition &= windowSize - 1;
+
+            while (togo > 0)
+            {
+                selector = (byte)GET_SYMBOL(state.SelectorModel, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                switch (selector)
+                {
+                    // Selector 0 = literal model, 64 entries, 0x00-0x3F
+                    case 0:
+                        sym = (byte)GET_SYMBOL(state.Model0, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        state.Window[window + windowPosition++] = sym;
+                        togo--;
+                        break;
+
+                    // Selector 1 = literal model, 64 entries, 0x40-0x7F
+                    case 1:
+                        sym = (byte)GET_SYMBOL(state.Model1, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        state.Window[window + windowPosition++] = sym;
+                        togo--;
+                        break;
+
+                    // Selector 2 = literal model, 64 entries, 0x80-0xBF
+                    case 2:
+                        sym = (byte)GET_SYMBOL(state.Model2, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        state.Window[window + windowPosition++] = sym;
+                        togo--;
+                        break;
+
+                    // Selector 3 = literal model, 64 entries, 0xC0-0xFF
+                    case 3:
+                        sym = (byte)GET_SYMBOL(state.Model3, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        state.Window[window + windowPosition++] = sym;
+                        togo--;
+                        break;
+
+                    // Selector 4 = fixed length of 3
+                    case 4:
+                        sym = (byte)GET_SYMBOL(state.Model4, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        extra = (int)Q_READ_BITS(state.ExtraBits[sym], inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        matchOffset = (uint)(state.PositionSlotBases[sym] + extra + 1);
+                        matchLength = 3;
+                        break;
+
+                    // Selector 5 = fixed length of 4
+                    case 5:
+                        sym = (byte)GET_SYMBOL(state.Model5, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        extra = (int)Q_READ_BITS(state.ExtraBits[sym], inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        matchOffset = (uint)(state.PositionSlotBases[sym] + extra + 1);
+                        matchLength = 4;
+                        break;
+
+                    // Selector 6 = variable length
+                    case 6:
+                        sym = (byte)GET_SYMBOL(state.Model6Length, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        extra = (int)Q_READ_BITS(state.LengthExtraBits[sym], inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        matchLength = state.LengthBases[sym] + extra + 5;
+
+                        sym = (byte)GET_SYMBOL(state.Model6Position, ref H, ref L, ref C, inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        extra = (int)Q_READ_BITS(state.ExtraBits[sym], inbuf, ref inpos, ref bitsLeft, ref bitBuffer);
+                        matchOffset = (uint)(state.PositionSlotBases[sym] + extra + 1);
+                        break;
+
+                    default:
+                        return inpos;
+                }
+
+                // If this is a match
+                if (selector >= 4)
+                {
+                    rundest = (int)(window + windowPosition);
+                    togo -= matchLength;
+
+                    // Copy any wrapped around source data
+                    if (windowPosition >= matchOffset)
+                    {
+                        // No wrap
+                        runsrc = (int)(rundest - matchOffset);
+                    }
+                    else
+                    {
+                        runsrc = (int)(rundest + (windowSize - matchOffset));
+                        copyLength = (int)(matchOffset - windowPosition);
+                        if (copyLength < matchLength)
+                        {
+                            matchLength -= copyLength;
+                            windowPosition += (uint)copyLength;
+                            while (copyLength-- > 0)
+                            {
+                                state.Window[rundest++] = state.Window[rundest++];
+                            }
+
+                            runsrc = window;
+                        }
+                    }
+
+                    windowPosition += (uint)matchLength;
+
+                    // Copy match data - no worries about destination wraps
+                    while (matchLength-- > 0)
+                    {
+                        state.Window[rundest++] = state.Window[runsrc++];
+
+                        // Handle wraparounds that aren't supposed to happen
+                        if (rundest >= state.Window.Length)
+                            rundest = 0;
+                        if (runsrc >= state.Window.Length)
+                            runsrc = 0;
+                    }
+                }
+
+                // If we hit the end of the window, copy to the output and wrap
+                if (windowPosition >= state.Window.Length)
+                {
+                    Array.Copy(state.Window, 0, outbuf, outpos, Math.Min(windowSize, outlen));
+                    outpos += (int)Math.Min(windowSize, outlen);
+                    outlen -= (int)Math.Min(windowSize, outlen);
+                    windowPosition = 0;
+                }
+            }
+
+            if (togo > 0)
+                return inpos;
+
+            if (outlen > 0)
+            {
+                int sourceIndex = (int)((windowPosition == 0 ? windowSize : windowPosition) - outlen);
+                Array.Copy(state.Window, sourceIndex, outbuf, outpos, outlen);
+            }
+
+            // Cache the decompression state variables
+            state.BitBuffer = bitBuffer;
+            state.BitsLeft = bitsLeft;
+            state.WindowPosition = windowPosition;
+
+            return inpos;
+        }
+
+        /// <summary>
+        /// Initialize a Quantum decompressor state
+        /// </summary>
+        public static bool InitState(State state, CFFOLDER folder)
+        {
+            int window = ((ushort)folder.CompressionType >> 8) & 0x1f;
+            int level = ((ushort)folder.CompressionType >> 4) & 0xF;
+            return InitState(state, window, level);
+        }
+
+        /// <summary>
+        /// Initialize a Quantum decompressor state
+        /// </summary>
+        public static bool InitState(State state, int window, int level)
+        {
+            uint windowSize = (uint)(1 << window);
+            int maxSize = window * 2;
+
+            // QTM supports window sizes of 2^10 (1Kb) through 2^21 (2Mb)
+            // If a previously allocated window is big enough, keep it
+            if (window < 10 || window > 21)
+                return false;
+
+            // If we don't have the proper window size
+            if (state.ActualSize < windowSize)
+                state.Window = null;
+
+            // If we have no window
+            if (state.Window == null)
+            {
+                state.Window = new byte[windowSize];
+                state.ActualSize = windowSize;
+            }
+
+            // Set the window size and position
+            state.WindowSize = windowSize;
+            state.WindowPosition = 0;
+
+            // Initialize arithmetic coding models
+            state.SelectorModel = CreateModel(state.SelectorModelSymbols, 7, 0);
+
+            state.Model0 = CreateModel(state.Model0Symbols, 0x40, 0x00);
+            state.Model1 = CreateModel(state.Model1Symbols, 0x40, 0x40);
+            state.Model2 = CreateModel(state.Model2Symbols, 0x40, 0x80);
+            state.Model3 = CreateModel(state.Model3Symbols, 0x40, 0xC0);
+
+            // Model 4 depends on table size, ranges from 20 to 24
+            state.Model4 = CreateModel(state.Model4Symbols, (maxSize < 24) ? maxSize : 24, 0);
+
+            // Model 5 depends on table size, ranges from 20 to 36
+            state.Model5 = CreateModel(symbols: state.Model5Symbols, (maxSize < 36) ? maxSize : 36, 0);
+
+            // Model 6 Position depends on table size, ranges from 20 to 42
+            state.Model6Position = CreateModel(state.Model6PositionSymbols, (maxSize < 42) ? maxSize : 42, 0);
+            state.Model6Length = CreateModel(state.Model6LengthSymbols, 27, 0);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Initialize a Quantum model that decodes symbols from s to (s + n - 1)
+        /// </summary>
+        private static Model CreateModel(ModelSymbol[] symbols, int entryCount, int initialSymbol)
+        {
+            // Set the basic values
+            Model model = new Model
+            {
+                TimeToReorder = 4,
+                Entries = entryCount,
+                Symbols = symbols,
+            };
+
+            // Clear out the look-up table
+            model.LookupTable = Enumerable.Repeat<ushort>(0xFFFF, model.LookupTable.Length).ToArray();
+
+            // Loop through and build the look-up table
+            for (ushort i = 0; i < entryCount; i++)
+            {
+                // Set up a look-up entry for symbol
+                model.LookupTable[i + initialSymbol] = i;
+
+                // Create the symbol in the table
+                model.Symbols[i] = new ModelSymbol
+                {
+                    Symbol = (ushort)(i + initialSymbol),
+                    CumulativeFrequency = (ushort)(entryCount - i),
+                };
+            }
+
+            // Set the last symbol frequency to 0
+            model.Symbols[entryCount] = new ModelSymbol { CumulativeFrequency = 0 };
+            return model;
+        }
+
+        /// <summary>
+        /// Update the Quantum model for a particular symbol
+        /// </summary>
+        private static void UpdateModel(Model model, int symbol)
+        {
+            // Update the cumulative frequency for all symbols less than the provided
+            for (int i = 0; i < symbol; i++)
+            {
+                model.Symbols[i].CumulativeFrequency += 8;
+            }
+
+            // If the first symbol still has a cumulative frequency under 3800
+            if (model.Symbols[0].CumulativeFrequency <= 3800)
+                return;
+
+            // If we have more than 1 shift left in the model
+            if (--model.TimeToReorder != 0)
+            {
+                // Loop through the entries from highest to lowest,
+                // performing the shift on the cumulative frequencies
+                for (int i = model.Entries - 1; i >= 0; i--)
+                {
+                    // -1, not -2; the 0 entry saves this
+                    model.Symbols[i].CumulativeFrequency >>= 1;
+                    if (model.Symbols[i].CumulativeFrequency <= model.Symbols[i + 1].CumulativeFrequency)
+                        model.Symbols[i].CumulativeFrequency = (ushort)(model.Symbols[i + 1].CumulativeFrequency + 1);
+                }
+            }
+
+            // If we have no shifts left in the model
+            else
+            {
+                // Reset the shifts left value to 50
+                model.TimeToReorder = 50;
+
+                // Loop through the entries setting the cumulative frequencies
+                for (int i = 0; i < model.Entries; i++)
+                {
+                    // No -1, want to include the 0 entry
+                    // This converts cumfreqs into frequencies, then shifts right
+                    model.Symbols[i].CumulativeFrequency -= model.Symbols[i + 1].CumulativeFrequency;
+                    model.Symbols[i].CumulativeFrequency++; // Avoid losing things entirely
+                    model.Symbols[i].CumulativeFrequency >>= 1;
+                }
+
+                // Now sort by frequencies, decreasing order -- this must be an
+                // inplace selection sort, or a sort with the same (in)stability
+                // characteristics
+                for (int i = 0; i < model.Entries - 1; i++)
+                {
+                    for (int j = i + 1; j < model.Entries; j++)
+                    {
+                        if (model.Symbols[i].CumulativeFrequency < model.Symbols[j].CumulativeFrequency)
+                        {
+                            var temp = model.Symbols[i];
+                            model.Symbols[i] = model.Symbols[j];
+                            model.Symbols[j] = temp;
+                        }
+                    }
+                }
+
+                // Then convert frequencies back to cumfreq
+                for (int i = model.Entries - 1; i >= 0; i--)
+                {
+                    model.Symbols[i].CumulativeFrequency += model.Symbols[i + 1].CumulativeFrequency;
+                }
+
+                // Then update the other part of the table
+                for (ushort i = 0; i < model.Entries; i++)
+                {
+                    model.LookupTable[model.Symbols[i].Symbol] = i;
+                }
+            }
+        }
+
+        // Bitstream reading macros (Quantum / normal byte order)
+        #region Macros
+
+        /* 
+        * These bit access routines work by using the area beyond the MSB and the
+        * LSB as a free source of zeroes. This avoids having to mask any bits.
+        * So we have to know the bit width of the bitbuffer variable. This is
+        * defined as Uint_BITS.
+        *
+        * Uint_BITS should be at least 16 bits. Unlike LZX's Huffman decoding,
+        * Quantum's arithmetic decoding only needs 1 bit at a time, it doesn't
+        * need an assured number. Retrieving larger bitstrings can be done with
+        * multiple reads and fills of the bitbuffer. The code should work fine
+        * for machines where Uint >= 32 bits.
+        *
+        * Also note that Quantum reads bytes in normal order; LZX is in
+        * little-endian order.
+        */
+
+        /// <summary>
+        /// Should be used first to set up the system
+        /// </summary>
+        private static void Q_INIT_BITSTREAM(out int bitsleft, out uint bitbuf)
+        {
+            bitsleft = 0;
+            bitbuf = 0;
+        }
+
+        /// <summary>
+        /// Adds more data to the bit buffer, if there is room for another 16 bits.
+        /// </summary>
+        private static void Q_FILL_BUFFER(byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            if (bitsleft > 8)
+                return;
+
+            byte b0 = inpos + 0 < inbuf.Length ? inbuf[inpos + 0] : (byte)0;
+            byte b1 = inpos + 1 < inbuf.Length ? inbuf[inpos + 1] : (byte)0;
+
+            bitbuf |= (uint)(((b0 << 8) | b1) << (16 - bitsleft));
+            bitsleft += 16;
+            inpos += 2;
+        }
+
+        /// <summary>
+        /// Extracts (without removing) N bits from the bit buffer
+        /// </summary>
+        private static uint Q_PEEK_BITS(int n, uint bitbuf)
+        {
+            return bitbuf >> (32 - n);
+        }
+
+        /// <summary>
+        /// Removes N bits from the bit buffer
+        /// </summary>
+        private static void Q_REMOVE_BITS(int n, ref int bitsleft, ref uint bitbuf)
+        {
+            bitbuf <<= n;
+            bitsleft -= n;
+        }
+
+        /// <summary>
+        /// Takes N bits from the buffer and puts them in v. Unlike LZX, this can loop
+        /// several times to get the requisite number of bits.
+        /// </summary>
+        private static uint Q_READ_BITS(int n, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            uint v = 0; int bitrun;
+            for (int bitsneed = n; bitsneed != 0; bitsneed -= bitrun)
+            {
+                Q_FILL_BUFFER(inbuf, ref inpos, ref bitsleft, ref bitbuf);
+                bitrun = (bitsneed > bitsleft) ? bitsleft : bitsneed;
+                v = (v << bitrun) | Q_PEEK_BITS(bitrun, bitbuf);
+                Q_REMOVE_BITS(bitrun, ref bitsleft, ref bitbuf);
+            }
+
+            return v;
+        }
+
+        /// <summary>
+        /// Fetches the next symbol from the stated model and puts it in symbol.
+        /// It may need to read the bitstream to do this.
+        /// </summary>
+        private static ushort GET_SYMBOL(Model model, ref ushort H, ref ushort L, ref ushort C, byte[] inbuf, ref int inpos, ref int bitsleft, ref uint bitbuf)
+        {
+            ushort symf = GetFrequency(model.Symbols[0].CumulativeFrequency, H, L, C);
+
+            int i;
+            for (i = 1; i < model.Entries; i++)
+            {
+                if (model.Symbols[i].CumulativeFrequency <= symf)
+                    break;
+            }
+
+            ushort symbol = model.Symbols[i - 1].Symbol;
+            GetCode(model.Symbols[i - 1].CumulativeFrequency,
+                model.Symbols[i].CumulativeFrequency,
+                model.Symbols[0].CumulativeFrequency,
+                ref H, ref L, ref C,
+                inbuf, ref inpos, ref bitsleft, ref bitbuf);
+
+            UpdateModel(model, i);
+            return symbol;
+        }
+
+        /// <summary>
+        /// Get the frequency for a given range and total frequency
+        /// </summary>
+        private static ushort GetFrequency(ushort totalFrequency, ushort H, ushort L, ushort C)
+        {
+            uint range = (uint)(((H - L) & 0xFFFF) + 1);
+            uint freq = (uint)(((C - L + 1) * totalFrequency - 1) / range);
+            return (ushort)(freq & 0xFFFF);
+        }
+
+        /// <summary>
+        /// The decoder renormalization loop
+        /// </summary>
+        private static void GetCode(int previousFrequency,
+            int cumulativeFrequency,
+            int totalFrequency,
+            ref ushort H,
+            ref ushort L,
+            ref ushort C,
+            byte[] inbuf,
+            ref int inpos,
+            ref int bitsleft,
+            ref uint bitbuf)
+        {
+            uint range = (uint)((H - L) + 1);
+            H = (ushort)(L + ((previousFrequency * range) / totalFrequency) - 1);
+            L = (ushort)(L + (cumulativeFrequency * range) / totalFrequency);
+
+            while (true)
+            {
+                if ((L & 0x8000) != (H & 0x8000))
+                {
+                    if ((L & 0x4000) == 0 || (H & 0x4000) != 0)
+                        break;
+
+                    // Underflow case
+                    C ^= 0x4000;
+                    L &= 0x3FFF;
+                    H |= 0x4000;
+                }
+
+                L <<= 1;
+                H = (ushort)((H << 1) | 1);
+                C = (ushort)((C << 1) | Q_READ_BITS(1, inbuf, ref inpos, ref bitsleft, ref bitbuf));
+            }
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/Quantum/State.cs

@@ -0,0 +1,193 @@
+using BinaryObjectScanner.Models.Compression.Quantum;
+
+namespace BinaryObjectScanner.Compression.Quantum
+{
+    /// <see href="https://github.com/kyz/libmspack/blob/master/libmspack/mspack/qtmd.c"/>
+    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
+    public class State
+    {
+        /// <summary>
+        /// The actual decoding window
+        /// </summary>
+        public byte[] Window;
+
+        /// <summary>
+        /// Window size (1Kb through 2Mb)
+        /// </summary>
+        public uint WindowSize;
+
+        /// <summary>
+        /// Window size when it was first allocated
+        /// </summary>
+        public uint ActualSize;
+
+        /// <summary>
+        /// Current offset within the window
+        /// </summary>
+        public uint WindowPosition;
+
+        #region Models
+
+        /// <summary>
+        /// Symbol table for selector model
+        /// </summary>
+        public ModelSymbol[] SelectorModelSymbols = new ModelSymbol[7 + 1];
+
+        /// <summary>
+        /// Model for selector values
+        /// </summary>
+        public Model SelectorModel;
+
+        /// <summary>
+        /// Model for Selector 0
+        /// </summary>
+        public Model Model0;
+
+        /// <summary>
+        /// Model for Selector 1
+        /// </summary>
+        public Model Model1;
+
+        /// <summary>
+        /// Model for Selector 2
+        /// </summary>
+        public Model Model2;
+
+        /// <summary>
+        /// Model for Selector 3
+        /// </summary>
+        public Model Model3;
+
+        /// <summary>
+        /// Model for Selector 4
+        /// </summary>
+        public Model Model4;
+
+        /// <summary>
+        /// Model for Selector 5
+        /// </summary>
+        public Model Model5;
+
+        /// <summary>
+        /// Model for Selector 6 Position
+        /// </summary>
+        public Model Model6Position;
+
+        /// <summary>
+        /// Model for Selector 6 Length
+        /// </summary>
+        public Model Model6Length;
+
+        #endregion
+
+        #region Symbol Tables
+
+        /// <summary>
+        /// Symbol table for Selector 0
+        /// </summary>
+        public ModelSymbol[] Model0Symbols = new ModelSymbol[0x40 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 1
+        /// </summary>
+        public ModelSymbol[] Model1Symbols = new ModelSymbol[0x40 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 2
+        /// </summary>
+        public ModelSymbol[] Model2Symbols = new ModelSymbol[0x40 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 3
+        /// </summary>
+        public ModelSymbol[] Model3Symbols = new ModelSymbol[0x40 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 4
+        /// </summary>
+        public ModelSymbol[] Model4Symbols = new ModelSymbol[0x18 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 5
+        /// </summary>
+        public ModelSymbol[] Model5Symbols = new ModelSymbol[0x24 + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 6 Position
+        /// </summary>
+        public ModelSymbol[] Model6PositionSymbols = new ModelSymbol[0x2a + 1];
+
+        /// <summary>
+        /// Symbol table for Selector 6 Length
+        /// </summary>
+        public ModelSymbol[] Model6LengthSymbols = new ModelSymbol[0x1b + 1];
+
+        #endregion
+
+        #region Decompression Tables
+
+        /// <summary>
+        /// An index to the position slot bases
+        /// </summary>
+        public uint[] PositionSlotBases = new uint[42]
+        {
+            0x00000, 0x00001, 0x00002, 0x00003, 0x00004, 0x00006, 0x00008, 0x0000c,
+            0x00010, 0x00018, 0x00020, 0x00030, 0x00040, 0x00060, 0x00080, 0x000c0,
+            0x00100, 0x00180, 0x00200, 0x00300, 0x00400, 0x00600, 0x00800, 0x00c00,
+            0x01000, 0x01800, 0x02000, 0x03000, 0x04000, 0x06000, 0x08000, 0x0c000,
+            0x10000, 0x18000, 0x20000, 0x30000, 0x40000, 0x60000, 0x80000, 0xc0000,
+            0x100000, 0x180000
+        };
+
+        /// <summary>
+        /// How many bits of offset-from-base data is needed
+        /// </summary>
+        public byte[] ExtraBits = new byte[42]
+        {
+            0,  0,  0,  0,  1,  1,  2,  2,
+            3,  3,  4,  4,  5,  5,  6,  6,
+            7,  7,  8,  8,  9,  9, 10, 10,
+            11, 11, 12, 12, 13, 13, 14, 14,
+            15, 15, 16, 16, 17, 17, 18, 18,
+            19, 19
+        };
+
+        /// <summary>
+        /// An index to the position slot bases [Selector 6]
+        /// </summary>
+        public byte[] LengthBases = new byte[27]
+        {
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
+            0x0a, 0x0c, 0x0e, 0x12, 0x16, 0x1a, 0x1e, 0x26,
+            0x2e, 0x36, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e, 0x9e,
+            0xbe, 0xde, 0xfe
+        };
+
+        /// <summary>
+        /// How many bits of offset-from-base data is needed [Selector 6]
+        /// </summary>
+        public byte[] LengthExtraBits = new byte[27]
+        {
+            0,  0,  0,  0,  0,  0,  1,  1,
+            1,  1,  2,  2,  2,  2,  3,  3,
+            3,  3,  4,  4,  4,  4,  5,  5,
+            5,  5,  0
+        };
+
+        #endregion
+
+        #region Decompression State
+
+        /// <summary>
+        /// Bit buffer to persist between runs
+        /// </summary>
+        public uint BitBuffer = 0;
+
+        /// <summary>
+        /// Bits remaining to persist between runs
+        /// </summary>
+        public int BitsLeft = 0;
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/bzip2/Constants.cs

@@ -0,0 +1,304 @@
+namespace BinaryObjectScanner.Compression.bzip2
+{
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/bzlib.h"/>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/bzlib_private.h"/>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/blocksort.c"/>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/crctable.c"/>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/randtable.c"/>
+    public static class Constants
+    {
+        #region bzlib.h
+
+        public const int BZ_RUN = 0;
+        public const int BZ_FLUSH = 1;
+        public const int BZ_FINISH = 2;
+
+        public const int BZ_OK = 0;
+        public const int BZ_RUN_OK = 1;
+        public const int BZ_FLUSH_OK = 2;
+        public const int BZ_FINISH_OK = 3;
+        public const int BZ_STREAM_END = 4;
+        public const int BZ_SEQUENCE_ERROR = (-1);
+        public const int BZ_PARAM_ERROR = (-2);
+        public const int BZ_MEM_ERROR = (-3);
+        public const int BZ_DATA_ERROR = (-4);
+        public const int BZ_DATA_ERROR_MAGIC = (-5);
+        public const int BZ_IO_ERROR = (-6);
+        public const int BZ_UNEXPECTED_EOF = (-7);
+        public const int BZ_OUTBUFF_FULL = (-8);
+        public const int BZ_CONFIG_ERROR = (-9);
+
+        public const int BZ_MAX_UNUSED = 5000;
+
+        #endregion
+
+        #region bzlib_private.h
+
+        internal const string BZ_VERSION = "1.0.5, 10-Dec-2007";
+
+        /*-- Header bytes. --*/
+
+        internal const byte BZ_HDR_B = 0x42;   /* 'B' */
+        internal const byte BZ_HDR_Z = 0x5a;   /* 'Z' */
+        internal const byte BZ_HDR_h = 0x68;   /* 'h' */
+        internal const byte BZ_HDR_0 = 0x30;   /* '0' */
+
+        /*-- Constants for the back end. --*/
+
+        internal const int BZ_MAX_ALPHA_SIZE = 258;
+        internal const int BZ_MAX_CODE_LEN = 23;
+
+        internal const int BZ_RUNA = 0;
+        internal const int BZ_RUNB = 1;
+
+        internal const int BZ_N_GROUPS = 6;
+        internal const int BZ_G_SIZE = 50;
+        internal const int BZ_N_ITERS = 4;
+
+        internal const int BZ_MAX_SELECTORS = (2 + (900000 / BZ_G_SIZE));
+
+        /*-- States and modes for compression. --*/
+
+        internal const int BZ_M_IDLE = 1;
+        internal const int BZ_M_RUNNING = 2;
+        internal const int BZ_M_FLUSHING = 3;
+        internal const int BZ_M_FINISHING = 4;
+
+        internal const int BZ_S_OUTPUT = 1;
+        internal const int BZ_S_INPUT = 2;
+
+        internal const int BZ_N_RADIX = 2;
+        internal const int BZ_N_QSORT = 12;
+        internal const int BZ_N_SHELL = 18;
+        internal const int BZ_N_OVERSHOOT = (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2);
+
+        /*-- states for decompression. --*/
+
+        internal const int BZ_X_IDLE = 1;
+        internal const int BZ_X_OUTPUT = 2;
+
+        internal const int BZ_X_MAGIC_1 = 10;
+        internal const int BZ_X_MAGIC_2 = 11;
+        internal const int BZ_X_MAGIC_3 = 12;
+        internal const int BZ_X_MAGIC_4 = 13;
+        internal const int BZ_X_BLKHDR_1 = 14;
+        internal const int BZ_X_BLKHDR_2 = 15;
+        internal const int BZ_X_BLKHDR_3 = 16;
+        internal const int BZ_X_BLKHDR_4 = 17;
+        internal const int BZ_X_BLKHDR_5 = 18;
+        internal const int BZ_X_BLKHDR_6 = 19;
+        internal const int BZ_X_BCRC_1 = 20;
+        internal const int BZ_X_BCRC_2 = 21;
+        internal const int BZ_X_BCRC_3 = 22;
+        internal const int BZ_X_BCRC_4 = 23;
+        internal const int BZ_X_RANDBIT = 24;
+        internal const int BZ_X_ORIGPTR_1 = 25;
+        internal const int BZ_X_ORIGPTR_2 = 26;
+        internal const int BZ_X_ORIGPTR_3 = 27;
+        internal const int BZ_X_MAPPING_1 = 28;
+        internal const int BZ_X_MAPPING_2 = 29;
+        internal const int BZ_X_SELECTOR_1 = 30;
+        internal const int BZ_X_SELECTOR_2 = 31;
+        internal const int BZ_X_SELECTOR_3 = 32;
+        internal const int BZ_X_CODING_1 = 33;
+        internal const int BZ_X_CODING_2 = 34;
+        internal const int BZ_X_CODING_3 = 35;
+        internal const int BZ_X_MTF_1 = 36;
+        internal const int BZ_X_MTF_2 = 37;
+        internal const int BZ_X_MTF_3 = 38;
+        internal const int BZ_X_MTF_4 = 39;
+        internal const int BZ_X_MTF_5 = 40;
+        internal const int BZ_X_MTF_6 = 41;
+        internal const int BZ_X_ENDHDR_2 = 42;
+        internal const int BZ_X_ENDHDR_3 = 43;
+        internal const int BZ_X_ENDHDR_4 = 44;
+        internal const int BZ_X_ENDHDR_5 = 45;
+        internal const int BZ_X_ENDHDR_6 = 46;
+        internal const int BZ_X_CCRC_1 = 47;
+        internal const int BZ_X_CCRC_2 = 48;
+        internal const int BZ_X_CCRC_3 = 49;
+        internal const int BZ_X_CCRC_4 = 50;
+
+        /*-- Constants for the fast MTF decoder. --*/
+
+        internal const int MTFA_SIZE = 4096;
+        internal const int MTFL_SIZE = 16;
+
+        #endregion
+
+        #region blocksort.c
+
+        internal const int FALLBACK_QSORT_SMALL_THRESH = 10;
+
+        internal const int FALLBACK_QSORT_STACK_SIZE = 100;
+
+        /*--
+            Knuth's increments seem to work better
+            than Incerpi-Sedgewick here.  Possibly
+            because the number of elems to sort is
+            usually small, typically <= 20.
+        --*/
+        internal static readonly int[] incs = new int[14]
+        {
+            1, 4, 13, 40, 121, 364, 1093, 3280,
+            9841, 29524, 88573, 265720, 797161, 2391484
+        };
+
+        /*--
+            The following is an implementation of
+            an elegant 3-way quicksort for strings,
+            described in a paper "Fast Algorithms for
+            Sorting and Searching Strings", by Robert
+            Sedgewick and Jon L. Bentley.
+        --*/
+        internal const int MAIN_QSORT_SMALL_THRESH = 20;
+
+        internal const int MAIN_QSORT_DEPTH_THRESH = (BZ_N_RADIX + BZ_N_QSORT);
+
+        internal const int MAIN_QSORT_STACK_SIZE = 100;
+
+        internal const uint SETMASK = 1 << 21;
+
+        internal const uint CLEARMASK = ~SETMASK;
+
+        #endregion
+
+        #region crctable.c
+
+        /// <summary>
+        /// Table for doing CRCs
+        /// </summary>
+        internal static readonly uint[] BZ2_crc32Table = new uint[256]
+        {
+            0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
+            0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
+            0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
+            0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
+            0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
+            0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+            0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
+            0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
+            0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
+            0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
+            0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
+            0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+            0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
+            0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
+            0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
+            0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
+            0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
+            0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+            0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
+            0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
+            0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
+            0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
+            0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
+            0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+            0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
+            0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
+            0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
+            0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
+            0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
+            0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+            0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
+            0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
+            0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
+            0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
+            0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
+            0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+            0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
+            0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
+            0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
+            0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
+            0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
+            0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+            0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
+            0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
+            0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
+            0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
+            0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
+            0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+            0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
+            0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
+            0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
+            0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
+            0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
+            0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
+            0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
+            0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
+            0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
+            0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
+            0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
+            0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+            0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
+            0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
+            0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
+            0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
+        };
+
+        #endregion
+
+        #region randtable.c
+
+        /// <summary>
+        /// Table for randomising repetitive blocks
+        /// </summary>
+        internal static readonly int[] BZ2_rNums = new int[512]
+        {
+            619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
+            985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
+            733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
+            419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
+            878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
+            862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
+            150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
+            170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
+            73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
+            909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
+            641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
+            161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
+            382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
+            98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
+            227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
+            469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
+            184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
+            715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
+            951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
+            652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
+            645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
+            609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
+            653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
+            411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
+            170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
+            857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
+            669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
+            944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
+            344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
+            897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
+            433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
+            686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
+            946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
+            978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
+            680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
+            707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
+            297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
+            134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
+            343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
+            140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
+            170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
+            369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
+            804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
+            896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
+            661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
+            768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
+            61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
+            372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
+            780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
+            920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
+            645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
+            936, 638
+        };
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/bzip2/DState.cs

@@ -0,0 +1,100 @@
+using static BinaryObjectScanner.Compression.bzip2.Constants;
+
+namespace BinaryObjectScanner.Compression.bzip2
+{
+    /// <summary>
+    /// Structure holding all the decompression-side stuff.
+    /// </summary>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/bzlib_private.h"/>
+    internal unsafe class DState
+    {
+        /* pointer back to the struct bz_stream */
+        public bz_stream strm;
+
+        /* state indicator for this stream */
+        public int state;
+
+        /* for doing the final run-length decoding */
+        public byte state_out_ch;
+        public int state_out_len;
+        public bool blockRandomised;
+        public int rNToGo;
+        public int rTPos;
+
+        /* the buffer for bit stream reading */
+        public uint bsBuff;
+        public int bsLive;
+
+        /* misc administratium */
+        public int blockSize100k;
+        public bool smallDecompress;
+        public int currBlockNo;
+        public int verbosity;
+
+        /* for undoing the Burrows-Wheeler transform */
+        public int origPtr;
+        public uint tPos;
+        public int k0;
+        public int[] unzftab = new int[256];
+        public int nblock_used;
+        public int[] cftab = new int[257];
+        public int[] cftabCopy = new int[257];
+
+        /* for undoing the Burrows-Wheeler transform (FAST) */
+        public uint* tt;
+
+        /* for undoing the Burrows-Wheeler transform (SMALL) */
+        public ushort* ll16;
+        public byte* ll4;
+
+        /* stored and calculated CRCs */
+        public uint storedBlockCRC;
+        public uint storedCombinedCRC;
+        public uint calculatedBlockCRC;
+        public uint calculatedCombinedCRC;
+
+        /* map of bytes used in block */
+        public int nInUse;
+        public bool[] inUse = new bool[256];
+        public bool[] inUse16 = new bool[16];
+        public byte[] seqToUnseq = new byte[256];
+
+        /* for decoding the MTF values */
+        public byte[] mtfa = new byte[MTFA_SIZE];
+        public int[] mtfbase = new int[256 / MTFL_SIZE];
+        public byte[] selector = new byte[BZ_MAX_SELECTORS];
+        public byte[] selectorMtf = new byte[BZ_MAX_SELECTORS];
+        public byte[,] len = new byte[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+
+        public int[,] limit = new int[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+        public int[,] @base = new int[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+        public int[,] perm = new int[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+        public int[] minLens = new int[BZ_N_GROUPS];
+
+        /* save area for scalars in the main decompress code */
+        public int save_i;
+        public int save_j;
+        public int save_t;
+        public int save_alphaSize;
+        public int save_nGroups;
+        public int save_nSelectors;
+        public int save_EOB;
+        public int save_groupNo;
+        public int save_groupPos;
+        public int save_nextSym;
+        public int save_nblockMAX;
+        public int save_nblock;
+        public int save_es;
+        public int save_N;
+        public int save_curr;
+        public int save_zt;
+        public int save_zn;
+        public int save_zvec;
+        public int save_zj;
+        public int save_gSel;
+        public int save_gMinlen;
+        public int* save_gLimit;
+        public int* save_gBase;
+        public int* save_gPerm;
+    }
+}

BinaryObjectScanner.Compression/bzip2/EState.cs

@@ -0,0 +1,80 @@
+using static BinaryObjectScanner.Compression.bzip2.Constants;
+
+namespace BinaryObjectScanner.Compression.bzip2
+{
+    /// <summary>
+    /// Structure holding all the compression-side stuff.
+    /// </summary>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/bzlib_private.h"/>
+    internal unsafe class EState
+    {
+        /* pointer back to the struct bz_stream */
+        public bz_stream* strm;
+
+        /* mode this stream is in, and whether inputting */
+        /* or outputting data */
+        public int mode;
+        public int state;
+
+        /* remembers avail_in when flush/finish requested */
+        public uint avail_in_expect;
+
+        /* for doing the block sorting */
+        public uint* arr1;
+        public uint* arr2;
+        public uint* ftab;
+        public int origPtr;
+
+        /* aliases for arr1 and arr2 */
+        public uint* ptr;
+        public byte* block;
+        public ushort* mtfv;
+        public byte* zbits;
+
+        /* for deciding when to use the fallback sorting algorithm */
+        public int workFactor;
+
+        /* run-length-encoding of the input */
+        public uint state_in_ch;
+        public int state_in_len;
+        public int rNToGo;
+        public int rTPos;
+
+        /* input and output limits and current posns */
+        public int nblock;
+        public int nblockMAX;
+        public int numZ;
+        public int state_out_pos;
+
+        /* map of bytes used in block */
+        public int nInUse;
+        public bool[] inUse = new bool[256];
+        public byte[] unseqToSeq = new byte[256];
+
+        /* the buffer for bit stream creation */
+        public uint bsBuff;
+        public int bsLive;
+
+        /* block and combined CRCs */
+        public uint blockCRC;
+        public uint combinedCRC;
+
+        /* misc administratium */
+        public int verbosity;
+        public int blockNo;
+        public int blockSize100k;
+
+        /* stuff for coding the MTF values */
+        public int nMTF;
+        public int[] mtfFreq = new int[BZ_MAX_ALPHA_SIZE];
+        public byte[] selector = new byte[BZ_MAX_SELECTORS];
+        public byte[] selectorMtf = new byte[BZ_MAX_SELECTORS];
+
+        public byte[,] len = new byte[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+        public int[,] code = new int[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+        public int[,] rfreq = new int[BZ_N_GROUPS, BZ_MAX_ALPHA_SIZE];
+
+        /* second dimension: only 3 needed; 4 makes index calculations faster */
+        public uint[,] len_pack = new uint[BZ_MAX_ALPHA_SIZE, 4];
+    }
+}

BinaryObjectScanner.Compression/bzip2/Huffman.cs

@@ -0,0 +1,217 @@
+using static BinaryObjectScanner.Compression.bzip2.Constants;
+
+namespace BinaryObjectScanner.Compression.bzip2
+{
+    /// <summary>
+    /// Huffman coding low-level stuff
+    /// </summary>
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/huffman.c"/>
+    internal static unsafe class Huffman
+    {
+        public static void BZ2_hbMakeCodeLengths(byte* len, int* freq, int alphaSize, int maxLen)
+        {
+            /*--
+                Nodes and heap entries run from 1.  Entry 0
+                for both the heap and nodes is a sentinel.
+            --*/
+            int nNodes, nHeap, n1, n2, i, j, k;
+            bool tooLong;
+
+            int[] heap = new int[BZ_MAX_ALPHA_SIZE + 2];
+            int[] weight = new int[BZ_MAX_ALPHA_SIZE * 2];
+            int[] parent = new int[BZ_MAX_ALPHA_SIZE * 2];
+
+            for (i = 0; i < alphaSize; i++)
+            {
+                weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
+            }
+
+            while (true)
+            {
+
+                nNodes = alphaSize;
+                nHeap = 0;
+
+                heap[0] = 0;
+                weight[0] = 0;
+                parent[0] = -2;
+
+                for (i = 1; i <= alphaSize; i++)
+                {
+                    parent[i] = -1;
+                    nHeap++;
+                    heap[nHeap] = i;
+                    UPHEAP(nHeap, heap, weight);
+                }
+
+                //AssertH(nHeap < (BZ_MAX_ALPHA_SIZE + 2), 2001);
+
+                while (nHeap > 1)
+                {
+                    n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1, nHeap, heap, weight);
+                    n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1, nHeap, heap, weight);
+                    nNodes++;
+                    parent[n1] = parent[n2] = nNodes;
+                    weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
+                    parent[nNodes] = -1;
+                    nHeap++;
+                    heap[nHeap] = nNodes;
+                    UPHEAP(nHeap, heap, weight);
+                }
+
+                //AssertH(nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002);
+
+                tooLong = false;
+                for (i = 1; i <= alphaSize; i++)
+                {
+                    j = 0;
+                    k = i;
+                    while (parent[k] >= 0) { k = parent[k]; j++; }
+                    len[i - 1] = (byte)j;
+                    if (j > maxLen) tooLong = true;
+                }
+
+                if (!tooLong) break;
+
+                /* 17 Oct 04: keep-going condition for the following loop used
+                   to be 'i < alphaSize', which missed the last element,
+                   theoretically leading to the possibility of the compressor
+                   looping.  However, this count-scaling step is only needed if
+                   one of the generated Huffman code words is longer than
+                   maxLen, which up to and including version 1.0.2 was 20 bits,
+                   which is extremely unlikely.  In version 1.0.3 maxLen was
+                   changed to 17 bits, which has minimal effect on compression
+                   ratio, but does mean this scaling step is used from time to
+                   time, enough to verify that it works.
+                   This means that bzip2-1.0.3 and later will only produce
+                   Huffman codes with a maximum length of 17 bits.  However, in
+                   order to preserve backwards compatibility with bitstreams
+                   produced by versions pre-1.0.3, the decompressor must still
+                   handle lengths of up to 20. */
+
+                for (i = 1; i <= alphaSize; i++)
+                {
+                    j = weight[i] >> 8;
+                    j = 1 + (j / 2);
+                    weight[i] = j << 8;
+                }
+            }
+        }
+
+        public static void BZ2_hbAssignCodes(int* code, byte* length, int minLen, int maxLen, int alphaSize)
+        {
+            int n, vec, i;
+
+            vec = 0;
+            for (n = minLen; n <= maxLen; n++)
+            {
+                for (i = 0; i < alphaSize; i++)
+                {
+                    if (length[i] == n)
+                    {
+                        code[i] = vec;
+                        vec++;
+                    }
+                };
+
+                vec <<= 1;
+            }
+        }
+
+        public static void BZ2_hbCreateDecodeTables(int* limit, int* @base, int* perm, byte* length, int minLen, int maxLen, int alphaSize)
+        {
+            int pp, i, j, vec;
+
+            pp = 0;
+            for (i = minLen; i <= maxLen; i++)
+            {
+                for (j = 0; j < alphaSize; j++)
+                {
+                    if (length[j] == i) { perm[pp] = j; pp++; }
+                }
+            };
+
+            for (i = 0; i < BZ_MAX_CODE_LEN; i++)
+            {
+                @base[i] = 0;
+            }
+
+            for (i = 0; i < alphaSize; i++)
+            {
+                @base[length[i] + 1]++;
+            }
+
+            for (i = 1; i < BZ_MAX_CODE_LEN; i++)
+            {
+                @base[i] += @base[i - 1];
+            }
+
+            for (i = 0; i < BZ_MAX_CODE_LEN; i++)
+            {
+                limit[i] = 0;
+            }
+
+            vec = 0;
+
+            for (i = minLen; i <= maxLen; i++)
+            {
+                vec += (@base[i + 1] - @base[i]);
+                limit[i] = vec - 1;
+                vec <<= 1;
+            }
+            
+            for (i = minLen + 1; i <= maxLen; i++)
+            {
+                @base[i] = ((limit[i - 1] + 1) << 1) - @base[i];
+            }
+        }
+
+        #region Macros
+
+        private static int WEIGHTOF(int zz0) => (int)(zz0 & 0xffffff00);
+
+        private static int DEPTHOF(int zz1) => zz1 & 0x000000ff;
+
+        private static int MYMAX(int zz2, int zz3) => zz2 > zz3 ? zz2 : zz3;
+
+        private static int ADDWEIGHTS(int zw1, int zw2) => (WEIGHTOF(zw1) + WEIGHTOF(zw2)) | (1 + MYMAX(DEPTHOF(zw1), DEPTHOF(zw2)));
+
+        private static void UPHEAP(int z, int[] heap, int[] weight)
+        {
+            int zz, tmp;
+            zz = z; tmp = heap[zz];
+            while (weight[tmp] < weight[heap[zz >> 1]])
+            {
+                heap[zz] = heap[zz >> 1];
+                zz >>= 1;
+            }
+
+            heap[zz] = tmp;
+        }
+
+        private static void DOWNHEAP(int z, int nHeap, int[] heap, int[] weight)
+        {
+            int zz, yy, tmp;
+            zz = z; tmp = heap[zz];
+            while (true)
+            {
+                yy = zz << 1;
+                if (yy > nHeap)
+                    break;
+
+                if (yy < nHeap && weight[heap[yy + 1]] < weight[heap[yy]])
+                    yy++;
+
+                if (weight[tmp] < weight[heap[yy]])
+                    break;
+
+                heap[zz] = heap[yy];
+                zz = yy;
+            }
+
+            heap[zz] = tmp;
+        }
+
+        #endregion
+    }
+}

BinaryObjectScanner.Compression/bzip2/bz_stream.cs

@@ -0,0 +1,22 @@
+namespace BinaryObjectScanner.Compression.bzip2
+{
+    /// <see href="https://github.com/ladislav-zezula/StormLib/blob/master/src/bzip2/bzlib.h"/>
+    public unsafe struct bz_stream
+    {
+        public char* next_in;
+        public uint avail_in;
+        public uint total_in_lo32;
+        public uint total_in_hi32;
+
+        public char* next_out;
+        public uint avail_out;
+        public uint total_out_lo32;
+        public uint total_out_hi32;
+
+        public void* state;
+
+        // void *(*bzalloc)(void *,int,int);
+        // void (*bzfree)(void *,void *);
+        // void *opaque;
+    }
+}