179 lines
5.8 KiB
C#
179 lines
5.8 KiB
C#
using NLog;
|
|
using System;
|
|
using System.IO;
|
|
|
|
namespace Resources
|
|
{
|
|
public class Compression
|
|
{
|
|
private const int SectionSize = 4096;
|
|
private static readonly byte[] SomeData = new byte[16] {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0};
|
|
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
|
|
|
|
class Header
|
|
{
|
|
public const int Size = 9;
|
|
|
|
public byte[] Buffer;
|
|
public byte Flags => Buffer[0];
|
|
public uint CompressedLength => BitConverter.ToUInt32(Buffer, 1);
|
|
public uint DecompressedLength => BitConverter.ToUInt32(Buffer, 5);
|
|
public bool IsCompressed => (Flags & 1) > 0;
|
|
public int LengthSize => (Flags & 2) > 0 ? 4 : 1;
|
|
|
|
public static Header Read(BinaryReader reader)
|
|
{
|
|
var buffer = new byte[Size];
|
|
reader.Read(buffer, 0, buffer.Length);
|
|
return new Header { Buffer = buffer };
|
|
}
|
|
}
|
|
|
|
private readonly Stream _stream;
|
|
private readonly BinaryReader _reader;
|
|
private readonly long _streamSize;
|
|
|
|
public Compression(Stream stream)
|
|
{
|
|
_stream = stream;
|
|
_reader = new BinaryReader(stream);
|
|
_streamSize = stream.Length;
|
|
}
|
|
|
|
public Stream Decompress()
|
|
{
|
|
var output = new MemoryStream();
|
|
var sourceBuffer = new byte[SectionSize];
|
|
|
|
var offset = (uint)0;
|
|
|
|
while (true)
|
|
{
|
|
var header = Header.Read(_reader);
|
|
|
|
if (header.DecompressedLength == SectionSize)
|
|
{
|
|
Logger.Debug("Compression block header read at offset 0x{0:X}", offset);
|
|
Logger.Debug("Flags 0x{0:X}, Compressed {1}, Decompressed {2}, LengthSize {3}",
|
|
header.Flags, header.CompressedLength, header.DecompressedLength, header.LengthSize);
|
|
|
|
_reader.Read(sourceBuffer, 0, (int)header.CompressedLength - Header.Size);
|
|
offset += header.CompressedLength;
|
|
|
|
if (header.IsCompressed)
|
|
{
|
|
var decompressed = DecompressBuffer(sourceBuffer);
|
|
output.Write(decompressed, 0, (int)header.DecompressedLength);
|
|
}
|
|
else
|
|
output.Write(sourceBuffer, 0, (int)header.CompressedLength - Header.Size);
|
|
}
|
|
else
|
|
{
|
|
var latestBlock = _streamSize - offset;
|
|
Logger.Debug("Latest block read at offset 0x{0:X}, size: {1}", offset, latestBlock);
|
|
|
|
_reader.Read(sourceBuffer, 0, (int)(latestBlock - Header.Size));
|
|
|
|
output.Write(header.Buffer, 0, Header.Size);
|
|
output.Write(sourceBuffer, 0, (int)(latestBlock - Header.Size));
|
|
break;
|
|
}
|
|
}
|
|
|
|
output.Seek(0, SeekOrigin.Begin);
|
|
return output;
|
|
}
|
|
|
|
|
|
private byte[] DecompressBuffer(byte[] srcBuffer)
|
|
{
|
|
var dstBuffer = new byte[SectionSize];
|
|
var data = (uint)1;
|
|
var dstOffset = 0;
|
|
var srcOffset = 0;
|
|
|
|
while (true)
|
|
{
|
|
while (true)
|
|
{
|
|
if (data == 1)
|
|
{
|
|
data = BitConverter.ToUInt32(srcBuffer, srcOffset);
|
|
srcOffset += 4;
|
|
}
|
|
|
|
var link = BitConverter.ToUInt32(srcBuffer, srcOffset);
|
|
|
|
if (data << 31 == 0)
|
|
break;
|
|
|
|
data = data >> 1;
|
|
|
|
uint dupOffset, dupLength;
|
|
|
|
if (link << 30 == 0)
|
|
{
|
|
dupOffset = (uint)((byte)link >> 2);
|
|
dupLength = 3;
|
|
srcOffset++;
|
|
}
|
|
else if ((link & 2) == 0)
|
|
{
|
|
dupOffset = (uint)((ushort)link >> 2);
|
|
dupLength = 3;
|
|
srcOffset += 2;
|
|
}
|
|
else if (link << 31 == 0)
|
|
{
|
|
dupOffset = (uint)((ushort)link >> 6);
|
|
dupLength = ((link >> 2) & 0xF) + 3;
|
|
srcOffset += 2;
|
|
}
|
|
else if ((link & 0x7F) == 3)
|
|
{
|
|
dupOffset = link >> 15;
|
|
dupLength = ((link >> 7) & 0xFF) + 3;
|
|
srcOffset += 4;
|
|
}
|
|
else
|
|
{
|
|
dupOffset = (link >> 7) & 0x1FFFF;
|
|
dupLength = ((link >> 2) & 0x1F) + 2;
|
|
srcOffset += 3;
|
|
}
|
|
|
|
Array.Copy(dstBuffer, dstOffset - dupOffset, dstBuffer, dstOffset, dupLength);
|
|
dstOffset += (int)dupLength;
|
|
}
|
|
|
|
if (dstOffset >= SectionSize - 11)
|
|
break;
|
|
|
|
var length = SomeData[data & 0xf];
|
|
Array.Copy(srcBuffer, srcOffset, dstBuffer, dstOffset, 4);
|
|
data >>= length;
|
|
dstOffset += length;
|
|
srcOffset += length;
|
|
}
|
|
|
|
while (dstOffset <= SectionSize - 1)
|
|
{
|
|
if (data == 1)
|
|
{
|
|
data = 0x80000000;
|
|
srcOffset += 4;
|
|
}
|
|
data >>= 1;
|
|
var tmp = srcBuffer[srcOffset];
|
|
srcOffset++;
|
|
dstBuffer[dstOffset] = tmp;
|
|
dstOffset++;
|
|
}
|
|
|
|
|
|
return dstBuffer;
|
|
}
|
|
}
|
|
}
|