private static byte[] Decompress(byte[] data)
{
switch (Config.MemoryCache.Type)
{
case Config.MemoryCache.Algorithm.None:
return(data);
case Config.MemoryCache.Algorithm.COMPRESS:
return(StreamDecompress(data));
case Config.MemoryCache.Algorithm.LZ:
#if WITh_ZLIB
return(DeflateStream.UncompressBuffer(data));
#else
throw new Exception("SpriteMaster was built with LZ support disabled");
#endif
case Config.MemoryCache.Algorithm.LZMA: {
/*
* using var outStream = new MemoryStream();
* using (var inStream = new XZDecompressStream(outStream)) {
* inStream.Read(data, 0, data.Length);
* }
* return outStream.ToArray();
*/
throw new NotImplementedException("LZMA support not yet implemented.");
}
default:
throw new Exception($"Unknown Compression Algorithm: {Config.MemoryCache.Type}");
}
}
/// <summary>
/// Uncompresses a zlib compressed byte array
/// </summary>
/// <param name="data">The compressed data</param>
/// <returns>The uncompressed data</returns>
public static byte[] UncompressBytes(byte[] data)
{
byte[] compressed = new byte[data.Length - 2];
Array.Copy(data, 2, compressed, 0, compressed.Length);
return(DeflateStream.UncompressBuffer(compressed));
}
public static byte[] Decompress(byte[] buffer)
{
byte[] toDecompress = new byte[buffer.Length - 2];
Array.Copy(buffer, 2, toDecompress, 0, toDecompress.Length);
return(DeflateStream.UncompressBuffer(toDecompress));
}
public T HttpPost <TP, T>(TP param, string url, RequestIdentity requestIdentity)
{
try
{
HttpContent httpContent = null;
if (param != null)
{
var requestjson = JsonConvert.SerializeObject(param);
httpContent = new StringContent(requestjson);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
Func <HttpContent, string> stringFunc = hc =>
{
var responsejson = hc.ReadAsByteArrayAsync().Result;
var str = DeflateStream.UncompressBuffer(responsejson);
var deresponsejson = Encoding.UTF8.GetString(str);
return(deresponsejson);
};
return(HttpHelper.HttpRequestPost <T>(url,
HttpHelper.HttpHeaderHandler(requestIdentity.ClientName, requestIdentity.ClientVersion,
requestIdentity.RandomCode,
requestIdentity.ApiVersion), httpContent, stringFunc));
}
catch (Exception exception)
{
//var message = exception.Message;
throw;
}
return(default(T));
}
private byte[] GetType2BlockData(long start, int compressedLength, int decompressedLength)
{
this.Stream.Seek(start, SeekOrigin.Begin);
var isCompressed = compressedLength < 32000;
var data = new byte[isCompressed ? compressedLength : decompressedLength];
this.Stream.Read(data, 0, data.Length);
if (isCompressed)
{
data = DeflateStream.UncompressBuffer(data);
}
return(data);
}
public static byte[] Decompress(byte[] data, string type)
{
switch (type)
{
case CompressionAlgorithm.Zlib:
return(ZlibStream.UncompressBuffer(data));
case CompressionAlgorithm.Deflate:
return(DeflateStream.UncompressBuffer(data));
case CompressionAlgorithm.GZip:
return(GZipStream.UncompressBuffer(data));
case CompressionAlgorithm.Lzma:
return(SevenZipHelper.Decompress(data));
}
return(data);
}
public byte[] Decompress()
{
byte[] decompressed = new byte[DecompressedLength];
int currentFileBufPos = 0;
foreach (var chunk in CompressedChunks)
{
byte[] decompressedChunk = DeflateStream.UncompressBuffer(chunk);
if (currentFileBufPos + decompressedChunk.Length > DecompressedLength)
{
byte[] newDecomp = new byte[currentFileBufPos + decompressedChunk.Length];
Buffer.BlockCopy(decompressed, 0, newDecomp, 0, currentFileBufPos);
decompressed = newDecomp;
}
Buffer.BlockCopy(decompressedChunk, 0, decompressed, currentFileBufPos, decompressedChunk.Length);
currentFileBufPos += decompressedChunk.Length;
}
return(decompressed);
}
public bool Read(EndianBinReader reader, uint size, uint realSize)
{
Size = size;
RealSize = realSize;
if ((Magic = reader.ReadUInt32()) != 0xC5EEF7FFu)
{
return(false);
}
DataSize = reader.ReadUInt32();
DataSize = (uint)-DataSize;
Size -= Consts.kVOLUME_SEGMENT_HEADER_SIZE;
Data = reader.ReadBytes((int)Size);
Data = DeflateStream.UncompressBuffer(Data);
System.Diagnostics.Debug.Assert(Data.Length == RealSize);
return(true);
}
public T HttpGet <T>(string url, RequestIdentity requestIdentity)
{
try
{
Func <HttpContent, string> stringFunc = hc =>
{
var responsejson = hc.ReadAsByteArrayAsync().Result;
var str = DeflateStream.UncompressBuffer(responsejson);
var deresponsejson = Encoding.UTF8.GetString(str);
return(deresponsejson);
};
return(HttpHelper.HttpRequestGet <T>(url,
HttpHelper.HttpHeaderHandler(requestIdentity.ClientName, requestIdentity.ClientVersion,
requestIdentity.RandomCode,
requestIdentity.ApiVersion), stringFunc));
}
catch (Exception exception)
{
//var message = exception.Message;
throw;
}
return(default(T));
}
protected DynValue Inflate(params DynValue[] values)
{
if (values.Length < 1)
{
Debug.LogError("Usage: Inflate(string)");
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString("Invalid arguments")));
}
if (values[0].Type != DataType.String)
{
Debug.LogError($"Inflate() argument 1: expected string, got {values[0].Type}");
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString("Invalid arguments")));
}
byte[] compressed = GetBytes(values[0].String);
try
{
byte[] decompressed = DeflateStream.UncompressBuffer(compressed);
return(DynValue.NewString(GetString(decompressed)));
}
catch (Exception e)
{
return(DynValue.NewTuple(DynValue.Nil, DynValue.NewString(e.Message)));
}
}
public static byte[] DecompressZlib(byte[] data)
{
return(DeflateStream.UncompressBuffer(data));
}
public static byte[] DeflateUnCompress(byte[] bytes)
{
return(DeflateStream.UncompressBuffer(bytes));
}
public override byte[] Inflate(byte[] buff)
{
return(DeflateStream.UncompressBuffer(buff));
}
private static byte[] LZDecompress(byte[] data)
{
return(DeflateStream.UncompressBuffer(data));
}
public byte[] DecompressDeflateStream(byte[] compressedBytes)
{
return(DeflateStream.UncompressBuffer(compressedBytes));
}
// These two data types are supported in DotNetZip, but only if .NET Framework is targeted.
//private SelfExtractorFlavor _selfExtractorFlavor;
//private SelfExtractorSaveOptions _selfExtractorSaveOptions;
public void CallAll()
{
// These two apis are supported in DotNetZip, but only if .NET Framework is targeted.
//_zipFile.SaveSelfExtractor(_string, _selfExtractorFlavor);
//_zipFile.SaveSelfExtractor(_string, _selfExtractorSaveOptions);
//Project: Ionic.Zip
_bZip2InputStream.Close();
_bZip2InputStream.Flush();
_int = _bZip2InputStream.Read(_bytes, _int, _int);
_int = _bZip2InputStream.ReadByte();
_long = _bZip2InputStream.Seek(_long, _seekOrigin);
_bZip2InputStream.SetLength(_long);
_bZip2InputStream.Write(_bytes, _int, _int);
_bZip2OutputStream.Close();
_bZip2OutputStream.Flush();
_int = _bZip2OutputStream.Read(_bytes, _int, _int);
_long = _bZip2OutputStream.Seek(_long, _seekOrigin);
_bZip2OutputStream.SetLength(_long);
_bZip2OutputStream.Write(_bytes, _int, _int);
_parallelBZip2OutputStream.Close();
_parallelBZip2OutputStream.Flush();
_int = _parallelBZip2OutputStream.Read(_bytes, _int, _int);
_long = _parallelBZip2OutputStream.Seek(_long, _seekOrigin);
_parallelBZip2OutputStream.SetLength(_long);
_parallelBZip2OutputStream.Write(_bytes, _int, _int);
_crc32.Combine(_int, _int);
_int = _crc32.ComputeCrc32(_int, _byte);
_int = _crc32.GetCrc32(_stream);
_int = _crc32.GetCrc32AndCopy(_stream, _stream);
_crc32.Reset();
_crc32.SlurpBlock(_bytes, _int, _int);
_crc32.UpdateCRC(_byte);
_crc32.UpdateCRC(_byte, _int);
_crcCalculatorStream.Close();
_crcCalculatorStream.Flush();
_int = _crcCalculatorStream.Read(_bytes, _int, _int);
_long = _crcCalculatorStream.Seek(_long, _seekOrigin);
_crcCalculatorStream.SetLength(_long);
_crcCalculatorStream.Write(_bytes, _int, _int);
_zipEntriesCollection = _fileSelector.SelectEntries(_zipFile);
_zipEntriesCollection = _fileSelector.SelectEntries(_zipFile, _string);
_stringsCollection = _fileSelector.SelectFiles(_string);
_stringsReadOnly = _fileSelector.SelectFiles(_string, _bool);
_string = _fileSelector.ToString();
_bool = _comHelper.CheckZip(_string);
_bool = _comHelper.CheckZipPassword(_string, _string);
_comHelper.FixZipDirectory(_string);
_string = _comHelper.GetZipLibraryVersion();
_bool = _comHelper.IsZipFile(_string);
_bool = _comHelper.IsZipFileWithExtract(_string);
_countingStream.Adjust(_long);
_countingStream.Flush();
_int = _countingStream.Read(_bytes, _int, _int);
_long = _countingStream.Seek(_long, _seekOrigin);
_countingStream.SetLength(_long);
_countingStream.Write(_bytes, _int, _int);
_zipEntry.Extract();
_zipEntry.Extract(_extractExistingFileAction);
_zipEntry.Extract(_string);
_zipEntry.Extract(_string, _extractExistingFileAction);
_zipEntry.Extract(_stream);
_zipEntry.ExtractWithPassword(_extractExistingFileAction, _string);
_zipEntry.ExtractWithPassword(_string);
_zipEntry.ExtractWithPassword(_string, _extractExistingFileAction, _string);
_zipEntry.ExtractWithPassword(_string, _string);
_zipEntry.ExtractWithPassword(_stream, _string);
_crcCalculatorStream = _zipEntry.OpenReader();
_crcCalculatorStream = _zipEntry.OpenReader(_string);
_zipEntry.SetEntryTimes(_datetime, _datetime, _datetime);
_string = _zipEntry.ToString();
_zipEntry = _zipFile.AddDirectory(_string);
_zipEntry = _zipFile.AddDirectory(_string, _string);
_zipEntry = _zipFile.AddDirectoryByName(_string);
_zipEntry = _zipFile.AddEntry(_string, _bytes);
_zipEntry = _zipFile.AddEntry(_string, _openDelegate, _closeDelegate);
_zipEntry = _zipFile.AddEntry(_string, _writeDelegate);
_zipEntry = _zipFile.AddEntry(_string, _string);
_zipEntry = _zipFile.AddEntry(_string, _string, _encoding);
_zipEntry = _zipFile.AddEntry(_string, _stream);
_zipEntry = _zipFile.AddFile(_string);
_zipEntry = _zipFile.AddFile(_string, _string);
_zipFile.AddFiles(_strings);
_zipFile.AddFiles(_strings, _bool, _string);
_zipFile.AddFiles(_strings, _string);
_zipEntry = _zipFile.AddItem(_string);
_zipEntry = _zipFile.AddItem(_string, _string);
_zipFile.AddSelectedFiles(_string);
_zipFile.AddSelectedFiles(_string, _bool);
_zipFile.AddSelectedFiles(_string, _string);
_zipFile.AddSelectedFiles(_string, _string, _bool);
_zipFile.AddSelectedFiles(_string, _string, _string);
_zipFile.AddSelectedFiles(_string, _string, _string, _bool);
_bool = _zipFile.ContainsEntry(_string);
_zipFile.Dispose();
_zipFile.ExtractAll(_string);
_zipFile.ExtractAll(_string, _extractExistingFileAction);
_zipFile.ExtractSelectedEntries(_string);
_zipFile.ExtractSelectedEntries(_string, _extractExistingFileAction);
_zipFile.ExtractSelectedEntries(_string, _string);
_zipFile.ExtractSelectedEntries(_string, _string, _string);
_zipFile.ExtractSelectedEntries(_string, _string, _string, _extractExistingFileAction);
_enumerator = _zipFile.GetNewEnum();
_zipFile.Initialize(_string);
_zipFile.RemoveEntries(_zipEntriesCollection);
_zipFile.RemoveEntries(_stringsCollection);
_zipFile.RemoveEntry(_zipEntry);
_zipFile.RemoveEntry(_string);
_int = _zipFile.RemoveSelectedEntries(_string);
_int = _zipFile.RemoveSelectedEntries(_string, _string);
_zipFile.Save();
_zipFile.Save(_string);
_zipFile.Save(_stream);
_zipEntriesCollection = _zipFile.SelectEntries(_string);
_zipEntriesCollection = _zipFile.SelectEntries(_string, _string);
_string = _zipFile.ToString();
_zipEntry = _zipFile.UpdateDirectory(_string);
_zipEntry = _zipFile.UpdateDirectory(_string, _string);
_zipEntry = _zipFile.UpdateEntry(_string, _bytes);
_zipEntry = _zipFile.UpdateEntry(_string, _openDelegate, _closeDelegate);
_zipEntry = _zipFile.UpdateEntry(_string, _writeDelegate);
_zipEntry = _zipFile.UpdateEntry(_string, _string);
_zipEntry = _zipFile.UpdateEntry(_string, _string, _encoding);
_zipEntry = _zipFile.UpdateEntry(_string, _stream);
_zipEntry = _zipFile.UpdateFile(_string);
_zipFile.UpdateFile(_string, _string);
_zipFile.UpdateFiles(_strings);
_zipFile.UpdateFiles(_strings, _string);
_zipFile.UpdateItem(_string);
_zipFile.UpdateItem(_string, _string);
_zipFile.UpdateSelectedFiles(_string, _string, _string, _bool);
_zipInputStream.Flush();
_zipEntry = _zipInputStream.GetNextEntry();
_int = _zipInputStream.Read(_bytes, _int, _int);
_long = _zipInputStream.Seek(_long, _seekOrigin);
_zipInputStream.SetLength(_long);
_string = _zipInputStream.ToString();
_zipInputStream.Write(_bytes, _int, _int);
_bool = _zipOutputStream.ContainsEntry(_string);
_zipOutputStream.Flush();
_zipEntry = _zipOutputStream.PutNextEntry(_string);
_int = _zipOutputStream.Read(_bytes, _int, _int);
_long = _zipOutputStream.Seek(_long, _seekOrigin);
_zipOutputStream.SetLength(_long);
_string = _zipOutputStream.ToString();
_zipOutputStream.Write(_bytes, _int, _int);
_deflateStream.Flush();
_int = _deflateStream.Read(_bytes, _int, _int);
_long = _deflateStream.Seek(_long, _seekOrigin);
_deflateStream.SetLength(_long);
_deflateStream.Write(_bytes, _int, _int);
_gZipStream.Flush();
_int = _gZipStream.Read(_bytes, _int, _int);
_long = _gZipStream.Seek(_long, _seekOrigin);
_gZipStream.SetLength(_long);
_gZipStream.Write(_bytes, _int, _int);
_parallelDeflateOutputStream.Close();
_parallelDeflateOutputStream.Flush();
_int = _parallelDeflateOutputStream.Read(_bytes, _int, _int);
_parallelDeflateOutputStream.Reset(_stream);
_long = _parallelDeflateOutputStream.Seek(_long, _seekOrigin);
_parallelDeflateOutputStream.SetLength(_long);
_parallelDeflateOutputStream.Write(_bytes, _int, _int);
// Static
_bool = ZipFile.CheckZip(_string);
_bool = ZipFile.CheckZip(_string, _bool, _textWriter);
_bool = ZipFile.CheckZipPassword(_string, _string);
ZipFile.FixZipDirectory(_string);
_bool = ZipFile.IsZipFile(_string);
_bool = ZipFile.IsZipFile(_string, _bool);
_bool = ZipFile.IsZipFile(_stream, _bool);
_zipFile = ZipFile.Read(_string);
_zipFile = ZipFile.Read(_string, _readOptions);
_zipFile = ZipFile.Read(_stream);
_zipFile = ZipFile.Read(_stream, _readOptions);
_uint = Adler.Adler32(_uint, _bytes, _int, _int);
_bytes = DeflateStream.CompressBuffer(_bytes);
_bytes = DeflateStream.CompressString(_string);
_bytes = DeflateStream.UncompressBuffer(_bytes);
_string = DeflateStream.UncompressString(_bytes);
_bytes = GZipStream.CompressBuffer(_bytes);
_bytes = GZipStream.CompressString(_string);
_bytes = GZipStream.UncompressBuffer(_bytes);
_string = GZipStream.UncompressString(_bytes);
_bytes = ZlibStream.CompressBuffer(_bytes);
_bytes = ZlibStream.CompressString(_string);
_bytes = ZlibStream.UncompressBuffer(_bytes);
_string = ZlibStream.UncompressString(_bytes);
}
public static void RunDatTest()
{
byte[] rawData = File.ReadAllBytes("empires2_x1_p1.dat");
byte[] uncompressedData = DeflateStream.UncompressBuffer(rawData);
File.WriteAllBytes("empires2.bin", uncompressedData);
}
internal static byte[] Decompress(byte[] data)
{
return(DeflateStream.UncompressBuffer(data));
}
private static byte[] Decompress(byte[] src)
{
return(DeflateStream.UncompressBuffer(src));
}
