public void DoTest()
{
byte[] buffer = new byte[1000000];
var rnd = new Random();
rnd.NextBytes(buffer);
double ratio;
Stopwatch watch = new Stopwatch();
watch.Start();
var output = Deflater.Do(buffer);
watch.Stop();
Console.WriteLine(watch.Elapsed);
Console.WriteLine($"origin {buffer.Length} bytes, deflated {output.Length} bytes.");
watch.Reset();
watch.Start();
Deflater.Do(buffer);
watch.Stop();
Console.WriteLine(watch.Elapsed);
Console.WriteLine($"origin {buffer.Length} bytes, deflated {output.Length} bytes.");
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// The output stream where deflated output is written.
/// </param>
/// <param name="deflater">
/// The underlying deflater to use
/// </param>
/// <param name="bufferSize">
/// The buffer size in bytes to use when deflating (minimum value 512)
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// bufsize is less than or equal to zero.
/// </exception>
/// <exception cref="ArgumentException">
/// baseOutputStream does not support writing
/// </exception>
/// <exception cref="ArgumentNullException">
/// deflater instance is null
/// </exception>
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize)
{
if (baseOutputStream == null)
{
throw new ArgumentNullException("baseOutputStream");
}
if (baseOutputStream.CanWrite == false)
{
throw new ArgumentException("Must support writing", "baseOutputStream");
}
if (deflater == null)
{
throw new ArgumentNullException("deflater");
}
if (bufferSize < 512)
{
throw new ArgumentOutOfRangeException("bufferSize");
}
baseOutputStream_ = baseOutputStream;
buffer_ = new byte[bufferSize];
deflater_ = deflater;
}
private static byte[] Compress(byte[] data)
{
byte[] numArray;
try
{
Deflater deflater = new Deflater();
MemoryStream memoryStream = new MemoryStream((int)data.Length);
DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(memoryStream, deflater);
deflaterOutputStream.Write(data, 0, (int)data.Length);
deflaterOutputStream.Flush();
deflaterOutputStream.Finish();
byte[] array = memoryStream.ToArray();
byte[] bytes = BitConverter.GetBytes((ulong)((long)((int)data.Length)));
byte[] numArray1 = new byte[(int)array.Length + FileUtil.BNET_COMPRESSED_HEADER_SIZE];
int length = 0;
Array.Copy(FileUtil.BNET_COMPRESSED_MAGIC_BYTES, 0, numArray1, length, (int)FileUtil.BNET_COMPRESSED_MAGIC_BYTES.Length);
length += (int)FileUtil.BNET_COMPRESSED_MAGIC_BYTES.Length;
Array.Copy(FileUtil.BNET_COMPRESSED_VERSION_BYTES, 0, numArray1, length, (int)FileUtil.BNET_COMPRESSED_VERSION_BYTES.Length);
length += (int)FileUtil.BNET_COMPRESSED_VERSION_BYTES.Length;
Array.Copy(bytes, 0, numArray1, length, (int)bytes.Length);
length += (int)bytes.Length;
Array.Copy(array, 0, numArray1, length, (int)array.Length);
return(numArray1);
}
catch (Exception exception)
{
numArray = null;
}
return(numArray);
}
public static async Task <ChunkBuilder> Create(BA2DX10EntryState state, ChunkState chunk, Stream src, DiskSlabAllocator slab)
{
var builder = new ChunkBuilder {
_chunk = chunk
};
if (!chunk.Compressed)
{
builder._dataSlab = slab.Allocate(chunk.FullSz);
await src.CopyToWithStatusAsync((int)chunk.FullSz, builder._dataSlab, $"Writing {state.Path} {chunk.StartMip}:{chunk.EndMip}");
}
else
{
var deflater = new Deflater(Deflater.BEST_COMPRESSION);
await using var ms = new MemoryStream();
await using (var ds = new DeflaterOutputStream(ms, deflater))
{
ds.IsStreamOwner = false;
await src.CopyToWithStatusAsync((int)chunk.FullSz, ds, $"Compressing {state.Path} {chunk.StartMip}:{chunk.EndMip}");
}
builder._dataSlab = slab.Allocate(ms.Length);
ms.Position = 0;
await ms.CopyToWithStatusAsync(ms.Length, builder._dataSlab, $"Writing {state.Path} {chunk.StartMip}:{chunk.EndMip}");
builder._packSize = (uint)ms.Length;
}
builder._dataSlab.Position = 0;
return(builder);
}
/// <summary>
/// Release all deflater instance
/// </summary>
public static void ReleaseDeflater()
{
if (_deflaterBest != null)
{
_deflaterBest.DataAvailable -= ZLibWrapper.WriteInOutputBuffer;
_deflaterBest.Dispose();
_deflaterBest = null;
}
if (_deflaterNone != null)
{
_deflaterNone.DataAvailable -= ZLibWrapper.WriteInOutputBuffer;
_deflaterNone.Dispose();
_deflaterNone = null;
}
if (_deflaterFastest != null)
{
_deflaterFastest.DataAvailable -= ZLibWrapper.WriteInOutputBuffer;
_deflaterFastest.Dispose();
_deflaterFastest = null;
}
if (_deflaterDefault != null)
{
_deflaterDefault.DataAvailable -= ZLibWrapper.WriteInOutputBuffer;
_deflaterDefault.Dispose();
_deflaterDefault = null;
}
}
/// <summary>
/// 压缩数据，如果压缩阀值为-1表示不对数据流进行压缩处理
/// </summary>
/// <param name="val">原始数据流</param>
/// <returns>压缩后数据流</returns>
public byte[] Compress(byte[] val)
{
byte[] buf;
if (overSize != -1 && val.Length > overSize)
{
using (MemoryStream destStream = new MemoryStream()) {
Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
using (DeflaterOutputStream compressStream = new DeflaterOutputStream(destStream, deflater)) {
compressStream.Write(val, 0, val.Length);
compressStream.Finish();
buf = new byte[destStream.Length + 1];
destStream.ToArray().CopyTo(buf, 1);
}
buf[0] = 1; // 已压缩标志
return(buf);
}
}
else
{
buf = new byte[val.Length + 1];
val.CopyTo(buf, 1);
buf[0] = 0; // 未压缩标志
return(buf);
}
}
private static MemoryStream Compress(MemoryStream stream)
{
stream.Position = 0;
byte[] input = stream.ToArray();
byte[] size = BitConverter.GetBytes(Convert.ToUInt32(input.Length));
Deflater compressor = new Deflater();
compressor.SetLevel(Deflater.BEST_SPEED);
compressor.SetInput(input);
compressor.Finish();
MemoryStream bos = new MemoryStream(input.Length);
byte[] buf = new byte[1024];
while (!compressor.IsFinished)
{
int count = compressor.Deflate(buf);
bos.Write(buf, 0, count);
}
MemoryStream result = new MemoryStream();
BinaryWriter writeBinary = new BinaryWriter(result);
writeBinary.Write(size);
writeBinary.Write(bos.ToArray());
writeBinary.Close();
return(result);
}
public CompressionHandler(int compressionThreshold)
{
_deflater = new Deflater(Deflater.DEFAULT_COMPRESSION);
_inflater = new Inflater();
CompressionThreshold = compressionThreshold;
}
//pes 18
//Zlib //PC
public static byte[] ZLIBFile(byte[] inputData)
{
uint fsize = (uint)inputData.Length;
Deflater deflater = new Deflater(9);
deflater.SetInput(inputData);
deflater.Finish();
using (var ms = new MemoryStream())
{
var outputBuffer = new byte[65536 * 32];
while (deflater.IsNeedingInput == false)
{
var read = deflater.Deflate(outputBuffer);
ms.Write(outputBuffer, 0, read);
if (deflater.IsFinished == true)
{
break;
}
}
deflater.Reset();
uint zsize = (uint)ms.Length;
byte[] header = { 0x04, 0x10, 0x01, 0x57, 0x45, 0x53, 0x59, 0x53 };
byte[] b1, b2;
b1 = BitConverter.GetBytes(zsize);
b2 = BitConverter.GetBytes(fsize);
byte[] zlib = ms.ToArray();
return(header.Concat(b1).Concat(b2).Concat(zlib).ToArray());
}
}
/// <summary>
/// Encode a RIF byte array to zRIF string.
/// </summary>
/// <param name="zrif">The zRIF string.</param>
/// <returns>The zRIF string or null on error.</returns>
public static string Encode(byte[] rif)
{
byte[] output = new byte[128 + 2];
if ((rif.Length != 512) && (rif.Length != 1024))
{
Console.Error.WriteLine("[ERROR] invalid RIF length");
return(null);
}
var deflater = new Deflater();
deflater.SetDictionary(zrif_dict);
deflater.SetInput(rif);
deflater.SetLevel(Deflater.BEST_COMPRESSION);
deflater.SetStrategy(DeflateStrategy.Default);
deflater.Finish();
int size = deflater.Deflate(output, 0, output.Length - 2);
if (!deflater.IsFinished)
{
Console.Error.WriteLine("[ERROR] Deflate error");
return(null);
}
// Don't have that much control over Window size so our header needs to be adjusted.
if ((output[0] == 0x78) && (output[1] == 0xF9))
{
output[0] = 0x28;
output[1] = 0xEE;
}
// Adjust the size to be a multiple of 3 so that we don't get padding
return(Convert.ToBase64String(output, 0, ((size + 2) / 3) * 3));
}
public static String Compress(string str)
{
byte[] bytesToCompress = ASCIIEncoding.UTF8.GetBytes(str);
// Compressor with highest level of compression.
Deflater compressor = new Deflater(Deflater.BEST_COMPRESSION);
compressor.SetInput(bytesToCompress); // Give the compressor the data to
// compress.
compressor.Finish();
// Create an expandable byte array to hold the compressed data.
// It is not necessary that the compressed data will be smaller than
// the uncompressed data.
byte[] ret = null;
using (MemoryStream memStream = new MemoryStream(bytesToCompress.Length))
{
// Compress the data
byte[] buf = new byte[bytesToCompress.Length + 100];
while (!compressor.IsFinished)
{
memStream.Write(buf, 0, compressor.Deflate(buf));
}
memStream.Close();
ret = memStream.ToArray();
}
// Get the compressed data
return(Convert.ToBase64String(ret));
}
private const int CopyBufferSize = 32 * 1024; // 32kb
public void Compress(Stream source, Stream destination)
{
/*
* var deflater = new DeflaterOutputStream(destination, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
*
* var dataBuffer = new byte[CopyBufferSize];
* StreamUtils.Copy(source, deflater, dataBuffer);
*/
var def = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
var inputData = new byte[source.Length - source.Position];
source.Read(inputData, 0, inputData.Length);
var buffer = new byte[CopyBufferSize];
def.SetInput(inputData, 0, inputData.Length);
def.Finish();
while (!def.IsFinished)
{
int outputLen = def.Deflate(buffer, 0, buffer.Length);
destination.Write(buffer, 0, outputLen);
}
def.Reset();
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// The output stream where deflated output is written.
/// </param>
/// <param name="deflater">
/// The underlying deflater to use
/// </param>
/// <param name="bufferSize">
/// The buffer size in bytes to use when deflating (minimum value 512)
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// bufsize is less than or equal to zero.
/// </exception>
/// <exception cref="ArgumentException">
/// baseOutputStream does not support writing
/// </exception>
/// <exception cref="ArgumentNullException">
/// deflater instance is null
/// </exception>
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize)
{
if (baseOutputStream == null)
{
throw new ArgumentNullException("baseOutputStream");
}
if (baseOutputStream.CanWrite == false)
{
throw new ArgumentException("Must support writing", "baseOutputStream");
}
if (deflater == null)
{
throw new ArgumentNullException("deflater");
}
if (bufferSize < 512)
{
throw new ArgumentOutOfRangeException("bufferSize");
}
baseOutputStream_ = baseOutputStream;
buffer_ = new byte[bufferSize];
deflater_ = deflater;
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// The output stream where deflated output is written.
/// </param>
/// <param name="deflater">
/// The underlying deflater to use
/// </param>
/// <param name="bufferSize">
/// The buffer size in bytes to use when deflating (minimum value 512)
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// bufsize is less than or equal to zero.
/// </exception>
/// <exception cref="ArgumentException">
/// baseOutputStream does not support writing
/// </exception>
/// <exception cref="ArgumentNullException">
/// deflater instance is null
/// </exception>
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize)
{
IsStreamOwner = true;
if (baseOutputStream == null)
{
throw new ArgumentNullException("baseOutputStream");
}
if (baseOutputStream.CanWrite == false)
{
throw new ArgumentException("Must support writing", SerialportSample.XWUtils.nameof(baseOutputStream));
}
if (deflater == null)
{
throw new ArgumentNullException(SerialportSample.XWUtils.nameof(deflater));
}
if (bufferSize < 512)
{
throw new ArgumentOutOfRangeException(SerialportSample.XWUtils.nameof(bufferSize));
}
baseOutputStream_ = baseOutputStream;
buffer_ = new byte[bufferSize];
deflater_ = deflater;
}
/// <summary>
/// Write out bytes to the underlying stream after compressing them using deflate
/// </summary>
/// <param name="buffer">The array of bytes to write</param>
/// <param name="offset">The offset into the supplied buffer to start</param>
/// <param name="count">The number of bytes to write</param>
public override void Write(byte[] buffer, int offset, int count)
{
if (m_stream == null)
{
Deflater deflater;
switch (CompressionLevel)
{
case CompressionLevels.High:
deflater = new Deflater(Deflater.BEST_COMPRESSION, true);
break;
case CompressionLevels.Low:
deflater = new Deflater(Deflater.BEST_SPEED, true);
break;
case CompressionLevels.Normal:
default:
deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
break;
}
m_stream = new DeflaterOutputStream(BaseStream, deflater);
}
m_stream.Write(buffer, offset, count);
}
public static ChunkBuilder Create(BA2DX10EntryState state, ChunkState chunk, Stream src, DiskSlabAllocator slab)
{
var builder = new ChunkBuilder {
_chunk = chunk
};
if (!chunk.Compressed)
{
builder._dataSlab = slab.Allocate(chunk.FullSz);
src.CopyToLimit(builder._dataSlab, (int)chunk.FullSz);
}
else
{
var deflater = new Deflater(Deflater.BEST_COMPRESSION);
using var ms = new MemoryStream();
using (var ds = new DeflaterOutputStream(ms, deflater))
{
ds.IsStreamOwner = false;
src.CopyToLimit(ds, (int)chunk.FullSz);
}
builder._dataSlab = slab.Allocate(ms.Length);
ms.Position = 0;
ms.CopyTo(builder._dataSlab);
builder._packSize = (uint)ms.Length;
}
builder._dataSlab.Position = 0;
return(builder);
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// The output stream where deflated output is written.
/// </param>
/// <param name="deflater">
/// The underlying deflater to use
/// </param>
/// <param name="bufferSize">
/// The buffer size in bytes to use when deflating (minimum value 512)
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// bufsize is less than or equal to zero.
/// </exception>
/// <exception cref="ArgumentException">
/// baseOutputStream does not support writing
/// </exception>
/// <exception cref="ArgumentNullException">
/// deflater instance is null
/// </exception>
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize)
{
if (baseOutputStream == null)
{
//throw new ArgumentNullException(//nameof//(baseOutputStream));
}
if (baseOutputStream.CanWrite == false)
{
//throw new ArgumentException("Must support writing", //nameof//(baseOutputStream));
}
if (deflater == null)
{
//throw new ArgumentNullException(//nameof//(deflater));
}
if (bufferSize < 512)
{
//throw new //nameofnameof//(bufferSize));
}
baseOutputStream_ = baseOutputStream;
buffer_ = new byte[bufferSize];
deflater_ = deflater;
}
/// <summary>
/// 压缩字符串数据
/// </summary>
/// <param name="data">压缩字符串</param>
/// <param name="result">返回压缩内容</param>
/// <returns></returns>
public static bool Compress(string data, ref string result)
{
try
{
byte[] buffer;
using (MemoryStream ms = new MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, data);
buffer = ms.ToArray();
ms.Close();
ms.Dispose();
}
using (MemoryStream msout = new MemoryStream())
{
Deflater defl = new Deflater();
using (DeflaterOutputStream mem1 = new DeflaterOutputStream(msout, defl))
{
mem1.Write(buffer, 0, buffer.Length);
mem1.Close();
mem1.Dispose();
}
result = Convert.ToBase64String(msout.ToArray());
msout.Close();
msout.Dispose();
}
return(true);
}
catch (Exception ex)
{
result = ex.Message;
return(false);
}
}
/// <summary>
/// Deflates the decompressed bytes.
/// </summary>
/// <param name="decompressedData"> Data. </param>
/// <param name="offset"> Offset in the data. </param>
/// <param name="count"> Number of the written bytes. </param>
/// <param name="compressedSize"> Compressed size. Optional parameter, but if it is known, then passing of the parameter may increasing performance. </param>
/// <returns> Array of the compressed bytes. </returns>
public static byte[] Deflate(byte[] decompressedData, int offset, int count, int?compressedSize = null)
{
IByteArrayWriter writer = new ByteArrayWriter(true);
Deflater deflater = new Deflater(Deflater.DEFLATED);
deflater.SetInput(decompressedData, offset, count);
deflater.Finish();
int length = (compressedSize != null) ? compressedSize.Value : count;
byte[] compressedData;
int processedBytes;
while (true)
{
compressedData = new byte[length];
processedBytes = deflater.Deflate(compressedData, 0, length);
if (processedBytes != 0)
{
writer.WriteBytes(compressedData, 0, processedBytes);
}
else
{
if (deflater.IsFinished)
{
break;
}
}
}
return(writer.GetBytes());
}
public static byte[] Compress(byte[] input)
{
// Create the compressor with highest level of compression
Deflater compressor = new Deflater();
compressor.SetLevel(Deflater.BEST_COMPRESSION);
// Give the compressor the data to compress
compressor.SetInput(input);
compressor.Finish();
/*
* Create an expandable byte array to hold the compressed data.
* You cannot use an array that's the same size as the orginal because
* there is no guarantee that the compressed data will be smaller than
* the uncompressed data.
*/
MemoryStream bos = new MemoryStream(input.Length);
// Compress the data
byte[] buf = new byte[1024];
while (!compressor.IsFinished)
{
int count = compressor.Deflate(buf);
bos.Write(buf, 0, count);
}
// Get the compressed data
return(bos.ToArray());
}
void IPreviewCallback.OnPreviewFrame(byte[] b, Camera c)
{
Android.Graphics.YuvImage yuvImage = new Android.Graphics.YuvImage(b, Android.Graphics.ImageFormat.Nv21, previewSize.Width, previewSize.Height, null);
byte[] msg = new byte[65000];
MemoryStream ms = new MemoryStream();
yuvImage.CompressToJpeg(new Android.Graphics.Rect(0, 0, previewSize.Width, previewSize.Height), 100, ms);
Deflater compresser = new Deflater();
compresser.SetInput(ms.ToArray());
compresser.Finish();
compresser.Deflate(msg); //int length = compresser.Deflate(msg);
compresser.End();
var current = Connectivity.NetworkAccess;
if (current == Xamarin.Essentials.NetworkAccess.Internet)
{
try
{
Sock.SendTo(msg, EndP);
}
catch
{
}
}
Thread.Sleep(300);
}
/// <summary>
/// Compresses the specified byte range using the
/// specified compressionLevel (constants are defined in
/// java.util.zip.Deflater).
/// </summary>
public static byte[] Compress(byte[] value, int offset, int length, int compressionLevel)
{
/* Create an expandable byte array to hold the compressed data.
* You cannot use an array that's the same size as the orginal because
* there is no guarantee that the compressed data will be smaller than
* the uncompressed data. */
var bos = new ByteArrayOutputStream(length);
Deflater compressor = SharpZipLib.CreateDeflater();
try
{
compressor.SetLevel(compressionLevel);
compressor.SetInput(value, offset, length);
compressor.Finish();
// Compress the data
var buf = new byte[1024];
while (!compressor.IsFinished)
{
int count = compressor.Deflate(buf);
bos.Write(buf, 0, count);
}
}
finally
{
}
return(bos.ToArray());
}
public static byte[] ZlibCompress(byte[] input)
{
using var ms = new MemoryStream(input.Length);
using var bs = new BinaryStream(ms);
bs.WriteUInt32(Constants.ZLIB_MAGIC);
bs.WriteInt32(-input.Length);
/* For some reason System.IO.Compression has issues making the games load these files?
* using var ds = new DeflateStream(ms, CompressionLevel.Optimal);
* ds.Write(input, 0, input.Length);
* ds.Flush();
*/
// Fall back to ICSharpCode
var d = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
d.SetInput(input);
d.Finish();
int count = d.Deflate(input);
bs.Write(input, 0, count);
return(ms.ToArray());
}
private static byte[] Compress(byte[] zlib)
{
// Create a GZIP stream with decompression mode.
// ... Then create a buffer and write into while reading from the GZIP stream.
using (MemoryStream memory = new MemoryStream())
{
var def = new Deflater();
def.setInput(gzip);
def.finish();
var decompressStream = new MemoryStream();
int i = 0;
var buffer = new byte[1024 * 1024];
while ((i = def.deflate(buffer)) > 0)
{
decompressStream.Write(buffer, 0, i);
}
return(decompressStream.ToArray());
}
//using (GZipStream stream = new GZipStream(memory, CompressionMode.Compress))
//{
// stream.Write(gzip, 0, gzip.Length);
// stream.Flush();
// stream.Close();
// return memory.ToArray();
//}
}
/// <summary>
/// 字节数组压缩
/// </summary>
/// <param name="data">待压缩的字节数组</param>
/// <param name="isClearData">压缩完成后，是否清除待压缩字节数组里面的内容</param>
/// <returns>已压缩的字节数组</returns>
public static byte[] ZipCompress(byte[] data, bool isClearData = true)
{
byte[] bytes = null;
Deflater f = new Deflater(Deflater.BEST_COMPRESSION);
f.SetInput(data);
f.Finish();
int count = 0;
using (MemoryStream o = new MemoryStream(data.Length))
{
byte[] buffer = new byte[BUFFER_LENGTH];
while (!f.IsFinished)
{
count = f.Deflate(buffer);
o.Write(buffer, 0, count);
}
bytes = o.ToArray();
}
if (isClearData)
{
Array.Clear(data, 0, data.Length);
}
return(bytes);
}
protected override void OnBeforeWrite(Network.Client client, Server.Core.Stream.ByteBuffer buffer)
{
buffer.WriteVarint(ID);
buffer.WriteInt(client.TheWorld.FlatWorld[Ndx].X);
buffer.WriteInt(client.TheWorld.FlatWorld[Ndx].Z);
buffer.WriteBoolean(GroundUpContinuous);
buffer.WriteLEUShort(PrimaryBitmap);
buffer.WriteShort((short)SecondaryBitmap);
byte[] chunkData = client.TheWorld.FlatWorld[Ndx].ChunkData;
byte[] compressData = new byte[chunkData.Length];
ConcurrentStack <Deflater> DeflaterPool = new ConcurrentStack <Deflater>();
Deflater deflater;
DeflaterPool.TryPop(out deflater);
if (deflater == null)
{
deflater = new Deflater(5);
}
deflater.SetInput(chunkData, 0, chunkData.Length);
deflater.Finish();
int length = deflater.Deflate(compressData);
deflater.Reset();
DeflaterPool.Push(deflater);
buffer.WriteInt(length);
buffer.Write(compressData, 0, length);
}
/// <summary>
/// Compress the contents of the provided array
/// </summary>
/// <param name="data">An uncompressed byte array</param>
/// <returns></returns>
public static byte[] Compress(byte[] data)
{
using (MemoryStream out1 = new MemoryStream())
{
Deflater deflater = new Deflater(0, false);
DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(out1, deflater);
try
{
//for (int i = 0; i < data.Length; i++)
//deflaterOutputStream.WriteByte(data[i]);
deflaterOutputStream.Write(data, 0, data.Length); //Tony Qu changed the code
return(out1.ToArray());
}
catch (IOException e)
{
throw new RecordFormatException(e.ToString());
}
finally
{
out1.Close();
if (deflaterOutputStream != null)
{
deflaterOutputStream.Close();
}
}
}
}
public void Compress()
{
var deflater = new Deflater();
byte[] packet = PacketData;
deflater.SetInput(packet, 0, packet.Length);
deflater.Finish();
var compBuffer = new byte[1024];
var ret = new List <byte>();
while (!deflater.IsFinished)
{
try
{
deflater.Deflate(compBuffer);
ret.AddRange(compBuffer);
Array.Clear(compBuffer, 0, compBuffer.Length);
}
catch (Exception ex)
{
return;
}
}
deflater.Reset();
Seek((byte)_headerType, SeekOrigin.Begin);
// Write the compressed bytes over whatever is there.
Write(ret.ToArray());
// Set the stream length to the end of the actual packet data.
// This makes sure we don't have any 'junk' packets at the end.
OutStream.SetLength(BaseStream.Position);
}
private static byte[] Compress(byte[] zlib)
{
// Create a GZIP stream with decompression mode.
// ... Then create a buffer and write into while reading from the GZIP stream.
using (MemoryStream memory = new MemoryStream())
{
var def = new Deflater();
def.setInput(gzip);
def.finish();
var decompressStream = new MemoryStream();
int i = 0;
var buffer = new byte[1024 * 1024];
while ((i = def.deflate(buffer)) > 0)
{
decompressStream.Write(buffer, 0, i);
}
return decompressStream.ToArray();
}
//using (GZipStream stream = new GZipStream(memory, CompressionMode.Compress))
//{
// stream.Write(gzip, 0, gzip.Length);
// stream.Flush();
// stream.Close();
// return memory.ToArray();
//}
}
public void SetLevel(int level)
{
if (level < 1)
{
throw new ArgumentOutOfRangeException("level");
}
Deflater.SetLevel(level);
}
public ZlibOutputStreamIs(Stream st, int compressLevel, EDeflateCompressStrategy strat, bool leaveOpen)
: base(st,compressLevel,strat,leaveOpen)
{
deflater=new Deflater(compressLevel);
setStrat(strat);
ost = new DeflaterOutputStream(st, deflater);
ost.IsStreamOwner = !leaveOpen;
}
// Constructor.
public ZlibCompressor(ChunkWriter writer)
{
this.writer = writer;
deflater = new Deflater();
outBuffer = new byte [4096];
outLen = 0;
wroteBlock = false;
}
public ZlibOutputStreamIs(Stream st, int compressLevel, EDeflateCompressStrategy strat, bool leaveOpen)
: base(st, compressLevel, strat, leaveOpen)
{
deflater = new Deflater(compressLevel);
setStrat(strat);
ost = new DeflaterOutputStream(st, deflater);
ost.IsStreamOwner = !leaveOpen;
}
public DeflaterOutputStream(MemoryStream buf1, Deflater deflater)
{
this.buf1 = buf1;
this.deflater = deflater;
if (PDF.original_zlib) {
ds2 = new OptionalDeflateStream(buf1);
} else {
buf2 = new MemoryStream();
buf2.WriteByte(0x58); // These are the correct values for
buf2.WriteByte(0x85); // CMF and FLG according to Microsoft
ds1 = new DeflateStream(buf2, CompressionMode.Compress, true);
}
}
public static void Main(string [] args)
{
if (args.Length == 0 || args.Length > 3) {
Console.WriteLine ("Usage: zipmark FILE [ITERATIONS] [BLOCKSIZE]");
return;
}
string filename = args [0];
FileInfo file = new FileInfo (filename);
if (!file.Exists) {
Console.WriteLine ("Couldn't find file {0}", filename);
return;
}
FileStream fs = file.OpenRead ();
byte [] raw = new byte [file.Length];
int count = fs.Read (raw, 0, (int)file.Length);
fs.Close ();
if (count != file.Length) {
Console.WriteLine ("Couldn't read file {0}", filename);
return;
}
Deflater def = new Deflater (Deflater.BEST_COMPRESSION, false);
Inflater inf = new Inflater (false);
// 1. Count deflated size
int cooked_size = Deflate (def, raw, null);
byte [] cooked = new byte [cooked_size];
// 2. Deflate & Inflate
if (args.Length > 1)
Iterations = Int32.Parse (args [1]);
if (args.Length > 2)
BlockSize = Int32.Parse (args [2]);
for (int i = 0; i < Iterations; ++ i) {
Deflate (def, raw, cooked);
Inflate (inf, cooked, raw);
}
return;
}
public DeflateStream(Stream stream, CompressionMode mode, bool leaveOpen)
{
if(stream == null)
{
throw new ArgumentNullException("stream");
}
if(mode == CompressionMode.Decompress)
{
if(!stream.CanRead)
{
throw new ArgumentException
(S._("IO_NotReadable"), "stream");
}
}
else if(mode == CompressionMode.Compress)
{
if(!stream.CanWrite)
{
throw new ArgumentException
(S._("IO_NotWritable"), "stream");
}
}
else
{
throw new ArgumentException
(S._("IO_CompressionMode"), "mode");
}
this.stream = stream;
this.mode = mode;
this.leaveOpen = leaveOpen;
this.buf = new byte [4096];
if(mode == CompressionMode.Decompress)
{
inflater = new Inflater();
}
else
{
deflater = new Deflater();
}
}
/// <summary>
/// SharpZipѹËõ
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static byte[] CompressSharpZip(byte[] buffer)
{
if (buffer == null || buffer.Length == 0)
{
return buffer;
}
using (MemoryStream inStream = new MemoryStream(buffer))
{
MemoryStream outStream = new MemoryStream();
Deflater mDeflater = new Deflater(Deflater.BEST_COMPRESSION);
DeflaterOutputStream compressStream = new DeflaterOutputStream(outStream, mDeflater);
int mSize;
byte[] mWriteData = new Byte[4096];
while ((mSize = inStream.Read(mWriteData, 0, 4096)) > 0)
{
compressStream.Write(mWriteData, 0, mSize);
}
compressStream.Finish();
inStream.Close();
return outStream.ToArray();
}
}
private static int compress(int tp, byte[] inBytes, int inSize, byte[] outBytes)
{
if (inSize == 0)
return 0;
int t1 = 0, t2 = (inSize + 1) / 2;
int inPtr = 0, ret;
byte[] tmp = new byte[inSize];
// zip and rle treat the data first, in the same way so I'm not
// repeating the code
if ((tp == ZIP_COMPRESSION) || (tp == RLE_COMPRESSION))
{
// reorder the pixel data ~ straight from ImfZipCompressor.cpp :)
while (true)
{
if (inPtr < inSize)
tmp[t1++] = inBytes[inPtr++];
else
break;
if (inPtr < inSize)
tmp[t2++] = inBytes[inPtr++];
else
break;
}
// Predictor ~ straight from ImfZipCompressor.cpp :)
t1 = 1;
int p = tmp[t1 - 1];
while (t1 < inSize)
{
int d = (int)tmp[t1] - p + (128 + 256);
p = (int)tmp[t1];
tmp[t1] = (byte)d;
t1++;
}
}
// We'll just jump from here to the wanted compress/decompress stuff if
// need be
switch (tp)
{
case ZIP_COMPRESSION:
Deflater def = new Deflater(Deflater.DEFAULT_COMPRESSION, false);
def.setInput(tmp, 0, inSize);
def.finish();
ret = def.deflate(outBytes);
return ret;
case RLE_COMPRESSION:
return rleCompress(tmp, inSize, outBytes);
default:
return -1;
}
}
/// <summary>
/// Full constructor that allows you to set the wrapped stream and the level of compression
/// </summary>
/// <param name="baseStream">The stream to wrap up with the deflate algorithm</param>
/// <param name="compressionLevel">The level of compression to use</param>
public DeflateFilter(Stream baseStream, CompressionLevels compressionLevel) : base(baseStream, compressionLevel)
{
_deflater = GetDeflater();
m_stream = new DeflaterOutputStream(baseStream, _deflater);
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// The output stream where deflated output is written.
/// </param>
/// <param name="deflater">
/// The underlying deflater to use
/// </param>
/// <param name="bufsize">
/// The buffer size to use when deflating
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// bufsize is less than or equal to zero.
/// </exception>
/// <exception cref="ArgumentException">
/// baseOutputStream does not support writing
/// </exception>
/// <exception cref="ArgumentNullException">
/// deflater instance is null
/// </exception>
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufsize)
{
if (baseOutputStream.CanWrite == false) {
throw new ArgumentException("baseOutputStream", "must support writing");
}
if (deflater == null) {
throw new ArgumentNullException("deflater");
}
if (bufsize <= 0) {
throw new ArgumentOutOfRangeException("bufsize");
}
this.baseOutputStream = baseOutputStream;
buf = new byte[bufsize];
def = deflater;
}
public static String Compress(string str)
{
byte[] bytesToCompress = ASCIIEncoding.UTF8.GetBytes(str);
// Compressor with highest level of compression.
Deflater compressor = new Deflater(Deflater.BEST_COMPRESSION);
compressor.SetInput(bytesToCompress); // Give the compressor the data to
// compress.
compressor.Finish();
// Create an expandable byte array to hold the compressed data.
// It is not necessary that the compressed data will be smaller than
// the uncompressed data.
byte[] ret = null;
using (MemoryStream memStream = new MemoryStream(bytesToCompress.Length))
{
// Compress the data
byte[] buf = new byte[bytesToCompress.Length + 100];
while (!compressor.IsFinished)
{
memStream.Write(buf, 0, compressor.Deflate(buf));
}
memStream.Close();
ret = memStream.ToArray();
}
// Get the compressed data
return Convert.ToBase64String(ret);
}
/// <summary>
/// Creates a new DeflaterOutputStream with the given Deflater and
/// default buffer size.
/// </summary>
/// <param name="baseOutputStream">
/// the output stream where deflated output should be written.
/// </param>
/// <param name="defl">
/// the underlying deflater.
/// </param>
public InteractiveDeflaterOutputStream(Stream baseOutputStream, Deflater defl)
: this(baseOutputStream, defl, 512)
{
}
private static byte[] Zip(byte[] buffer, int version, byte[] key, byte[] iv)
{
byte[] buffer12;
try
{
ZipStream stream = new ZipStream();
if (version == 0)
{
Deflater deflater = new Deflater();
DateTime now = DateTime.Now;
long num = (long) ((ulong) ((((((((now.Year - 0x7bc) & 0x7f) << 0x19) | (now.Month << 0x15)) | (now.Day << 0x10)) | (now.Hour << 11)) | (now.Minute << 5)) | (now.Second >> 1)));
uint[] numArray = new uint[] {
0, 0x77073096, 0xee0e612c, 0x990951ba, 0x76dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0xedb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x9b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x1db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x6b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0xf00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x86d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x3b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x4db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0xd6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0xa00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x26d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x5005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0xcb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0xbdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint maxValue = uint.MaxValue;
uint num3 = maxValue;
int num4 = 0;
int length = buffer.Length;
while (--length >= 0)
{
num3 = numArray[(int) ((IntPtr) ((num3 ^ buffer[num4++]) & 0xff))] ^ (num3 >> 8);
}
num3 ^= maxValue;
stream.WriteInt(0x4034b50);
stream.WriteShort(20);
stream.WriteShort(0);
stream.WriteShort(8);
stream.WriteInt((int) num);
stream.WriteInt((int) num3);
long position = stream.Position;
stream.WriteInt(0);
stream.WriteInt(buffer.Length);
byte[] bytes = Encoding.UTF8.GetBytes("{data}");
stream.WriteShort(bytes.Length);
stream.WriteShort(0);
stream.Write(bytes, 0, bytes.Length);
deflater.SetInput(buffer);
while (!deflater.IsNeedingInput)
{
byte[] output = new byte[0x200];
int count = deflater.Deflate(output);
if (count <= 0)
{
break;
}
stream.Write(output, 0, count);
}
deflater.Finish();
while (!deflater.IsFinished)
{
byte[] buffer4 = new byte[0x200];
int num8 = deflater.Deflate(buffer4);
if (num8 <= 0)
{
break;
}
stream.Write(buffer4, 0, num8);
}
long totalOut = deflater.TotalOut;
stream.WriteInt(0x2014b50);
stream.WriteShort(20);
stream.WriteShort(20);
stream.WriteShort(0);
stream.WriteShort(8);
stream.WriteInt((int) num);
stream.WriteInt((int) num3);
stream.WriteInt((int) totalOut);
stream.WriteInt(buffer.Length);
stream.WriteShort(bytes.Length);
stream.WriteShort(0);
stream.WriteShort(0);
stream.WriteShort(0);
stream.WriteShort(0);
stream.WriteInt(0);
stream.WriteInt(0);
stream.Write(bytes, 0, bytes.Length);
stream.WriteInt(0x6054b50);
stream.WriteShort(0);
stream.WriteShort(0);
stream.WriteShort(1);
stream.WriteShort(1);
stream.WriteInt(0x2e + bytes.Length);
stream.WriteInt((30 + bytes.Length) + ((int) totalOut));
stream.WriteShort(0);
stream.Seek(position, SeekOrigin.Begin);
stream.WriteInt((int) totalOut);
}
else if (version == 1)
{
byte[] buffer5;
stream.WriteInt(0x17d7a7b);
stream.WriteInt(buffer.Length);
for (int i = 0; i < buffer.Length; i += buffer5.Length)
{
buffer5 = new byte[Math.Min(0x1fffff, buffer.Length - i)];
Buffer.BlockCopy(buffer, i, buffer5, 0, buffer5.Length);
long num11 = stream.Position;
stream.WriteInt(0);
stream.WriteInt(buffer5.Length);
Deflater deflater2 = new Deflater();
deflater2.SetInput(buffer5);
while (!deflater2.IsNeedingInput)
{
byte[] buffer6 = new byte[0x200];
int num12 = deflater2.Deflate(buffer6);
if (num12 <= 0)
{
break;
}
stream.Write(buffer6, 0, num12);
}
deflater2.Finish();
while (!deflater2.IsFinished)
{
byte[] buffer7 = new byte[0x200];
int num13 = deflater2.Deflate(buffer7);
if (num13 <= 0)
{
break;
}
stream.Write(buffer7, 0, num13);
}
long num14 = stream.Position;
stream.Position = num11;
stream.WriteInt((int) deflater2.TotalOut);
stream.Position = num14;
}
}
else
{
if (version == 2)
{
stream.WriteInt(0x27d7a7b);
byte[] inputBuffer = Zip(buffer, 1, null, null);
using (ICryptoTransform transform = GetDesTransform(key, iv, false))
{
byte[] buffer9 = transform.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length);
stream.Write(buffer9, 0, buffer9.Length);
goto Label_044F;
}
}
if (version == 3)
{
stream.WriteInt(0x37d7a7b);
byte[] buffer10 = Zip(buffer, 1, null, null);
using (ICryptoTransform transform2 = GetAesTransform(key, iv, false))
{
byte[] buffer11 = transform2.TransformFinalBlock(buffer10, 0, buffer10.Length);
stream.Write(buffer11, 0, buffer11.Length);
}
}
}
Label_044F:
stream.Flush();
stream.Close();
buffer12 = stream.ToArray();
}
catch (Exception exception)
{
ExceptionMessage = "ERR 2003: " + exception.Message;
throw;
}
return buffer12;
}
public static byte[] CompressChunkData(byte[] chunkData, int chunkDataRealLength, out int length)
{
byte[] comp = new byte[chunkDataRealLength];
#if PROFILE_MAPCHUNK
DateTime start = DateTime.Now;
#endif
// The ZlibStream gives up to 3ms faster with approx. 10bytes larger, but currently has a bug
// need to reproduce and post on codeplex DotNetZip site.
//comp = ZlibStream.CompressBuffer(data);
//len = comp.Length;
//try
//{
// byte[] testout = ZlibStream.UncompressBuffer(comp);
//}
//catch (Exception)
//{
// // TODO: add some code to generate test case for DotNetZip issue
// throw;
//}
// Compression level 5 gives 0.3ms faster than the Java version, and exact same size
// Using the static instance gives another 0.3ms
Deflater deflater;
DeflaterPool.TryPop(out deflater);
if(deflater == null)
deflater = new Deflater(5);
deflater.SetInput(chunkData, 0, chunkDataRealLength);
deflater.Finish();
length = deflater.Deflate(comp);
deflater.Reset();
DeflaterPool.Push(deflater);
return comp;
}
// Note: The .NET Framework SDK 2.0 version of this class does
// not have BeginWrite and EndWrite for some inexplicable reason.
// Close this stream.
public override void Close()
{
if(stream != null)
{
if(deflater != null)
{
int temp;
deflater.Finish();
while(!deflater.IsFinished)
{
temp = deflater.Deflate(buf, 0, buf.Length);
if(temp <= 0)
{
if(!deflater.IsFinished)
{
throw new IOException
(S._("IO_Compress_Input"));
}
break;
}
stream.Write(buf, 0, temp);
}
byte[] footer = new byte [8];
temp = (int)(crc32.Value);
footer[0] = (byte)temp;
footer[1] = (byte)(temp << 8);
footer[2] = (byte)(temp << 16);
footer[3] = (byte)(temp << 24);
temp = deflater.TotalIn;
footer[4] = (byte)temp;
footer[5] = (byte)(temp << 8);
footer[6] = (byte)(temp << 16);
footer[7] = (byte)(temp << 24);
stream.Write(footer, 0, 8);
}
if(!leaveOpen)
{
stream.Close();
}
stream = null;
inflater = null;
deflater = null;
buf = null;
}
}
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater)
: this(baseOutputStream, deflater, 512)
{
}
// Close this stream.
public override void Close()
{
if(stream != null)
{
if(deflater != null)
{
int temp;
deflater.Finish();
while(!deflater.IsFinished)
{
temp = deflater.Deflate(buf, 0, buf.Length);
if(temp <= 0)
{
if(!deflater.IsFinished)
{
throw new IOException
(S._("IO_Compress_Input"));
}
break;
}
stream.Write(buf, 0, temp);
}
}
if(!leaveOpen)
{
stream.Close();
}
stream = null;
inflater = null;
deflater = null;
buf = null;
}
}
public override void Write(BigEndianStream stream)
{
stream.Write(X);
stream.Write(Y);
stream.Write(Z);
stream.Write(SizeX);
stream.Write(SizeY);
stream.Write(SizeZ);
int o = 16 * 16 * 128;
byte[] data = new byte[o * 5 / 2];
int i = 0;
for (int x = 0; x < 16; x++)
{
for (int z = 0; z < 16; z++)
{
for (int y = 0; y < 128; y++)
{
int s = ((i + 1) & 1) * 4;
int ofst = i;
data[ofst] = Chunk[x, y, z];
ofst = i / 2 + o * 2 / 2;
data[ofst] = unchecked((byte)(data[ofst] | (Chunk.GetData(x, y, z) << s)));
ofst = i / 2 + o * 3 / 2;
data[ofst] = unchecked((byte)(data[ofst] | (Chunk.GetBlockLight(x, y, z) << s)));
ofst = i / 2 + o * 4 / 2;
data[ofst] = unchecked((byte)(data[ofst] | (Chunk.GetSkyLight(x, y, z) << s)));
i++;
}
}
}
byte[] comp = new byte[o * 5];
int len;
Deflater deflater = new Deflater(0);
try
{
deflater.setInput(data);
deflater.finish();
len = deflater.deflate(comp);
}
finally
{
deflater.end();
}
stream.Write(len);
stream.Write(comp, 0, len);
}
static int Deflate(Deflater def, byte [] src, byte [] dest)
{
bool count;
int offset, length, remain;
if (dest == null) {
dest = new byte [BlockSize];
count = true;
} else
count = false;
def.Reset ();
def.SetInput (src);
offset = 0;
while (!def.IsFinished) {
if (def.IsNeedingInput)
def.Finish ();
remain = Math.Min (dest.Length - offset, BlockSize);
if (remain == 0)
break;
length = def.Deflate (dest, offset, remain);
if (!count)
offset += length;
}
return def.TotalOut;
}
public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
{
if(stream == null)
{
throw new ArgumentNullException("stream");
}
if(mode == CompressionMode.Decompress)
{
if(!stream.CanRead)
{
throw new ArgumentException
(S._("IO_NotReadable"), "stream");
}
}
else if(mode == CompressionMode.Compress)
{
if(!stream.CanWrite)
{
throw new ArgumentException
(S._("IO_NotWritable"), "stream");
}
}
else
{
throw new ArgumentException
(S._("IO_CompressionMode"), "mode");
}
this.stream = stream;
this.mode = mode;
this.leaveOpen = leaveOpen;
this.buf = new byte [4096];
this.crc32 = new Crc32();
this.endOfStream = false;
this.headerDone = false;
if(mode == CompressionMode.Decompress)
{
inflater = new Inflater(true);
}
else
{
deflater = new Deflater(-1, true);
}
}
