SabreTools/BinaryObjectScanner
1
0
Fork 0
mirror of https://github.com/SabreTools/BinaryObjectScanner.git synced 2026-02-14 13:46:03 +00:00
Code Issues 295 Packages Projects Releases 20 Wiki Activity

Properly implement methods from macros

Browse Source
This commit is contained in:
Matt Nadareski
2022-05-23 23:31:55 -07:00
parent 7022a957d6
commit 21ecaca761
9 changed files with 283 additions and 1823 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
BurnOutSharp/External/libmspack/Compression/CompressionStream.cs vendored
View File

@@ -158,31 +158,51 @@ namespace LibMSPackSharp.Compression
bits_left = BitsLeft;
}
/// <summary>
/// Ensure there are at least N bits in the bit buffer
/// </summary>
public void ENSURE_BITS(int nbits, ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
while (bits_left < nbits)
{
READ_BYTES(ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (Error != Error.MSPACK_ERR_OK)
return;
}
}
/// <summary>
/// Read from the input if the buffer is empty
/// </summary>
public Error READ_IF_NEEDED(ref int i_ptr, ref int i_end)
public void READ_IF_NEEDED(ref int i_ptr, ref int i_end)
{
if (i_ptr >= i_end)
{
if (ReadInput() != Error.MSPACK_ERR_OK)
return Error;
ReadInput();
if (Error != Error.MSPACK_ERR_OK)
return;
i_ptr = InputPointer;
i_end = InputEnd;
}
return Error.MSPACK_ERR_OK;
}
/// <summary>
/// Read bytes from the input into the bit buffer
/// </summary>
public abstract void READ_BYTES(ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left);
/// <summary>
/// Read an input stream and fill the buffer
/// </summary>
protected Error ReadInput()
protected virtual void ReadInput()
{
int read = System.Read(InputFileHandle, InputBuffer, 0, (int)InputBufferSize);
if (read < 0)
return Error = Error.MSPACK_ERR_READ;
{
Error = Error.MSPACK_ERR_READ;
return;
}
// We might overrun the input stream by asking for bits we don't use,
// so fake 2 more bytes at the end of input
@@ -191,7 +211,8 @@ namespace LibMSPackSharp.Compression
if (EndOfInput != 0)
{
Console.WriteLine("Out of input bytes");
return Error = Error.MSPACK_ERR_READ;
Error = Error.MSPACK_ERR_READ;
return;
}
else
{
@@ -204,7 +225,6 @@ namespace LibMSPackSharp.Compression
// Update i_ptr and i_end
InputPointer = 0;
InputEnd = read;
return Error = Error.MSPACK_ERR_OK;
}
#endregion
@@ -225,6 +245,46 @@ namespace LibMSPackSharp.Compression
/// </summary>
public long PEEK_BITS_MSB(int nbits, uint bit_buffer) => (bit_buffer >> (BITBUF_WIDTH - (nbits)));
/// <summary>
/// Takes N bits from the buffer and puts them in var
/// </summary>
public long READ_BITS_MSB(int nbits, ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
ENSURE_BITS(nbits, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (Error != Error.MSPACK_ERR_OK)
return -1;
long temp = PEEK_BITS_MSB(nbits, bit_buffer);
REMOVE_BITS_MSB(nbits, ref bit_buffer, ref bits_left);
return temp;
}
/// <summary>
/// Read multiple bits and put them in var
/// </summary>
public long READ_MANY_BITS_MSB(int nbits, ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
byte needed = (byte)(nbits), bitrun;
long temp = 0;
while (needed > 0)
{
if (bits_left <= (BITBUF_WIDTH - 16))
{
READ_BYTES(ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (Error != Error.MSPACK_ERR_OK)
return -1;
}
bitrun = (byte)((bits_left < needed) ? bits_left : needed);
temp = (temp << bitrun) | PEEK_BITS_MSB(bitrun, bit_buffer);
REMOVE_BITS_MSB(bitrun, ref bit_buffer, ref bits_left);
needed -= bitrun;
}
return temp;
}
/// <summary>
/// Removes N bits from the bit buffer
/// </summary>
@@ -257,6 +317,36 @@ namespace LibMSPackSharp.Compression
/// </summary>
public long PEEK_BITS_T_LSB(int nbits, uint bit_buffer) => bit_buffer & lsb_bit_mask[(nbits)];
/// <summary>
/// Takes N bits from the buffer and puts them in var
/// </summary>
public long READ_BITS_LSB(int nbits, ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
ENSURE_BITS(nbits, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (Error != Error.MSPACK_ERR_OK)
return -1;
long temp = PEEK_BITS_LSB(nbits, bit_buffer);
REMOVE_BITS_LSB(nbits, ref bit_buffer, ref bits_left);
return temp;
}
/// <summary>
/// Takes N bits from the buffer and puts them in var using a bit mask
/// </summary>
public long READ_BITS_T_LSB(int nbits, ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
ENSURE_BITS(nbits, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (Error != Error.MSPACK_ERR_OK)
return -1;
long temp = PEEK_BITS_T_LSB(nbits, bit_buffer);
REMOVE_BITS_LSB(nbits, ref bit_buffer, ref bits_left);
return temp;
}
/// <summary>
/// Removes N bits from the bit buffer
/// </summary>

404
BurnOutSharp/External/libmspack/Compression/LZHKWAJ.cs vendored
View File

@@ -62,32 +62,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(types[i], 4)
{
//READ_BITS(types[i], 4)
{
//ENSURE_BITS(nbits)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(types[i]) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
types[i] = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -173,26 +148,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(MATCHLEN2, len)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
lzh.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzh.MATCHLEN2_table[lzh.PEEK_BITS_MSB(KWAJ_TABLEBITS, bit_buffer)];
if (sym >= KWAJ_MATCHLEN2_SYMS)
{
@@ -224,26 +180,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(MATCHLEN1, len)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
lzh.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzh.MATCHLEN1_table[lzh.PEEK_BITS_MSB(KWAJ_TABLEBITS, bit_buffer)];
if (sym >= KWAJ_MATCHLEN1_SYMS)
{
@@ -279,26 +216,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(OFFSET, j)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
lzh.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzh.OFFSET_table[lzh.PEEK_BITS_MSB(KWAJ_TABLEBITS, bit_buffer)];
if (sym >= KWAJ_OFFSET_SYMS)
{
@@ -328,32 +246,7 @@ namespace LibMSPackSharp.Compression
//READ_BITS_SAFE(j, 6)
{
//READ_BITS(j, 6)
{
//ENSURE_BITS(6)
{
while (bits_left < (6))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(j) = (int)lzh.PEEK_BITS_MSB(6, bit_buffer);
lzh.REMOVE_BITS_MSB(6, ref bit_buffer, ref bits_left);
}
j = (int)lzh.READ_BITS_MSB(6, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -381,26 +274,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(LITLEN, len)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
lzh.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzh.LITLEN_table[lzh.PEEK_BITS_MSB(KWAJ_TABLEBITS, bit_buffer)];
if (sym >= KWAJ_LITLEN_SYMS)
{
@@ -434,26 +308,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(LITERAL, j)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
lzh.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzh.LITERAL_table[lzh.PEEK_BITS_MSB(KWAJ_TABLEBITS, bit_buffer)];
if (sym >= KWAJ_LITERAL_SYMS)
{
@@ -521,32 +376,7 @@ namespace LibMSPackSharp.Compression
case 1:
//READ_BITS_SAFE(c, 4)
{
//READ_BITS(val, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(c) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
c = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -556,32 +386,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(sel, 1)
{
//READ_BITS(val, 1)
{
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(sel) = (uint)lzh.PEEK_BITS_MSB(1, bit_buffer);
lzh.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
sel = (uint)lzh.READ_BITS_MSB(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -594,32 +399,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(sel, 1)
{
//READ_BITS(val, 1)
{
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(sel) = (uint)lzh.PEEK_BITS_MSB(1, bit_buffer);
lzh.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
sel = (uint)lzh.READ_BITS_MSB(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -632,32 +412,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(c, 4)
{
//READ_BITS(val, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(c) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
c = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -672,32 +427,7 @@ namespace LibMSPackSharp.Compression
case 2:
//READ_BITS_SAFE(c, 4)
{
//READ_BITS(val, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(c) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
c = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -707,32 +437,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(sel, 2)
{
//READ_BITS(sel, 2)
{
//ENSURE_BITS(2)
{
while (bits_left < (2))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(sel) = (uint)lzh.PEEK_BITS_MSB(2, bit_buffer);
lzh.REMOVE_BITS_MSB(2, ref bit_buffer, ref bits_left);
}
sel = (uint)lzh.READ_BITS_MSB(2, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -741,32 +446,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(c, 4)
{
//READ_BITS(c, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(c) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
c = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -786,32 +466,7 @@ namespace LibMSPackSharp.Compression
{
//READ_BITS_SAFE(c, 4)
{
//READ_BITS(c, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
if (i_ptr >= i_end)
{
if ((err = ReadInput(lzh)) != Error.MSPACK_ERR_OK)
return err;
i_ptr = lzh.InputPointer;
i_end = lzh.InputEnd;
}
lzh.INJECT_BITS_MSB(lzh.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(c) = (uint)lzh.PEEK_BITS_MSB(4, bit_buffer);
lzh.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
c = (uint)lzh.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (lzh.EndOfInput != 0 && bits_left < lzh.EndOfInput)
return Error.MSPACK_ERR_OK;
}
@@ -826,34 +481,5 @@ namespace LibMSPackSharp.Compression
return Error.MSPACK_ERR_OK;
}
private static Error ReadInput(LZHKWAJStream lzh)
{
int read;
if (lzh.EndOfInput != 0)
{
lzh.EndOfInput += 8;
lzh.InputBuffer[0] = 0;
read = 1;
}
else
{
read = lzh.System.Read(lzh.InputFileHandle, lzh.InputBuffer, 0, KWAJ_INPUT_SIZE);
if (read < 0)
return Error.MSPACK_ERR_READ;
if (read == 0)
{
lzh.InputEnd = 8;
lzh.InputBuffer[0] = 0;
read = 1;
}
}
// Update InputPointer and InputLength
lzh.InputPointer = 0;
lzh.InputEnd = read;
return Error.MSPACK_ERR_OK;
}
}
}

52
BurnOutSharp/External/libmspack/Compression/LZHKWAJStream.cs vendored
View File

@@ -13,6 +13,8 @@ namespace LibMSPackSharp.Compression
{
public class LZHKWAJStream : CompressionStream
{
#region Fields
// Huffman code lengths
public byte[] MATCHLEN1_len { get; set; } = new byte[KWAJ_MATCHLEN1_SYMS];
@@ -32,5 +34,55 @@ namespace LibMSPackSharp.Compression
// History window
public byte[] Window { get; set; } = new byte[LZSS.LZSS_WINDOW_SIZE];
#endregion
/// <inheritdoc/>
public override void READ_BYTES(ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
if (i_ptr >= i_end)
{
ReadInput();
if (Error != Error.MSPACK_ERR_OK)
return;
i_ptr = InputPointer;
i_end = InputEnd;
}
INJECT_BITS_MSB(InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
/// <inheritdoc/>
protected override void ReadInput()
{
int read;
if (EndOfInput != 0)
{
EndOfInput += 8;
InputBuffer[0] = 0;
read = 1;
}
else
{
read = System.Read(InputFileHandle, InputBuffer, 0, KWAJ_INPUT_SIZE);
if (read < 0)
{
Error = Error.MSPACK_ERR_READ;
return;
}
if (read == 0)
{
InputEnd = 8;
InputBuffer[0] = 0;
read = 1;
}
}
// Update InputPointer and InputLength
InputPointer = 0;
InputEnd = read;
}
}
}

757
BurnOutSharp/External/libmspack/Compression/LZX.cs vendored
View File

@@ -509,28 +509,7 @@ namespace LibMSPackSharp.Compression
// LZX DELTA format has chunk_size, not present in LZX format
if (lzx.IsDelta)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
lzx.REMOVE_BITS_MSB(16, ref bit_buffer, ref bits_left);
}
@@ -560,33 +539,8 @@ namespace LibMSPackSharp.Compression
// Read block type (3 bits) and block length (24 bits)
//READ_BITS(lzx.BlockType, 3)
{
//ENSURE_BITS(3) // THIS IS NOT 3 BECAUSE OF OTHER CODE I FOUND
{
while (bits_left < (3))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(lzx.BlockType) = (LZXBlockType)lzx.PEEK_BITS_MSB(3, bit_buffer);
lzx.REMOVE_BITS_MSB(3, ref bit_buffer, ref bits_left);
}
// THIS IS NOT 3 BECAUSE OF OTHER CODE I FOUND
lzx.BlockType = (LZXBlockType)lzx.READ_BITS_MSB(3, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
// Read header if necessary
if (lzx.HeaderRead == 0)
@@ -594,153 +548,20 @@ namespace LibMSPackSharp.Compression
// Read 1 bit. if bit=0, intel_filesize = 0.
// if bit=1, read intel filesize (32 bits)
j = 0;
//READ_BITS(i, 1)
{
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)lzx.PEEK_BITS_MSB(1, bit_buffer);
lzx.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
i = (int)lzx.READ_BITS_MSB(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (i != 0)
{
//READ_BITS(i, 16)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)lzx.PEEK_BITS_MSB(16, bit_buffer);
lzx.REMOVE_BITS_MSB(16, ref bit_buffer, ref bits_left);
}
//READ_BITS(j, 16)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(j) = (int)lzx.PEEK_BITS_MSB(16, bit_buffer);
lzx.REMOVE_BITS_MSB(16, ref bit_buffer, ref bits_left);
}
i = (int)lzx.READ_BITS_MSB(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
j = (int)lzx.READ_BITS_MSB(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
}
lzx.IntelFileSize = (i << 16) | j;
lzx.HeaderRead = 1;
}
//READ_BITS(i, 16)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)lzx.PEEK_BITS_MSB(16, bit_buffer);
lzx.REMOVE_BITS_MSB(16, ref bit_buffer, ref bits_left);
}
//READ_BITS(j, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(j) = (int)lzx.PEEK_BITS_MSB(8, bit_buffer);
lzx.REMOVE_BITS_MSB(8, ref bit_buffer, ref bits_left);
}
i = (int)lzx.READ_BITS_MSB(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
j = (int)lzx.READ_BITS_MSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
lzx.BlockRemaining = lzx.BlockLength = (uint)((i << 8) | j);
// Console.WriteLine($"New block t {lzx.BlockType} len {lzx.BlockLength}");
@@ -752,34 +573,7 @@ namespace LibMSPackSharp.Compression
// Read lengths of and build aligned huffman decoding tree
for (i = 0; i < 8; i++)
{
//READ_BITS(j, 3)
{
//ENSURE_BITS(3)
{
while (bits_left < (3))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(j) = (int)lzx.PEEK_BITS_MSB(3, bit_buffer);
lzx.REMOVE_BITS_MSB(3, ref bit_buffer, ref bits_left);
}
j = (int)lzx.READ_BITS_MSB(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
lzx.ALIGNED_len[i] = (byte)j;
}
@@ -935,29 +729,7 @@ namespace LibMSPackSharp.Compression
// Read 1-16 (not 0-15) bits to align to bytes
if (bits_left == 0)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
}
lzx.ENSURE_BITS(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
bits_left = 0; bit_buffer = 0;
@@ -1002,28 +774,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(MAINTREE, main_element)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.MAINTREE_table[lzx.PEEK_BITS_MSB(LZX_MAINTREE_TABLEBITS, bit_buffer)];
if (sym >= LZX_MAINTREE_MAXSYMBOLS)
{
@@ -1068,28 +819,7 @@ namespace LibMSPackSharp.Compression
//READ_HUFFSYM(LENGTH, length_footer)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.LENGTH_table[lzx.PEEK_BITS_MSB(LZX_LENGTH_TABLEBITS, bit_buffer)];
if (sym >= LZX_LENGTH_MAXSYMBOLS)
{
@@ -1145,35 +875,7 @@ namespace LibMSPackSharp.Compression
else
{
extra = (match_offset >= 36) ? 17 : extra_bits[match_offset];
//READ_BITS(verbatim_bits, extra)
{
//ENSURE_BITS(extra)
{
while (bits_left < (extra))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(verbatim_bits) = (int)lzx.PEEK_BITS_MSB(extra, bit_buffer);
lzx.REMOVE_BITS_MSB(extra, ref bit_buffer, ref bits_left);
}
verbatim_bits = (int)lzx.READ_BITS_MSB(extra, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset = (uint)(position_base[match_offset] - 2 + verbatim_bits);
}
}
@@ -1188,61 +890,12 @@ namespace LibMSPackSharp.Compression
if (extra > 3)
{
extra -= 3;
//READ_BITS(verbatim_bits, extra)
{
//ENSURE_BITS(extra)
{
while (bits_left < (extra))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(verbatim_bits) = (int)lzx.PEEK_BITS_MSB(extra, bit_buffer);
lzx.REMOVE_BITS_MSB(extra, ref bit_buffer, ref bits_left);
}
verbatim_bits = (int)lzx.READ_BITS_MSB(extra, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset += (uint)(verbatim_bits << 3);
//READ_HUFFSYM(ALIGNED, aligned_bits)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.ALIGNED_table[lzx.PEEK_BITS_MSB(LZX_ALIGNED_TABLEBITS, bit_buffer)];
if (sym >= LZX_ALIGNED_MAXSYMBOLS)
{
@@ -1272,28 +925,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(ALIGNED, aligned_bits)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.ALIGNED_table[lzx.PEEK_BITS_MSB(LZX_ALIGNED_TABLEBITS, bit_buffer)];
if (sym >= LZX_ALIGNED_MAXSYMBOLS)
{
@@ -1321,34 +953,7 @@ namespace LibMSPackSharp.Compression
// 1-2: verbatim bits only
else if (extra > 0)
{
//READ_BITS(verbatim_bits, extra)
{
//ENSURE_BITS(extra)
{
while (bits_left < (extra))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(verbatim_bits) = (int)lzx.PEEK_BITS_MSB(extra, bit_buffer);
lzx.REMOVE_BITS_MSB(extra, ref bit_buffer, ref bits_left);
}
verbatim_bits = (int)lzx.READ_BITS_MSB(extra, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset += (uint)verbatim_bits;
}
@@ -1370,96 +975,20 @@ namespace LibMSPackSharp.Compression
int extra_len;
// 4 entry huffman tree
//ENSURE_BITS(3)
{
while (bits_left < (3))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(3, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
// '0' . 8 extra length bits
if (lzx.PEEK_BITS_MSB(1, bit_buffer) == 0)
{
lzx.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
//READ_BITS(extra_len, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(extra_len) = (int)lzx.PEEK_BITS_MSB(8, bit_buffer);
lzx.REMOVE_BITS_MSB(8, ref bit_buffer, ref bits_left);
}
extra_len = (int)lzx.READ_BITS_MSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
}
// '10' . 10 extra length bits + 0x100
else if (lzx.PEEK_BITS_MSB(2, bit_buffer) == 2)
{
lzx.REMOVE_BITS_MSB(2, ref bit_buffer, ref bits_left);
//READ_BITS(extra_len, 10)
{
//ENSURE_BITS(10)
{
while (bits_left < (10))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(extra_len) = (int)lzx.PEEK_BITS_MSB(10, bit_buffer);
lzx.REMOVE_BITS_MSB(10, ref bit_buffer, ref bits_left);
}
extra_len = (int)lzx.READ_BITS_MSB(10, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
extra_len += 0x100;
}
@@ -1467,35 +996,7 @@ namespace LibMSPackSharp.Compression
else if (lzx.PEEK_BITS_MSB(3, bit_buffer) == 6)
{
lzx.REMOVE_BITS_MSB(3, ref bit_buffer, ref bits_left);
//READ_BITS(extra_len, 12)
{
//ENSURE_BITS(12)
{
while (bits_left < (12))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(extra_len) = (int)lzx.PEEK_BITS_MSB(12, bit_buffer);
lzx.REMOVE_BITS_MSB(12, ref bit_buffer, ref bits_left);
}
extra_len = (int)lzx.READ_BITS_MSB(12, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
extra_len += 0x500;
}
@@ -1503,34 +1004,7 @@ namespace LibMSPackSharp.Compression
else
{
lzx.REMOVE_BITS_MSB(3, ref bit_buffer, ref bits_left);
//READ_BITS(extra_len, 15)
{
//ENSURE_BITS(15)
{
while (bits_left < (15))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(extra_len) = (int)lzx.PEEK_BITS_MSB(15, bit_buffer);
lzx.REMOVE_BITS_MSB(15, ref bit_buffer, ref bits_left);
}
extra_len = (int)lzx.READ_BITS_MSB(15, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
}
match_length += extra_len;
@@ -1650,30 +1124,7 @@ namespace LibMSPackSharp.Compression
// Re-align input bitstream
if (bits_left > 0)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
}
lzx.ENSURE_BITS(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if ((bits_left & 15) != 0)
lzx.REMOVE_BITS_MSB(bits_left & 15, ref bit_buffer, ref bits_left);
@@ -1785,34 +1236,7 @@ namespace LibMSPackSharp.Compression
// Read lengths for pretree (20 symbols, lengths stored in fixed 4 bits)
for (x = 0; x < 20; x++)
{
//READ_BITS(y, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(y) = (uint)lzx.PEEK_BITS_MSB(4, bit_buffer);
lzx.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
y = (uint)lzx.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
lzx.PRETREE_len[x] = (byte)y;
}
@@ -1829,28 +1253,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(PRETREE, z)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.PRETREE_table[lzx.PEEK_BITS_MSB(LZX_PRETREE_TABLEBITS, bit_buffer)];
if (sym >= LZX_PRETREE_MAXSYMBOLS)
{
@@ -1875,34 +1278,7 @@ namespace LibMSPackSharp.Compression
// Code = 17, run of ([read 4 bits]+4) zeros
if (z == 17)
{
//READ_BITS(y, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(y) = (uint)lzx.PEEK_BITS_MSB(4, bit_buffer);
lzx.REMOVE_BITS_MSB(4, ref bit_buffer, ref bits_left);
}
y = (uint)lzx.READ_BITS_MSB(4, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
y += 4;
while (y-- != 0)
{
@@ -1913,34 +1289,7 @@ namespace LibMSPackSharp.Compression
// Code = 18, run of ([read 5 bits]+20) zeros
else if (z == 18)
{
//READ_BITS(y, 5)
{
//ENSURE_BITS(5)
{
while (bits_left < (5))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(y) = (uint)lzx.PEEK_BITS_MSB(5, bit_buffer);
lzx.REMOVE_BITS_MSB(5, ref bit_buffer, ref bits_left);
}
y = (uint)lzx.READ_BITS_MSB(5, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
y += 20;
while (y-- != 0)
{
@@ -1951,60 +1300,12 @@ namespace LibMSPackSharp.Compression
// Code = 19, run of ([read 1 bit]+4) [read huffman symbol]
else if (z == 19)
{
//READ_BITS(y, 1)
{
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
(y) = (uint)lzx.PEEK_BITS_MSB(1, bit_buffer);
lzx.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
y = (uint)lzx.READ_BITS_MSB(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
y += 4;
//READ_HUFFSYM(PRETREE, z)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b0 = lzx.InputBuffer[i_ptr++];
lzx.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (lzx.Error != Error.MSPACK_ERR_OK)
return lzx.Error;
byte b1 = lzx.InputBuffer[i_ptr++];
lzx.INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}
lzx.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = lzx.PRETREE_table[lzx.PEEK_BITS_MSB(LZX_PRETREE_TABLEBITS, bit_buffer)];
if (sym >= LZX_PRETREE_MAXSYMBOLS)
{

21
BurnOutSharp/External/libmspack/Compression/LZXDStream.cs vendored
View File

@@ -14,6 +14,8 @@ namespace LibMSPackSharp.Compression
{
public class LZXDStream : CompressionStream
{
#region Fields
/// <summary>
/// Number of bytes actually output
/// </summary>
@@ -136,5 +138,24 @@ namespace LibMSPackSharp.Compression
// This is used purely for doing the intel E8 transform
public byte[] e8_buf { get; set; } = new byte[LZX.LZX_FRAME_SIZE];
#endregion
/// <inheritdoc/>
public override void READ_BYTES(ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
READ_IF_NEEDED(ref i_ptr, ref i_end);
if (Error != Error.MSPACK_ERR_OK)
return;
byte b0 = InputBuffer[i_ptr++];
READ_IF_NEEDED(ref i_ptr, ref i_end);
if (Error != Error.MSPACK_ERR_OK)
return;
byte b1 = InputBuffer[i_ptr++];
INJECT_BITS_MSB((b1 << 8) | b0, 16, ref bit_buffer, ref bits_left);
}
}
}

401
BurnOutSharp/External/libmspack/Compression/MSZIP.cs vendored
View File

@@ -200,26 +200,7 @@ namespace LibMSPackSharp.Compression
state = 0;
do
{
//READ_BITS(i, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)zip.PEEK_BITS_LSB(8, bit_buffer);
zip.REMOVE_BITS_LSB(8, ref bit_buffer, ref bits_left);
}
i = (int)zip.READ_BITS_LSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (i == 'C')
state = 1;
@@ -306,100 +287,19 @@ namespace LibMSPackSharp.Compression
i = bits_left & 7;
zip.REMOVE_BITS_LSB(i, ref bit_buffer, ref bits_left);
//READ_BITS(block_len, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(block_len) = (int)zip.PEEK_BITS_LSB(8, bit_buffer);
zip.REMOVE_BITS_LSB(8, ref bit_buffer, ref bits_left);
}
//READ_BITS(i, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)zip.PEEK_BITS_LSB(8, bit_buffer);
zip.REMOVE_BITS_LSB(8, ref bit_buffer, ref bits_left);
}
block_len = (int)zip.READ_BITS_LSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
i = (int)zip.READ_BITS_LSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
block_len |= i << 8;
if (block_len == 0)
break;
// Read "CK" header
//READ_BITS(i, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)zip.PEEK_BITS_LSB(8, bit_buffer);
zip.REMOVE_BITS_LSB(8, ref bit_buffer, ref bits_left);
}
i = (int)zip.READ_BITS_LSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (i != 'C')
return Error.MSPACK_ERR_DATAFORMAT;
//READ_BITS(i, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)zip.PEEK_BITS_LSB(8, bit_buffer);
zip.REMOVE_BITS_LSB(8, ref bit_buffer, ref bits_left);
}
i = (int)zip.READ_BITS_LSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (i != 'K')
return Error.MSPACK_ERR_DATAFORMAT;
@@ -435,75 +335,15 @@ namespace LibMSPackSharp.Compression
zip.RESTORE_BITS(out int i_ptr, out int i_end, out uint bit_buffer, out int bits_left);
// Read the number of codes
//READ_BITS(lit_codes, 5)
{
//ENSURE_BITS(5)
{
while (bits_left < (5))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(lit_codes) = (uint)zip.PEEK_BITS_LSB(5, bit_buffer);
zip.REMOVE_BITS_LSB(5, ref bit_buffer, ref bits_left);
}
lit_codes = (uint)zip.READ_BITS_LSB(5, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
lit_codes += 257;
//READ_BITS(dist_codes, 5)
{
//ENSURE_BITS(5)
{
while (bits_left < (5))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(dist_codes) = (uint)zip.PEEK_BITS_LSB(5, bit_buffer);
zip.REMOVE_BITS_LSB(5, ref bit_buffer, ref bits_left);
}
dist_codes = (uint)zip.READ_BITS_LSB(5, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
dist_codes += 1;
//READ_BITS(bitlen_codes, 4)
{
//ENSURE_BITS(4)
{
while (bits_left < (4))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(bitlen_codes) = (uint)zip.PEEK_BITS_LSB(4, bit_buffer);
zip.REMOVE_BITS_LSB(4, ref bit_buffer, ref bits_left);
}
bitlen_codes = (uint)zip.READ_BITS_LSB(5, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
bitlen_codes += 4;
if (lit_codes > MSZIP_LITERAL_MAXSYMBOLS)
return Error.INF_ERR_SYMLENS;
if (dist_codes > MSZIP_DISTANCE_MAXSYMBOLS)
@@ -512,26 +352,7 @@ namespace LibMSPackSharp.Compression
// Read in the bit lengths in their unusual order
for (i = 0; i < bitlen_codes; i++)
{
//READ_BITS(bl_len[bitlen_order[i]], 3)
{
//ENSURE_BITS(3)
{
while (bits_left < (3))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(bl_len[bitlen_order[i]]) = (byte)zip.PEEK_BITS_LSB(3, bit_buffer);
zip.REMOVE_BITS_LSB(3, ref bit_buffer, ref bits_left);
}
bl_len[bitlen_order[i]] = (byte)zip.READ_BITS_LSB(3, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
}
while (i < 19)
@@ -548,21 +369,7 @@ namespace LibMSPackSharp.Compression
{
// Single-level huffman lookup
//ENSURE_BITS(7)
{
while (bits_left < (7))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
zip.ENSURE_BITS(7, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
code = bl_table[zip.PEEK_BITS_LSB(7, bit_buffer)];
zip.REMOVE_BITS_LSB(bl_len[code], ref bit_buffer, ref bits_left);
@@ -575,79 +382,19 @@ namespace LibMSPackSharp.Compression
switch (code)
{
case 16:
//READ_BITS(run, 2)
{
//ENSURE_BITS(2)
{
while (bits_left < (2))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(run) = (uint)zip.PEEK_BITS_LSB(2, bit_buffer);
zip.REMOVE_BITS_LSB(2, ref bit_buffer, ref bits_left);
}
run = (uint)zip.READ_BITS_LSB(2, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
run += 3;
code = last_code;
break;
case 17:
//READ_BITS(run, 3)
{
//ENSURE_BITS(3)
{
while (bits_left < (3))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(run) = (uint)zip.PEEK_BITS_LSB(3, bit_buffer);
zip.REMOVE_BITS_LSB(3, ref bit_buffer, ref bits_left);
}
run = (uint)zip.READ_BITS_LSB(3, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
run += 3;
code = 0;
break;
case 18:
//READ_BITS(run, 7)
{
//ENSURE_BITS(7)
{
while (bits_left < (7))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(run) = (uint)zip.PEEK_BITS_LSB(7, bit_buffer);
zip.REMOVE_BITS_LSB(7, ref bit_buffer, ref bits_left);
}
run = (uint)zip.READ_BITS_LSB(7, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
run += 11;
code = 0;
break;
@@ -703,50 +450,10 @@ namespace LibMSPackSharp.Compression
do
{
// Read in last block bit
//READ_BITS(last_block, 1)
{
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(last_block) = (uint)zip.PEEK_BITS_LSB(1, bit_buffer);
zip.REMOVE_BITS_LSB(1, ref bit_buffer, ref bits_left);
}
last_block = (uint)zip.READ_BITS_LSB(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
// Read in block type
//READ_BITS(block_type, 2)
{
//ENSURE_BITS(2)
{
while (bits_left < (2))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(block_type) = (uint)zip.PEEK_BITS_LSB(2, bit_buffer);
zip.REMOVE_BITS_LSB(2, ref bit_buffer, ref bits_left);
}
block_type = (uint)zip.READ_BITS_LSB(2, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
if (block_type == 0)
{
@@ -877,21 +584,7 @@ namespace LibMSPackSharp.Compression
{
//READ_HUFFSYM(LITERAL, code)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
zip.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = zip.LITERAL_table[zip.PEEK_BITS_LSB(MSZIP_LITERAL_TABLEBITS, bit_buffer)];
if (sym >= MSZIP_LITERAL_MAXSYMBOLS)
{
@@ -939,46 +632,12 @@ namespace LibMSPackSharp.Compression
if (code >= 29)
return Error.INF_ERR_LITCODE; // Codes 286-287 are illegal
//READ_BITS_T(length, lit_extrabits[code])
{
//ENSURE_BITS(lit_extrabits[code])
{
while (bits_left < (lit_extrabits[code]))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(length) = (uint)zip.PEEK_BITS_T_LSB(lit_extrabits[code], bit_buffer);
zip.REMOVE_BITS_LSB(lit_extrabits[code], ref bit_buffer, ref bits_left);
}
length = (uint)zip.READ_BITS_T_LSB(lit_extrabits[code], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
length += lit_lengths[code];
//READ_HUFFSYM(DISTANCE, code)
{
//ENSURE_BITS(CompressionStream.HUFF_MAXBITS)
{
while (bits_left < (CompressionStream.HUFF_MAXBITS))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
zip.ENSURE_BITS(CompressionStream.HUFF_MAXBITS, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
sym = zip.DISTANCE_table[zip.PEEK_BITS_LSB(MSZIP_DISTANCE_TABLEBITS, bit_buffer)];
if (sym >= MSZIP_DISTANCE_MAXSYMBOLS)
{
@@ -1003,27 +662,7 @@ namespace LibMSPackSharp.Compression
if (code >= 30)
return Error.INF_ERR_DISTCODE;
//READ_BITS_T(distance, dist_extrabits[code])
{
//ENSURE_BITS(dist_extrabits[code])
{
while (bits_left < (dist_extrabits[code]))
{
//READ_BYTES
{
zip.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (zip.Error != Error.MSPACK_ERR_OK)
return zip.Error;
zip.INJECT_BITS_LSB(zip.InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}
(distance) = (uint)zip.PEEK_BITS_T_LSB(dist_extrabits[code], bit_buffer);
zip.REMOVE_BITS_LSB(dist_extrabits[code], ref bit_buffer, ref bits_left);
}
distance = (uint)zip.READ_BITS_T_LSB(dist_extrabits[code], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
distance += dist_offsets[code];
// Match position is window position minus distance. If distance

14
BurnOutSharp/External/libmspack/Compression/MSZIPDStream.cs vendored
View File

@@ -16,6 +16,8 @@ namespace LibMSPackSharp.Compression
{
public class MSZIPDStream : CompressionStream
{
#region Fields
/// <summary>
/// 32kb history window
/// </summary>
@@ -48,5 +50,17 @@ namespace LibMSPackSharp.Compression
public ushort[] DISTANCE_table { get; set; } = new ushort[MSZIP.MSZIP_DISTANCE_TABLESIZE];
#endregion
#endregion
/// <inheritdoc/>
public override void READ_BYTES(ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
READ_IF_NEEDED(ref i_ptr, ref i_end);
if (Error != Error.MSPACK_ERR_OK)
return;
INJECT_BITS_LSB(InputBuffer[i_ptr++], 8, ref bit_buffer, ref bits_left);
}
}
}

328
BurnOutSharp/External/libmspack/Compression/QTM.cs vendored
View File

@@ -230,35 +230,7 @@ namespace LibMSPackSharp.Compression
{
H = 0xFFFF;
L = 0;
//READ_BITS(C, 16)
{
//ENSURE_BITS(16)
{
while (bits_left < (16))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
(C) = (ushort)qtm.PEEK_BITS_MSB(16, bit_buffer);
qtm.REMOVE_BITS_MSB(16, ref bit_buffer, ref bits_left);
}
C = (ushort)qtm.READ_BITS_MSB(16, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
qtm.HeaderRead = 1;
}
@@ -318,28 +290,7 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
@@ -415,28 +366,7 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
@@ -498,65 +428,13 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
}
//READ_MANY_BITS(extra, extra_bits[sym])
{
byte needed = (byte)(extra_bits[sym]), bitrun;
(extra) = 0;
while (needed > 0)
{
if ((bits_left) <= (CompressionStream.BITBUF_WIDTH - 16))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
bitrun = (byte)((bits_left < needed) ? bits_left : needed);
(extra) = (int)(((extra) << bitrun) | (qtm.PEEK_BITS_MSB(bitrun, bit_buffer)));
qtm.REMOVE_BITS_MSB(bitrun, ref bit_buffer, ref bits_left);
needed -= bitrun;
}
}
extra = (int)qtm.READ_MANY_BITS_MSB(extra_bits[sym], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset = (uint)(position_base[sym] + extra + 1);
match_length = 3;
break;
@@ -609,65 +487,13 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
}
//READ_MANY_BITS(extra, extra_bits[sym])
{
byte needed = (byte)(extra_bits[sym]), bitrun;
(extra) = 0;
while (needed > 0)
{
if ((bits_left) <= (CompressionStream.BITBUF_WIDTH - 16))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
bitrun = (byte)((bits_left < needed) ? bits_left : needed);
(extra) = (int)(((extra) << bitrun) | (qtm.PEEK_BITS_MSB(bitrun, bit_buffer)));
qtm.REMOVE_BITS_MSB(bitrun, ref bit_buffer, ref bits_left);
needed -= bitrun;
}
}
extra = (int)qtm.READ_MANY_BITS_MSB(extra_bits[sym], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset = (uint)(position_base[sym] + extra + 1);
match_length = 4;
break;
@@ -720,65 +546,13 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
}
//READ_MANY_BITS(extra, length_extra[sym])
{
byte needed = (byte)(length_extra[sym]), bitrun;
(extra) = 0;
while (needed > 0)
{
if ((bits_left) <= (CompressionStream.BITBUF_WIDTH - 16))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
bitrun = (byte)((bits_left < needed) ? bits_left : needed);
(extra) = (int)(((extra) << bitrun) | (qtm.PEEK_BITS_MSB(bitrun, bit_buffer)));
qtm.REMOVE_BITS_MSB(bitrun, ref bit_buffer, ref bits_left);
needed -= bitrun;
}
}
extra = (int)qtm.READ_MANY_BITS_MSB(length_extra[sym], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_length = length_base[sym] + extra + 5;
//GET_SYMBOL(qtm.Model6, sym)
@@ -827,65 +601,13 @@ namespace LibMSPackSharp.Compression
L <<= 1;
H = (ushort)((H << 1) | 1);
//ENSURE_BITS(1)
{
while (bits_left < (1))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
qtm.ENSURE_BITS(1, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
C = (ushort)((C << 1) | (qtm.PEEK_BITS_MSB(1, bit_buffer)));
qtm.REMOVE_BITS_MSB(1, ref bit_buffer, ref bits_left);
}
}
//READ_MANY_BITS(extra, extra_bits[sym])
{
byte needed = (byte)(extra_bits[sym]), bitrun;
(extra) = 0;
while (needed > 0)
{
if ((bits_left) <= (CompressionStream.BITBUF_WIDTH - 16))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
bitrun = (byte)((bits_left < needed) ? bits_left : needed);
(extra) = (int)(((extra) << bitrun) | (qtm.PEEK_BITS_MSB(bitrun, bit_buffer)));
qtm.REMOVE_BITS_MSB(bitrun, ref bit_buffer, ref bits_left);
needed -= bitrun;
}
}
extra = (int)qtm.READ_MANY_BITS_MSB(extra_bits[sym], ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
match_offset = (uint)(position_base[sym] + extra + 1);
break;
@@ -1014,33 +736,7 @@ namespace LibMSPackSharp.Compression
// blocks, can have anything from 0 to 4 trailing null bytes.
do
{
//READ_BITS(i, 8)
{
//ENSURE_BITS(8)
{
while (bits_left < (8))
{
//READ_BYTES
{
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b0 = qtm.InputBuffer[i_ptr++];
qtm.READ_IF_NEEDED(ref i_ptr, ref i_end);
if (qtm.Error != Error.MSPACK_ERR_OK)
return qtm.Error;
byte b1 = qtm.InputBuffer[i_ptr++];
qtm.INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}
(i) = (int)qtm.PEEK_BITS_MSB(8, bit_buffer);
qtm.REMOVE_BITS_MSB(8, ref bit_buffer, ref bits_left);
}
i = (int)qtm.READ_BITS_MSB(8, ref i_ptr, ref i_end, ref bit_buffer, ref bits_left);
} while (i != 0xFF);
qtm.HeaderRead = 0;

21
BurnOutSharp/External/libmspack/Compression/QTMDStream.cs vendored
View File

@@ -14,6 +14,8 @@ namespace LibMSPackSharp.Compression
{
public class QTMDStream : CompressionStream
{
#region Fields
/// <summary>
/// Decoding window
/// </summary>
@@ -119,5 +121,24 @@ namespace LibMSPackSharp.Compression
public QTMDModelSym[] Model6LenSymbols { get; set; } = new QTMDModelSym[27 + 1];
public QTMDModelSym[] Model7Symbols { get; set; } = new QTMDModelSym[7 + 1];
#endregion
/// <inheritdoc/>
public override void READ_BYTES(ref int i_ptr, ref int i_end, ref uint bit_buffer, ref int bits_left)
{
READ_IF_NEEDED(ref i_ptr, ref i_end);
if (Error != Error.MSPACK_ERR_OK)
return;
byte b0 = InputBuffer[i_ptr++];
READ_IF_NEEDED(ref i_ptr, ref i_end);
if (Error != Error.MSPACK_ERR_OK)
return;
byte b1 = InputBuffer[i_ptr++];
INJECT_BITS_MSB((b0 << 8) | b1, 16, ref bit_buffer, ref bits_left);
}
}
}