public static byte[] Compress(byte[] file)
{
int splitSize = 0x10000;
int partitionCount = ((file.Length - 1) / 0x10000) + 1;
var partitionList = new List <byte[]>();
using (var reader = new BinaryReader(new MemoryStream(file)))
{
for (int i = 0; i < partitionCount; i++)
{
var encoding = new ZlibCodec();
encoding.InitializeDeflate(Ionic.Zlib.CompressionLevel.BestCompression); // RFC1950/1951/1952 encoding needed
byte[] buffer = ZlibStream.CompressBuffer(reader.ReadBytes(splitSize));
encoding.EndDeflate();
partitionList.Add(buffer);
}
}
using (var ms = new MemoryStream())
using (var br = new BinaryWriter(ms))
{
// Header
br.Write(splitSize);
br.Write(partitionCount);
br.Write(file.Length); // Uncompressed file length
for (int i = 0; i < partitionList.Count; i++)
{
br.Write(partitionList[i].Length + 4); // Entry size (partition size member + partition)
}
long currentOffset = br.BaseStream.Position;
// Entries
for (int i = 0; i < partitionList.Count; i++)
{
br.BaseStream.Position = currentOffset + 0x7F & ~0x7F; // Aligning
br.Write(partitionList[i].Length);
br.BaseStream.Write(partitionList[i], 0x0, partitionList[i].Length);
currentOffset = br.BaseStream.Position;
}
//Align Final data to 128
while (br.BaseStream.Position % 128 != 0)
{
br.Write((byte)0);
}
return(ms.ToArray());
}
}
private byte[] ZlibCodecCompress(string textToCompress)
{
int outputSize = 2048;
byte[] output = new Byte[outputSize];
byte[] uncompressed = UTF8Encoding.UTF8.GetBytes(textToCompress);
int lengthToCompress = uncompressed.Length;
// If you want a ZLIB stream, set this to true. If you want
// a bare DEFLATE stream, set this to false.
bool wantRfc1950Header = false;
using (MemoryStream ms = new MemoryStream())
{
ZlibCodec compressor = new ZlibCodec();
compressor.InitializeDeflate(CompressionLevel.BestCompression, wantRfc1950Header);
compressor.InputBuffer = uncompressed;
compressor.AvailableBytesIn = lengthToCompress;
compressor.NextIn = 0;
compressor.OutputBuffer = output;
foreach (var f in new FlushType[] { FlushType.None, FlushType.Finish })
{
int bytesToWrite = 0;
do
{
compressor.AvailableBytesOut = outputSize;
compressor.NextOut = 0;
compressor.Deflate(f);
bytesToWrite = outputSize - compressor.AvailableBytesOut;
if (bytesToWrite > 0)
{
ms.Write(output, 0, bytesToWrite);
}
}while ((f == FlushType.None && (compressor.AvailableBytesIn != 0 || compressor.AvailableBytesOut == 0)) ||
(f == FlushType.Finish && bytesToWrite != 0));
}
compressor.EndDeflate();
ms.Flush();
return(ms.ToArray());
}
}
private static byte[] ZlibCodecCompress(byte[] data)
{
int buffer_size = 0x800;
byte[] buffer = new byte[buffer_size];
int length = data.Length;
bool flag = false;
using (MemoryStream stream = new MemoryStream())
{
ZlibCodec codec = new ZlibCodec();
codec.InitializeDeflate(CompressionLevel.Default, flag);
codec.WindowBits = -15;
codec.Strategy = CompressionStrategy.Default;
codec.InputBuffer = data;
codec.AvailableBytesIn = length;
codec.NextIn = 0;
codec.OutputBuffer = buffer;
FlushType[] typeArray1 = new FlushType[2];
typeArray1[1] = FlushType.Finish;
foreach (FlushType type in typeArray1)
{
int count = 0;
do
{
codec.AvailableBytesOut = buffer_size;
codec.NextOut = 0;
codec.Deflate(type);
count = buffer_size - codec.AvailableBytesOut;
if (count > 0)
{
stream.Write(buffer, 0, count);
}
} while (((type == FlushType.None) &&
((codec.AvailableBytesIn != 0) || (codec.AvailableBytesOut == 0))) ||
((type == FlushType.Finish) && (count != 0)));
}
codec.EndDeflate();
stream.Flush();
return(stream.ToArray());
}
}
public static byte[] Deflate(byte[] input)
{
int outputSize = 8192;
byte[] output = new Byte[outputSize];
int lengthToCompress = input.Length;
using (MemoryStream ms = new MemoryStream())
{
ZlibCodec compressor = new ZlibCodec();
compressor.InitializeDeflate(Ionic.Zlib.CompressionLevel.BestCompression, true);
compressor.InputBuffer = input;
compressor.AvailableBytesIn = lengthToCompress;
compressor.NextIn = 0;
compressor.OutputBuffer = output;
foreach (var f in new FlushType[] { FlushType.None, FlushType.Finish })
{
int bytesToWrite = 0;
do
{
compressor.AvailableBytesOut = outputSize;
compressor.NextOut = 0;
compressor.Deflate(f);
bytesToWrite = outputSize - compressor.AvailableBytesOut;
if (bytesToWrite > 0)
{
ms.Write(output, 0, bytesToWrite);
}
}while (bytesToWrite != 0);
}
compressor.EndDeflate();
ms.Flush();
return(ms.ToArray());
}
}
public static byte[] Deflate(byte[] decompressed)
{
int rc;
ZlibCodec compressor = new ZlibCodec();
byte[] compressed = new byte[decompressed.Length * 2 + 16];
rc = compressor.InitializeDeflate(Zlib.CompressionLevel.BestCompression);
if (rc != ZlibConstants.Z_OK)
{
throw new Exception("inflating: " + compressor.Message);
}
compressor.InputBuffer = decompressed;
compressor.NextIn = 0;
compressor.AvailableBytesIn = decompressed.Length;
compressor.OutputBuffer = compressed;
compressor.NextOut = 0;
compressor.AvailableBytesOut = compressed.Length;
while (compressor.TotalBytesIn != decompressed.Length && compressor.TotalBytesOut < compressed.Length)
{
compressor.Deflate(FlushType.None);
}
do
{
rc = compressor.Deflate(FlushType.Finish);
} while (rc != ZlibConstants.Z_STREAM_END);
long compressedLen = compressor.TotalBytesOut;
compressor.EndDeflate();
byte[] result = new byte[compressedLen];
Array.Copy(compressed, result, compressedLen);
return(result);
}
public byte[] Compress(byte[] data)
{
var buffer = new byte[4096];
var zc = new ZlibCodec(CompressionMode.Compress);
zc.InitializeDeflate(CompressionLevel.Default, 15, true);
zc.InputBuffer = data;
zc.NextIn = 0;
zc.AvailableBytesIn = data.Length;
zc.OutputBuffer = buffer;
using (var ms = new MemoryStream())
{
do
{
zc.NextOut = 0;
zc.AvailableBytesOut = buffer.Length;
zc.Deflate(FlushType.None);
ms.Write(zc.OutputBuffer, 0, buffer.Length - zc.AvailableBytesOut);
}while (zc.AvailableBytesIn > 0 || zc.AvailableBytesOut == 0);
do
{
zc.NextOut = 0;
zc.AvailableBytesOut = buffer.Length;
zc.Deflate(FlushType.Finish);
if (buffer.Length - zc.AvailableBytesOut > 0)
{
ms.Write(buffer, 0, buffer.Length - zc.AvailableBytesOut);
}
}while (zc.AvailableBytesIn > 0 || zc.AvailableBytesOut == 0);
zc.EndDeflate();
return(ms.ToArray());
}
}
private void _FlushFinish()
{
// After writing a series of compressed buffers, each one closed
// with Flush.Sync, we now write the final one as Flush.Finish,
// and then stop.
byte[] buffer = new byte[128];
var compressor = new ZlibCodec();
int rc = compressor.InitializeDeflate(_compressLevel, false);
compressor.InputBuffer = null;
compressor.NextIn = 0;
compressor.AvailableBytesIn = 0;
compressor.OutputBuffer = buffer;
compressor.NextOut = 0;
compressor.AvailableBytesOut = buffer.Length;
rc = compressor.Deflate(FlushType.Finish);
if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
{
throw new Exception("deflating: " + compressor.Message);
}
if (buffer.Length - compressor.AvailableBytesOut > 0)
{
TraceOutput(TraceBits.EmitBegin,
"Emit begin flush bytes({0})",
buffer.Length - compressor.AvailableBytesOut);
_outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
TraceOutput(TraceBits.EmitDone,
"Emit done flush");
}
compressor.EndDeflate();
_Crc32 = _runningCrc.Crc32Result;
}
private async ValueTask RunZlibCompress()
{
var zlibCodec = new ZlibCodec();
var buffer = new byte[1024];
zlibCodec.OutputBuffer = buffer;
var result = zlibCodec.InitializeDeflate();
if (result < 0)
{
throw new InvalidOperationException(
$"Got error code {result} when initializing deflate routine: {zlibCodec.Message}");
}
result = zlibCodec.SetDictionary(_dictionary);
if (result < 0)
{
throw new InvalidOperationException(
$"Got error code {result} when setting dictionary: {zlibCodec.Message}");
}
Exception?exception = null;
try
{
System.IO.Pipelines.ReadResult inputBuffer;
do
{
inputBuffer = await _pipe
.Reader.ReadAsync(CancellationToken)
.ConfigureAwait(false);
foreach (var input in inputBuffer.Buffer)
{
zlibCodec.NextIn = 0;
zlibCodec.InputBuffer = input.ToArray();
zlibCodec.AvailableBytesIn = input.Length;
while (zlibCodec.AvailableBytesIn > 0)
{
zlibCodec.NextOut = 0;
zlibCodec.AvailableBytesOut = buffer.Length;
var start = zlibCodec.NextOut;
result = zlibCodec.Deflate(FlushType.None);
if (result < 0)
{
throw new InvalidOperationException(
$"Got error code {result} when deflating the stream: {zlibCodec.Message}");
}
var length = zlibCodec.NextOut - start;
await _outputStream.WriteAsync(
buffer, start, length,
CancellationToken)
.ConfigureAwait(false);
}
}
_pipe.Reader.AdvanceTo(inputBuffer.Buffer.End);
} while (inputBuffer.HasMoreData());
zlibCodec.InputBuffer = Array.Empty <byte>();
zlibCodec.NextIn = 0;
zlibCodec.AvailableBytesIn = 0;
zlibCodec.NextOut = 0;
zlibCodec.AvailableBytesOut = buffer.Length;
var bufferStart = zlibCodec.NextOut;
result = zlibCodec.Deflate(FlushType.Sync);
if (result != ZlibConstants.Z_OK)
{
throw new InvalidOperationException($"Expected OK, got {result}");
}
result = zlibCodec.Deflate(FlushType.Finish);
if (result != ZlibConstants.Z_STREAM_END)
{
throw new InvalidOperationException($"Expected END, got {result}");
}
var bufferLength = zlibCodec.NextOut - bufferStart;
await _outputStream.WriteAsync(
buffer, bufferStart, bufferLength,
CancellationToken)
.ConfigureAwait(false);
await _outputStream.FlushAsync(CancellationToken)
.ConfigureAwait(false);
}
catch (Exception ex)
{
exception = ex;
}
finally
{
zlibCodec.EndDeflate();
await _pipe.Reader.CompleteAsync(exception)
.ConfigureAwait(false);
}
}
public void WriteSkimToFile(double[][] skim, string filename, int[] mapping, int count, int transport, int startTime,
int endTime, int factor)
{
var file = new FileInfo(filename);
using (var writer = new BinaryWriter(file.Open(FileMode.Create, FileAccess.Write, FileShare.ReadWrite)))
{
//var position = 0L;
double colSum = GetColumnSums(skim);
double diagonalSum = GetDiagonalSum(skim);
string header = "\nMuuli-Matrix im gepackten Binary format.\nBezirke: " +
count + " \nVarTyp: 5 \nGesamtsumme: " +
colSum + " \nDiagonalsumme: " +
diagonalSum + " \nVMittel: " + transport +
" \nvon: " + startTime + " \nbis: " +
endTime + " \nFaktor: " + factor + " \n";
short headerlength = (short)header.Length;
int dataType = 5;
int roundProc = 1;
//write header info
writer.Write((short)3);
writer.Write("$BI".ToCharArray());
writer.Write((short)headerlength);
writer.Write(header.ToCharArray());
//write additional header info
writer.Write((Int32)transport);
writer.Write((float)startTime);
writer.Write((float)endTime);
writer.Write((float)factor);
writer.Write((Int32)count);
writer.Write((short)dataType);
writer.Write(roundProc == 1 ? '\x01' : '\x00');
for (int x = 0; x < count; x++)
{
writer.Write((Int32)mapping[x]);
}
for (int x = 0; x < count; x++)
{
writer.Write((Int32)mapping[x]);
}
writer.Write('\x00');
writer.Write(diagonalSum);
for (int i = 0; i < count; i++)
{
MemoryStream toCompressFileStream = new MemoryStream();
BinaryWriter compressedWriter = new BinaryWriter(toCompressFileStream);
for (int j = 0; j < count; j++)
{
compressedWriter.Write(skim[i][j]);
}
compressedWriter.Flush();
int outputSize = sizeof(double) * count;
byte[] output = new Byte[outputSize];
using (MemoryStream ms = new MemoryStream())
{
ZlibCodec compressor = new ZlibCodec();
compressor.InitializeDeflate(Ionic.Zlib.CompressionLevel.None, true);
compressor.InputBuffer = toCompressFileStream.ToArray();
compressor.AvailableBytesIn = (int)toCompressFileStream.Length;
compressor.NextIn = 0;
compressor.OutputBuffer = output;
foreach (var f in new FlushType[] { FlushType.None, FlushType.Finish })
{
int bytesToWrite = 0;
do
{
compressor.AvailableBytesOut = outputSize;
compressor.NextOut = 0;
compressor.Deflate(f);
bytesToWrite = outputSize - compressor.AvailableBytesOut;
if (bytesToWrite > 0)
{
ms.Write(output, 0, bytesToWrite);
}
} while ((f == FlushType.None && (compressor.AvailableBytesIn != 0 || compressor.AvailableBytesOut == 0)) ||
(f == FlushType.Finish && bytesToWrite != 0));
}
compressor.EndDeflate();
ms.Flush();
writer.Write((Int32)ms.Length);
writer.Write(ms.ToArray());
writer.Write(GetRowSum(skim, i));
writer.Write(GetColumnSum(skim, i));
}
}
}
}
private void Run()
{
int rc;
int bufferSize = 40000;
byte[] compressedBytes = new byte[bufferSize];
byte[] decompressedBytes = new byte[bufferSize];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.LEVEL9_BEST_COMPRESSION);
CheckForError(compressingStream, rc, "InitializeDeflate");
string dictionaryWord = "hello ";
byte[] dictionary = System.Text.ASCIIEncoding.ASCII.GetBytes(dictionaryWord);
string TextToCompress = "hello, hello! How are you, Joe? ";
byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
rc = compressingStream.SetDictionary(dictionary);
CheckForError(compressingStream, rc, "SetDeflateDictionary");
long dictId = compressingStream.Adler32;
compressingStream.OutputBuffer = compressedBytes;
compressingStream.NextOut = 0;
compressingStream.AvailableBytesOut = bufferSize;
compressingStream.InputBuffer = BytesToCompress;
compressingStream.NextIn = 0;
compressingStream.AvailableBytesIn = BytesToCompress.Length;
rc = compressingStream.Deflate(ZlibConstants.Z_FINISH);
if (rc != ZlibConstants.Z_STREAM_END)
{
System.Console.Out.WriteLine("deflate should report Z_STREAM_END");
System.Environment.Exit(1);
}
rc = compressingStream.EndDeflate();
CheckForError(compressingStream, rc, "deflateEnd");
ZlibCodec decompressingStream = new ZlibCodec();
decompressingStream.InputBuffer = compressedBytes;
decompressingStream.NextIn = 0;
decompressingStream.AvailableBytesIn = bufferSize;
rc = decompressingStream.InitializeInflate();
CheckForError(decompressingStream, rc, "inflateInit");
decompressingStream.OutputBuffer = decompressedBytes;
decompressingStream.NextOut = 0;
decompressingStream.AvailableBytesOut = decompressedBytes.Length;
while (true)
{
rc = decompressingStream.Inflate(ZlibConstants.Z_NO_FLUSH);
if (rc == ZlibConstants.Z_STREAM_END)
{
break;
}
if (rc == ZlibConstants.Z_NEED_DICT)
{
if ((int)decompressingStream.Adler32 != (int)dictId)
{
System.Console.Out.WriteLine("unexpected dictionary");
System.Environment.Exit(1);
}
rc = decompressingStream.SetDictionary(dictionary);
}
CheckForError(decompressingStream, rc, "inflate with dict");
}
rc = decompressingStream.EndInflate();
CheckForError(decompressingStream, rc, "EndInflate");
int j = 0;
for (; j < decompressedBytes.Length; j++)
{
if (decompressedBytes[j] == 0)
{
break;
}
}
var result = System.Text.ASCIIEncoding.ASCII.GetString(decompressedBytes, 0, j);
Console.WriteLine("orig length: {0}", TextToCompress.Length);
Console.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
Console.WriteLine("decompressed length: {0}", decompressingStream.TotalBytesOut);
Console.WriteLine("result length: {0}", result.Length);
Console.WriteLine("result of inflate:\n{0}", result);
}
private void Run()
{
int rc;
int comprLen = 40000;
int uncomprLen = comprLen;
byte[] CompressedBytes = new byte[comprLen];
byte[] DecompressedBytes = new byte[uncomprLen];
string TextToCompress = "This is the text that will be compressed.";
byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
ZlibCodec compressor = new ZlibCodec(CompressionMode.Compress);
compressor.InputBuffer = BytesToCompress;
compressor.NextIn = 0;
compressor.OutputBuffer = CompressedBytes;
compressor.NextOut = 0;
compressor.AvailableBytesIn = 3;
compressor.AvailableBytesOut = CompressedBytes.Length;
rc = compressor.Deflate(ZlibConstants.Z_FULL_FLUSH);
CheckForError(compressor, rc, "Deflate");
CompressedBytes[3]++; // force an error in first compressed block // dinoch
compressor.AvailableBytesIn = TextToCompress.Length - 3;
rc = compressor.Deflate(ZlibConstants.Z_FINISH);
if (rc != ZlibConstants.Z_STREAM_END)
{
CheckForError(compressor, rc, "Deflate");
}
rc = compressor.EndDeflate();
CheckForError(compressor, rc, "EndDeflate");
comprLen = (int)(compressor.TotalBytesOut);
ZlibCodec decompressor = new ZlibCodec(CompressionMode.Decompress);
decompressor.InputBuffer = CompressedBytes;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = 2;
decompressor.OutputBuffer = DecompressedBytes;
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = DecompressedBytes.Length;
rc = decompressor.Inflate(ZlibConstants.Z_NO_FLUSH);
CheckForError(decompressor, rc, "Inflate");
decompressor.AvailableBytesIn = CompressedBytes.Length - 2;
rc = decompressor.SyncInflate();
CheckForError(decompressor, rc, "SyncInflate");
bool gotException = false;
try
{
rc = decompressor.Inflate(ZlibConstants.Z_FINISH);
}
catch (ZlibException ex1)
{
Console.WriteLine("Got Expected Exception: " + ex1);
gotException = true;
}
if (!gotException)
{
System.Console.Out.WriteLine("inflate should report DATA_ERROR");
/* Because of incorrect adler32 */
System.Environment.Exit(1);
}
rc = decompressor.EndInflate();
CheckForError(decompressor, rc, "EndInflate");
int j = 0;
for (; j < DecompressedBytes.Length; j++)
{
if (DecompressedBytes[j] == 0)
{
break;
}
}
var result = System.Text.ASCIIEncoding.ASCII.GetString(DecompressedBytes, 0, j);
Console.WriteLine("orig length: {0}", TextToCompress.Length);
Console.WriteLine("compressed length: {0}", compressor.TotalBytesOut);
Console.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut);
Console.WriteLine("result length: {0}", result.Length);
Console.WriteLine("result of inflate:\n(Thi){0}", result);
}
private void Run()
{
int rc;
int j;
int bufferSize = 40000;
byte[] compressedBytes = new byte[bufferSize];
byte[] bufferToCompress = new byte[bufferSize];
byte[] decompressedBytes = new byte[bufferSize];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.BestSpeed);
CheckForError(compressingStream, rc, "InitializeDeflate");
compressingStream.OutputBuffer = compressedBytes;
compressingStream.NextOut = 0;
compressingStream.AvailableBytesOut = compressedBytes.Length;
// At this point, bufferToCompress is all zeroes, so it should compress
// very well:
compressingStream.InputBuffer = bufferToCompress;
compressingStream.AvailableBytesIn = bufferToCompress.Length;
rc = compressingStream.Deflate(FlushType.None);
CheckForError(compressingStream, rc, "deflate");
if (compressingStream.AvailableBytesIn != 0)
{
System.Console.Out.WriteLine("deflate not greedy");
System.Environment.Exit(1);
}
Console.WriteLine("Stage 1: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn);
Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut);
// Feed in already compressed data and switch to no compression:
compressingStream.SetDeflateParams(CompressionLevel.None, CompressionStrategy.Default);
compressingStream.InputBuffer = compressedBytes;
compressingStream.NextIn = 0;
compressingStream.AvailableBytesIn = bufferSize / 2; // why? - for fun
rc = compressingStream.Deflate(FlushType.None);
CheckForError(compressingStream, rc, "Deflate");
Console.WriteLine("Stage 2: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn);
Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut);
// Insert data into bufferToCompress, and Switch back to compressing mode:
System.Random rnd = new Random();
for (int i = 0; i < bufferToCompress.Length / 1000; i++)
{
byte b = (byte)rnd.Next();
int n = 500 + rnd.Next(500);
for (j = 0; j < n; j++)
{
bufferToCompress[j + i] = b;
}
i += j - 1;
}
compressingStream.SetDeflateParams(CompressionLevel.BestCompression, CompressionStrategy.Filtered);
compressingStream.InputBuffer = bufferToCompress;
compressingStream.NextIn = 0;
compressingStream.AvailableBytesIn = bufferToCompress.Length;
rc = compressingStream.Deflate(FlushType.None);
CheckForError(compressingStream, rc, "Deflate");
Console.WriteLine("Stage 3: uncompressed bytes in so far: {0,6}", compressingStream.TotalBytesIn);
Console.WriteLine(" compressed bytes out so far: {0,6}", compressingStream.TotalBytesOut);
rc = compressingStream.Deflate(FlushType.Finish);
if (rc != ZlibConstants.Z_STREAM_END)
{
Console.WriteLine("deflate reported {0}, should report Z_STREAM_END", rc);
Environment.Exit(1);
}
rc = compressingStream.EndDeflate();
CheckForError(compressingStream, rc, "EndDeflate");
Console.WriteLine("Stage 4: uncompressed bytes in (final): {0,6}", compressingStream.TotalBytesIn);
Console.WriteLine(" compressed bytes out (final): {0,6}", compressingStream.TotalBytesOut);
ZlibCodec decompressingStream = new ZlibCodec(CompressionMode.Decompress);
decompressingStream.InputBuffer = compressedBytes;
decompressingStream.NextIn = 0;
decompressingStream.AvailableBytesIn = bufferSize;
// upon inflating, we overwrite the decompressedBytes buffer repeatedly
while (true)
{
decompressingStream.OutputBuffer = decompressedBytes;
decompressingStream.NextOut = 0;
decompressingStream.AvailableBytesOut = decompressedBytes.Length;
rc = decompressingStream.Inflate(FlushType.None);
if (rc == ZlibConstants.Z_STREAM_END)
{
break;
}
CheckForError(decompressingStream, rc, "inflate large");
}
rc = decompressingStream.EndInflate();
CheckForError(decompressingStream, rc, "EndInflate");
if (decompressingStream.TotalBytesOut != 2 * decompressedBytes.Length + bufferSize / 2)
{
System.Console.WriteLine("bad large inflate: " + decompressingStream.TotalBytesOut);
System.Environment.Exit(1);
}
for (j = 0; j < decompressedBytes.Length; j++)
{
if (decompressedBytes[j] == 0)
{
break;
}
}
Console.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
Console.WriteLine("decompressed length (expected): {0}", 2 * decompressedBytes.Length + bufferSize / 2);
Console.WriteLine("decompressed length (actual) : {0}", decompressingStream.TotalBytesOut);
}
