mirror of
https://github.com/SabreTools/BinaryObjectScanner.git
synced 2026-02-16 05:44:53 +00:00
Remove two incomplete compressions
This commit is contained in:
Matt Nadareski
@@ -1,12 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -1,205 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,304 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -1,100 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
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];
|
||||
}
|
||||
}
|
||||
@@ -1,217 +0,0 @@
|
||||
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
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,22 +0,0 @@
|
||||
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;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user