public void Compress(string algorithm)
{
if (algorithm == CompressionAlgorithm.Deflate)
{
byte[] buffer = _memoryStream.ToArray();
MemoryStream ms = new MemoryStream();
DeflateStream deflateStream = new DeflateStream(ms, CompressionMode.Compress, true);
deflateStream.Write(buffer, 0, buffer.Length);
deflateStream.Close();
_memoryStream.Close();
_memoryStream = ms;
AMFReader amfReader = new AMFReader(_memoryStream);
AMFWriter amfWriter = new AMFWriter(_memoryStream);
_dataOutput = new DataOutput(amfWriter);
_dataInput = new DataInput(amfReader);
}
if (algorithm == CompressionAlgorithm.Zlib)
{
byte[] buffer = _memoryStream.ToArray();
MemoryStream ms = new MemoryStream();
ZlibStream zlibStream = new ZlibStream(ms, CompressionMode.Compress, true);
zlibStream.Write(buffer, 0, buffer.Length);
zlibStream.Flush();
zlibStream.Close();
zlibStream.Dispose();
_memoryStream.Close();
_memoryStream = ms;
AMFReader amfReader = new AMFReader(_memoryStream);
AMFWriter amfWriter = new AMFWriter(_memoryStream);
_dataOutput = new DataOutput(amfWriter);
_dataInput = new DataInput(amfReader);
}
}
private byte[] InternalExtract()
{
_stream.Position = _manifest.Offset;
var sizeBytes = new byte[4];
_stream.Read(sizeBytes, 0, 4);
int uncompressedSize = BitConverter.ToInt32(sizeBytes, 0);
if (uncompressedSize <= 0)
{
return(new byte[0]);
}
_stream.Position += 4;
var buffer = new byte[_manifest.UncompressedSize];
var zlibStream = new ZlibStream(_stream, CompressionMode.Decompress, true);
zlibStream.Read(buffer, 0, buffer.Length);
zlibStream.Close();
zlibStream.Dispose();
return(buffer);
}
public static void Decompress(byte[] compressed, int compressedOffset, int compressedSize, byte[] uncompressed, int uncompressedOffset, int uncompressedSize, CompressionMethod method, FArchive?reader = null)
{
using var srcStream = new MemoryStream(compressed, compressedOffset, compressedSize, false)
{
Position = 0
};
switch (method)
{
case CompressionMethod.None:
Buffer.BlockCopy(compressed, compressedOffset, uncompressed, uncompressedOffset, compressedSize);
return;
case CompressionMethod.Zlib:
var zlib = new ZlibStream(srcStream, CompressionMode.Decompress);
zlib.Read(uncompressed, uncompressedOffset, uncompressedSize);
zlib.Dispose();
return;
case CompressionMethod.Gzip:
var gzip = new GZipStream(srcStream, CompressionMode.Decompress);
gzip.Read(uncompressed, uncompressedOffset, uncompressedSize);
gzip.Dispose();
return;
case CompressionMethod.Oodle:
Oodle.Decompress(compressed, compressedOffset, compressedSize, uncompressed, uncompressedOffset, uncompressedSize, reader);
return;
case CompressionMethod.LZ4:
var uncompressedBuffer = new byte[uncompressedSize + uncompressedSize / 255 + 16]; // LZ4_compressBound(uncompressedSize)
int result;
#if USE_LZ4_NATIVE_LIB
unsafe
{
fixed(byte *compressedPtr = compressed, uncompressedBufferPtr = uncompressedBuffer)
{
result = LZ4.LZ4_decompress_safe(compressedPtr + compressedOffset, uncompressedBufferPtr, compressedSize, uncompressedBuffer.Length);
}
}
#else
result = LZ4Codec.Decode(compressed, compressedOffset, compressedSize, uncompressedBuffer, 0, uncompressedBuffer.Length);
#endif
Buffer.BlockCopy(uncompressedBuffer, 0, uncompressed, uncompressedOffset, uncompressedSize);
if (result != uncompressedSize)
{
throw new FileLoadException($"Failed to decompress LZ4 data (Expected: {uncompressedSize}, Result: {result})");
}
return;
default:
if (reader != null)
{
throw new UnknownCompressionMethodException(reader, $"Compression method \"{method}\" is unknown");
}
else
{
throw new UnknownCompressionMethodException($"Compression method \"{method}\" is unknown");
}
}
}
public void SetChunkData(byte[] cData, Boolean isCompressed = true)
{
MemoryStream byteStream = new MemoryStream();
ZlibStream zStream = new ZlibStream(byteStream, CompressionMode.Decompress, CompressionLevel.BestCompression, true);
zStream.Write(cData, 0, cData.Length);
zStream.Flush();
zStream.Dispose();
zStream = null;
byte[] bytes = byteStream.ToArray();
byteStream.Dispose();
byteStream = null;
Block b;
WorldLocation blockLoc;
int x, y, z;
// Block Types
for (int i = 0; i < 32768; i++)
{
x = (Location.X * 16) + (i >> 11);
y = i & 0x7F;
z = (Location.Z * 16) + ((i & 0x780) >> 7);
blockLoc = new WorldLocation(x, y, z);
b = new Block((BlockType)bytes[i], blockLoc);
Blocks.Add(b);
}
// TODO: Read and handle block/sky light and metadata
bytes = null;
}
public void Write(Texture2D texture2D, Stream outputStream)
{
width = texture2D.Width;
height = texture2D.Height;
GetColorData(texture2D);
// write PNG signature
outputStream.Write(HeaderChunk.PngSignature, 0, HeaderChunk.PngSignature.Length);
// write header chunk
var headerChunk = new HeaderChunk();
headerChunk.Width = (uint)texture2D.Width;
headerChunk.Height = (uint)texture2D.Height;
headerChunk.BitDepth = 8;
headerChunk.ColorType = colorType;
headerChunk.CompressionMethod = 0;
headerChunk.FilterMethod = 0;
headerChunk.InterlaceMethod = 0;
var headerChunkBytes = headerChunk.Encode();
outputStream.Write(headerChunkBytes, 0, headerChunkBytes.Length);
// write data chunks
var encodedPixelData = EncodePixelData(texture2D);
var compressedPixelData = new MemoryStream();
ZlibStream deflateStream = null;
try
{
deflateStream = new ZlibStream(compressedPixelData, CompressionMode.Compress);
deflateStream.Write(encodedPixelData, 0, encodedPixelData.Length);
deflateStream.Finish();
}
catch (Exception exception)
{
throw new Exception("An error occurred during DEFLATE compression.", exception);
}
var dataChunk = new DataChunk();
dataChunk.Data = compressedPixelData.ToArray();
var dataChunkBytes = dataChunk.Encode();
outputStream.Write(dataChunkBytes, 0, dataChunkBytes.Length);
deflateStream.Dispose();
compressedPixelData.Dispose();
// write end chunk
var endChunk = new EndChunk();
var endChunkBytes = endChunk.Encode();
outputStream.Write(endChunkBytes, 0, endChunkBytes.Length);
}
public byte[] GetChunkData()
{
MemoryStream byteStream = new MemoryStream();
byte[] bytes = new byte[Blocks.Count + ((Blocks.Count / 2) * 3)];
int index;
foreach (Block b in Blocks)
{
index = b.Location.Y + ((b.Location.Z - (Location.Z * 16)) * (SizeY + 1)) + ((b.Location.X - (Location.X * 16)) * (SizeY + 1) * (SizeZ + 1));
byteStream.Seek(index, SeekOrigin.Begin);
byteStream.WriteByte((byte)b.Type);
}
byteStream.Seek(Blocks.Count, SeekOrigin.Begin);
for (int a = 1; a <= 3; a++)
{
for (int b = 0; b < 16384; b++)
{
switch (a)
{
case 1:
byteStream.WriteByte(0xFF);
break;
default:
byteStream.WriteByte(0xFF);
break;
}
}
}
bytes = byteStream.ToArray();
byteStream.Dispose();
byteStream = null;
// Compress array
MemoryStream ms = new MemoryStream();
ZlibStream zs = new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.Default, true);
zs.Write(bytes, 0, bytes.Length);
zs.Flush();
zs.Dispose();
zs = null;
byte[] finalBytes = ms.ToArray();
ms.Dispose();
ms = null;
bytes = null;
//
return(finalBytes);
}
public static void Decompress(byte[] compressed, int compressedOffset, int compressedSize, byte[] uncompressed, int uncompressedOffset, int uncompressedSize, CompressionMethod method, FArchive?reader = null)
{
using var srcStream = new MemoryStream(compressed, compressedOffset, compressedSize, false)
{
Position = 0
};
switch (method)
{
case CompressionMethod.None:
Buffer.BlockCopy(compressed, compressedOffset, uncompressed, uncompressedOffset, compressedSize);
return;
case CompressionMethod.Zlib:
var zlib = new ZlibStream(srcStream, CompressionMode.Decompress);
zlib.Read(uncompressed, uncompressedOffset, uncompressedSize);
zlib.Dispose();
return;
case CompressionMethod.Gzip:
var gzip = new GZipStream(srcStream, CompressionMode.Decompress);
gzip.Read(uncompressed, uncompressedOffset, uncompressedSize);
gzip.Dispose();
return;
case CompressionMethod.Oodle:
Pro_Swapper.Swap.RawExport = compressed;
Oodle.Decompress(compressed, compressedOffset, compressedSize, uncompressed, uncompressedOffset, uncompressedSize, reader);
return;
case CompressionMethod.LZ4:
var uncompressedBuffer = new byte[uncompressedSize + 4];
var result = LZ4Codec.Decode(compressed, compressedOffset, compressedSize, uncompressedBuffer, 0, uncompressedBuffer.Length);
Buffer.BlockCopy(uncompressedBuffer, 0, uncompressed, uncompressedOffset, uncompressedSize);
if (result != uncompressedSize)
{
throw new FileLoadException($"Failed to decompress LZ4 data (Expected: {uncompressedSize}, Result: {result})");
}
//var lz4 = LZ4Stream.Decode(srcStream);
//lz4.Read(uncompressed, uncompressedOffset, uncompressedSize);
//lz4.Dispose();
return;
default:
if (reader != null)
{
throw new UnknownCompressionMethodException(reader, $"Compression method \"{method}\" is unknown");
}
else
{
throw new UnknownCompressionMethodException($"Compression method \"{method}\" is unknown");
}
}
}
private byte[] GetBytes()
{
const int binaryFormatVersion = 1;
const int sizeVersion = 2;
const int sizeDictionaryBlob = 4;
const int sizeCountMetrics = 4;
const int bitsInByte = 8;
const int byteMask = 0xff;
// close the compressor, we're going to dispose the compressed streams
_closed = true;
AppendStrings();
// got to dispose the compressed streams to flush them all
_stringsCompressStream.Dispose();
_stringsCompressStream = null;
_metricsCompressStream.Dispose();
_metricsCompressStream = null;
// version info + dictionary length + dictionary blob + number of metrics + metrics blob
var completeSize = sizeVersion + sizeDictionaryBlob + _stringsBuffer.Position + sizeCountMetrics + _metricsBuffer.Position;
// protect casts
if (completeSize > int.MaxValue)
{
throw new InvalidOperationException($"Out of range: completeSize ({completeSize}).");
}
if (_stringsBuffer.Position > int.MaxValue)
{
throw new InvalidOperationException($"Out of range: _stringsBuffer.Length ({_stringsBuffer.Position}).");
}
if (_metricsBuffer.Position > int.MaxValue)
{
throw new InvalidOperationException($"Out of range: _metricsBuffer.Length ({_metricsBuffer.Position}).");
}
using var buffer = new MemoryStream((int)completeSize);
var output = new DataOutputStream(buffer);
// ReSharper disable once ShiftExpressionResultEqualsZero - well, yes
output.WriteByte((binaryFormatVersion >> bitsInByte) & byteMask);
output.WriteByte(binaryFormatVersion & byteMask);
output.WriteInt((int)_stringsBuffer.Position);
output.Write(_stringsBuffer.GetBuffer(), 0, (int)_stringsBuffer.Position);
output.WriteInt(_count);
output.Write(_metricsBuffer.GetBuffer(), 0, (int)_metricsBuffer.Position);
return(buffer.ToArray());
}
/// <summary>
/// Compresses an array of bytes.
/// </summary>
/// <param name="data">Data to compress.</param>
public static byte[] Compress(byte[] data, CompressionLevel compressionLevel)
{
// Compress the data.
using var resultStream = new MemoryStream();
var zlibStream = new ZlibStream(resultStream, compressionLevel, true);
// Write compressed data to result.
zlibStream.Write(data, 0, data.Length);
zlibStream.Dispose();
// Return compressed data
return(resultStream.ToArray());
}
private static void Reset(ref MemoryStream buffer, ref ZlibStream compress, ref DataOutputStream output, int size)
{
compress?.Dispose();
// shrink if capacity is more than 50% larger than the estimated size
if (buffer == null || buffer.Capacity > 3 * size / 2)
{
buffer?.Dispose();
buffer = new MemoryStream(size);
}
buffer.Seek(0, SeekOrigin.Begin);
compress = new ZlibStream(buffer, CompressionMode.Compress, CompressionLevel.BestSpeed, true);
output = new DataOutputStream(compress);
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_tempBuffer?.Dispose();
_stringsCompressStream?.Dispose();
_stringsBuffer?.Dispose();
_metricsCompressStream?.Dispose();
_metricsBuffer?.Dispose();
}
/// <summary>
/// This method is called each time when some data is received from server.
/// </summary>
/// <param name="sender">The source of event.</param>
/// <param name="e">Arguments of event.</param>
protected override void OnDataReceived(object sender, DataReceivedEventArgs e)
{
Assert.ArgumentNotNull(sender, "sender");
Assert.ArgumentNotNull(e, "e");
TotalBytesReceived += (uint)e.BytesReceived;
byte[] data = e.GetData();
if (!_compressionInProgress)
{
ProcessData(data, e.Offset, e.BytesReceived);
}
else
{
_compressedDataStream.Seek(0, SeekOrigin.Begin);
_compressedDataStream.Write(data, e.Offset, e.BytesReceived);
_compressedDataStream.SetLength(e.BytesReceived);
_compressedDataStream.Seek(0, SeekOrigin.Begin);
try
{
int bytesDecompresed = 1;
while (bytesDecompresed > 0)
{
bytesDecompresed = _zlibDecompressionStream.Read(_unpackBuffer, 0, _unpackBuffer.Length);
if (bytesDecompresed < 0)
{
_compressionInProgress = false;
_zlibDecompressionStream.Dispose();
_zlibDecompressionStream = null;
return;
}
BytesDecompressed += (uint)bytesDecompresed;
ProcessData(_unpackBuffer, 0, bytesDecompresed);
}
}
catch (Exception ex)
{
ErrorLogger.Instance.Write(string.Format("Error data decompressed: offset = {0}, bytesCount = {1}, data = {2}\r\n\r\n{3}\r\n{4}",
e.Offset, e.BytesReceived, Encoding.Default.GetString(data), ex.Message, ex.StackTrace));
Dispose(true);
HandleException(new NetworkErrorEventArgs(ex));
}
}
}
public BinaryReader GetReaderForPotentiallyCompressedBlock(Context context, BinaryReader currentReader, BlockHeader block)
{
if (block.IsCompressed)
{
ZlibStream zlibStream = null;
try {
zlibStream = new ZlibStream(currentReader.BaseStream, System.IO.Compression.CompressionMode.Decompress,
leaveOpen: currentReader == context.Reader.BaseReader);
return(new BinaryReader(zlibStream));
} catch {
if (zlibStream != null)
{
zlibStream.Dispose();
}
throw;
}
}
return(currentReader);
}
public static void Decompress(byte[] compressed, int compressedOffset, int compressedSize, byte[] uncompressed, int uncompressedOffset, int uncompressedSize, CompressionMethod method, FArchive?reader = null)
{
using var srcStream = new MemoryStream(compressed, compressedOffset, compressedSize, false)
{
Position = 0
};
switch (method)
{
case CompressionMethod.None:
Buffer.BlockCopy(compressed, compressedOffset, uncompressed, uncompressedOffset, compressedSize);
return;
case CompressionMethod.Zlib:
var zlib = new ZlibStream(srcStream, CompressionMode.Decompress);
zlib.Read(uncompressed, uncompressedOffset, uncompressedSize);
zlib.Dispose();
return;
case CompressionMethod.Gzip:
var gzip = new GZipStream(srcStream, CompressionMode.Decompress);
gzip.Read(uncompressed, uncompressedOffset, uncompressedSize);
gzip.Dispose();
return;
case CompressionMethod.Oodle:
Oodle.Decompress(compressed, compressedOffset, compressedSize, uncompressed, uncompressedOffset, uncompressedSize, reader);
return;
default:
if (reader != null)
{
throw new OodleException(reader, $"Compression method \"{method}\" is unknown");
}
else
{
throw new OodleException($"Compression method \"{method}\" is unknown");
}
}
}
/// <summary>
/// Compresses the byte array using zlib compression. The entire byte array is compressed.
/// </summary>
/// <param name="algorithm">The compression algorithm to use when compressing. Valid values are defined as constants in the CompressionAlgorithm class. The default is to use zlib format.</param>
/// <remarks>
/// After the call, the Length property of the ByteArray is set to the new length. The position property is set to the end of the byte array.
/// </remarks>
public void Compress(string algorithm)
{
ValidationUtils.ArgumentConditionTrue(algorithm == CompressionAlgorithm.Deflate || algorithm == CompressionAlgorithm.Zlib, "algorithm", "Invalid parameter");
#if SILVERLIGHT
throw new NotSupportedException();
#else
if (algorithm == CompressionAlgorithm.Deflate)
{
byte[] buffer = _memoryStream.ToArray();
MemoryStream ms = new MemoryStream();
DeflateStream deflateStream = new DeflateStream(ms, CompressionMode.Compress, true);
deflateStream.Write(buffer, 0, buffer.Length);
deflateStream.Close();
_memoryStream.Close();
_memoryStream = ms;
AMFReader amfReader = new AMFReader(_memoryStream);
AMFWriter amfWriter = new AMFWriter(_memoryStream);
_dataOutput = new DataOutput(amfWriter);
_dataInput = new DataInput(amfReader);
}
if (algorithm == CompressionAlgorithm.Zlib)
{
byte[] buffer = _memoryStream.ToArray();
MemoryStream ms = new MemoryStream();
ZlibStream zlibStream = new ZlibStream(ms, CompressionMode.Compress, true);
zlibStream.Write(buffer, 0, buffer.Length);
zlibStream.Flush();
zlibStream.Close();
zlibStream.Dispose();
_memoryStream.Close();
_memoryStream = ms;
AMFReader amfReader = new AMFReader(_memoryStream);
AMFWriter amfWriter = new AMFWriter(_memoryStream);
_dataOutput = new DataOutput(amfWriter);
_dataInput = new DataInput(amfReader);
}
#endif
}
