public WorkItem(int size,
Alienlab.Zlib.CompressionLevel compressLevel,
CompressionStrategy strategy,
int ix)
{
this.buffer= new byte[size];
// alloc 5 bytes overhead for every block (margin of safety= 2)
int n = size + ((size / 32768)+1) * 5 * 2;
this.compressed = new byte[n];
this.compressor = new ZlibCodec();
this.compressor.InitializeDeflate(compressLevel, false);
this.compressor.OutputBuffer = this.compressed;
this.compressor.InputBuffer = this.buffer;
this.index = ix;
}
internal static int inflate_trees_fixed(int[] bl, int[] bd, int[][] tl, int[][] td, ZlibCodec z)
{
bl[0] = fixed_bl;
bd[0] = fixed_bd;
tl[0] = fixed_tl;
td[0] = fixed_td;
return Z_OK;
}
internal int inflate_trees_dynamic(int nl, int nd, int[] c, int[] bl, int[] bd, int[] tl, int[] td, int[] hp, ZlibCodec z)
{
int result;
// build literal/length tree
initWorkArea(288);
hn[0] = 0;
result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
if (result != Z_OK || bl[0] == 0)
{
if (result == Z_DATA_ERROR)
{
z.Message = "oversubscribed literal/length tree";
}
else if (result != Z_MEM_ERROR)
{
z.Message = "incomplete literal/length tree";
result = Z_DATA_ERROR;
}
return result;
}
// build distance tree
initWorkArea(288);
result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
if (result != Z_OK || (bd[0] == 0 && nl > 257))
{
if (result == Z_DATA_ERROR)
{
z.Message = "oversubscribed distance tree";
}
else if (result == Z_BUF_ERROR)
{
z.Message = "incomplete distance tree";
result = Z_DATA_ERROR;
}
else if (result != Z_MEM_ERROR)
{
z.Message = "empty distance tree with lengths";
result = Z_DATA_ERROR;
}
return result;
}
return Z_OK;
}
internal int inflate_trees_bits(int[] c, int[] bb, int[] tb, int[] hp, ZlibCodec z)
{
int result;
initWorkArea(19);
hn[0] = 0;
result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
if (result == Z_DATA_ERROR)
{
z.Message = "oversubscribed dynamic bit lengths tree";
}
else if (result == Z_BUF_ERROR || bb[0] == 0)
{
z.Message = "incomplete dynamic bit lengths tree";
result = Z_DATA_ERROR;
}
return result;
}
private byte[] DeflateBuffer(byte[] b, CompressionLevel level)
{
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
ZlibCodec compressor = new ZlibCodec();
TestContext.WriteLine("\n============================================");
TestContext.WriteLine("Size of Buffer to Deflate: {0} bytes.", b.Length);
MemoryStream ms = new MemoryStream();
int rc = compressor.InitializeDeflate(level);
compressor.InputBuffer = b;
compressor.NextIn = 0;
compressor.AvailableBytesIn = b.Length;
compressor.OutputBuffer = buffer;
for (int pass = 0; pass < 2; pass++)
{
FlushType flush = (pass==0)
? FlushType.None
: FlushType.Finish;
do
{
compressor.NextOut = 0;
compressor.AvailableBytesOut = buffer.Length;
rc = compressor.Deflate(flush);
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new Exception("deflating: " + compressor.Message);
if (buffer.Length - compressor.AvailableBytesOut > 0)
ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
}
while (compressor.AvailableBytesIn > 0 || compressor.AvailableBytesOut == 0);
}
compressor.EndDeflate();
Console.WriteLine("TBO({0}).", compressor.TotalBytesOut);
ms.Seek(0, SeekOrigin.Begin);
byte[] c = new byte[compressor.TotalBytesOut];
ms.Read(c, 0, c.Length);
return c;
}
private byte[] InflateBuffer(byte[] b, int length)
{
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
ZlibCodec decompressor = new ZlibCodec();
byte[] DecompressedBytes = new byte[length];
TestContext.WriteLine("\n============================================");
TestContext.WriteLine("Size of Buffer to Inflate: {0} bytes.", b.Length);
MemoryStream ms = new MemoryStream(DecompressedBytes);
int rc = decompressor.InitializeInflate();
decompressor.InputBuffer = b;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = b.Length;
decompressor.OutputBuffer = buffer;
for (int pass = 0; pass < 2; pass++)
{
FlushType flush = (pass==0)
? FlushType.None
: FlushType.Finish;
do
{
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = buffer.Length;
rc = decompressor.Inflate(flush);
if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
throw new Exception("inflating: " + decompressor.Message);
if (buffer.Length - decompressor.AvailableBytesOut > 0)
ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
}
while (decompressor.AvailableBytesIn > 0 || decompressor.AvailableBytesOut == 0);
}
decompressor.EndInflate();
TestContext.WriteLine("TBO({0}).", decompressor.TotalBytesOut);
return DecompressedBytes;
}
public void Zlib_Codec_TestLargeDeflateInflate()
{
int rc;
int j;
int bufferSize = 80000;
byte[] compressedBytes = new byte[bufferSize];
byte[] workBuffer = new byte[bufferSize / 4];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.Level1);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message));
compressingStream.OutputBuffer = compressedBytes;
compressingStream.AvailableBytesOut = compressedBytes.Length;
compressingStream.NextOut = 0;
System.Random rnd = new Random();
for (int k = 0; k < 4; k++)
{
switch (k)
{
case 0:
// At this point, workBuffer is all zeroes, so it should compress very well.
break;
case 1:
// switch to no compression, keep same workBuffer (all zeroes):
compressingStream.SetDeflateParams(CompressionLevel.None, CompressionStrategy.Default);
break;
case 2:
// Insert data into workBuffer, and switch back to compressing mode.
// we'll use lengths of the same random byte:
for (int i = 0; i < workBuffer.Length / 1000; i++)
{
byte b = (byte)rnd.Next();
int n = 500 + rnd.Next(500);
for (j = 0; j < n; j++)
workBuffer[j + i] = b;
i += j - 1;
}
compressingStream.SetDeflateParams(CompressionLevel.BestCompression, CompressionStrategy.Filtered);
break;
case 3:
// insert totally random data into the workBuffer
rnd.NextBytes(workBuffer);
break;
}
compressingStream.InputBuffer = workBuffer;
compressingStream.NextIn = 0;
compressingStream.AvailableBytesIn = workBuffer.Length;
rc = compressingStream.Deflate(FlushType.None);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate({0}) [{1}]", k, compressingStream.Message));
if (k == 0)
Assert.AreEqual<int>(0, compressingStream.AvailableBytesIn, "Deflate should be greedy.");
TestContext.WriteLine("Stage {0}: uncompressed/compresssed bytes so far: ({1,6}/{2,6})",
k, compressingStream.TotalBytesIn, compressingStream.TotalBytesOut);
}
rc = compressingStream.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressingStream.Message));
rc = compressingStream.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message));
TestContext.WriteLine("Final: uncompressed/compressed bytes: ({0,6},{1,6})",
compressingStream.TotalBytesIn, 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
int nCycles = 0;
while (true)
{
decompressingStream.OutputBuffer = workBuffer;
decompressingStream.NextOut = 0;
decompressingStream.AvailableBytesOut = workBuffer.Length;
rc = decompressingStream.Inflate(FlushType.None);
nCycles++;
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}] TotalBytesOut={1}",
decompressingStream.Message, decompressingStream.TotalBytesOut));
}
rc = decompressingStream.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message));
Assert.AreEqual<int>(4 * workBuffer.Length, (int)decompressingStream.TotalBytesOut);
TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
TestContext.WriteLine("decompressed length (expected): {0}", 4 * workBuffer.Length);
TestContext.WriteLine("decompressed length (actual) : {0}", decompressingStream.TotalBytesOut);
TestContext.WriteLine("decompression cycles: {0}", nCycles);
}
public void Zlib_TestFlushSync()
{
int rc;
int bufferSize = 40000;
byte[] CompressedBytes = new byte[bufferSize];
byte[] DecompressedBytes = new byte[bufferSize];
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.AvailableBytesIn = 3;
compressor.OutputBuffer = CompressedBytes;
compressor.NextOut = 0;
compressor.AvailableBytesOut = CompressedBytes.Length;
rc = compressor.Deflate(FlushType.Full);
CompressedBytes[3]++; // force an error in first compressed block // dinoch - ??
compressor.AvailableBytesIn = TextToCompress.Length - 3;
rc = compressor.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message));
rc = compressor.EndDeflate();
bufferSize = (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(FlushType.None);
decompressor.AvailableBytesIn = bufferSize - 2;
rc = decompressor.SyncInflate();
bool gotException = false;
try
{
rc = decompressor.Inflate(FlushType.Finish);
}
catch (ZlibException ex1)
{
TestContext.WriteLine("Got Expected Exception: " + ex1);
gotException = true;
}
Assert.IsTrue(gotException, "inflate should report DATA_ERROR");
rc = decompressor.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message));
int j = 0;
for (; j < DecompressedBytes.Length; j++)
if (DecompressedBytes[j] == 0)
break;
var result = System.Text.ASCIIEncoding.ASCII.GetString(DecompressedBytes, 0, j);
Assert.AreEqual<int>(TextToCompress.Length, result.Length + 3, "Strings are unequal lengths");
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);
}
public void Zlib_BasicDictionaryDeflateInflate()
{
int rc;
int comprLen = 40000;
int uncomprLen = comprLen;
byte[] uncompr = new byte[uncomprLen];
byte[] compr = new byte[comprLen];
//long dictId;
ZlibCodec compressor = new ZlibCodec();
rc = compressor.InitializeDeflate(CompressionLevel.BestCompression);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressor.Message));
string dictionaryWord = "hello ";
byte[] dictionary = System.Text.ASCIIEncoding.ASCII.GetBytes(dictionaryWord);
string TextToCompress = "hello, hello! How are you, Joe? I said hello. ";
byte[] BytesToCompress = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
rc = compressor.SetDictionary(dictionary);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at SetDeflateDictionary() [{0}]", compressor.Message));
int dictId = compressor.Adler32;
compressor.OutputBuffer = compr;
compressor.NextOut = 0;
compressor.AvailableBytesOut = comprLen;
compressor.InputBuffer = BytesToCompress;
compressor.NextIn = 0;
compressor.AvailableBytesIn = BytesToCompress.Length;
rc = compressor.Deflate(FlushType.Finish);
Assert.AreEqual<int>(ZlibConstants.Z_STREAM_END, rc, String.Format("at Deflate() [{0}]", compressor.Message));
rc = compressor.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressor.Message));
ZlibCodec decompressor = new ZlibCodec();
decompressor.InputBuffer = compr;
decompressor.NextIn = 0;
decompressor.AvailableBytesIn = comprLen;
rc = decompressor.InitializeInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressor.Message));
decompressor.OutputBuffer = uncompr;
decompressor.NextOut = 0;
decompressor.AvailableBytesOut = uncomprLen;
while (true)
{
rc = decompressor.Inflate(FlushType.None);
if (rc == ZlibConstants.Z_STREAM_END)
{
break;
}
if (rc == ZlibConstants.Z_NEED_DICT)
{
Assert.AreEqual<long>(dictId, decompressor.Adler32, "Unexpected Dictionary");
rc = decompressor.SetDictionary(dictionary);
}
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate/SetInflateDictionary() [{0}]", decompressor.Message));
}
rc = decompressor.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressor.Message));
int j = 0;
for (; j < uncompr.Length; j++)
if (uncompr[j] == 0)
break;
Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths"));
int i = 0;
for (i = 0; i < j; i++)
if (TextToCompress[i] != uncompr[i])
break;
Assert.AreEqual<int>(j, i, String.Format("Non-identical content"));
var result = System.Text.ASCIIEncoding.ASCII.GetString(uncompr, 0, j);
TestContext.WriteLine("orig length: {0}", TextToCompress.Length);
TestContext.WriteLine("compressed length: {0}", compressor.TotalBytesOut);
TestContext.WriteLine("uncompressed length: {0}", decompressor.TotalBytesOut);
TestContext.WriteLine("result length: {0}", result.Length);
TestContext.WriteLine("result of inflate:\n{0}", result);
}
public void Zlib_BasicDeflateAndInflate()
{
string TextToCompress = LoremIpsum;
int rc;
int bufferSize = 40000;
byte[] compressedBytes = new byte[bufferSize];
byte[] decompressedBytes = new byte[bufferSize];
ZlibCodec compressingStream = new ZlibCodec();
rc = compressingStream.InitializeDeflate(CompressionLevel.Default);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeDeflate() [{0}]", compressingStream.Message));
compressingStream.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
compressingStream.NextIn = 0;
compressingStream.OutputBuffer = compressedBytes;
compressingStream.NextOut = 0;
while (compressingStream.TotalBytesIn != TextToCompress.Length && compressingStream.TotalBytesOut < bufferSize)
{
compressingStream.AvailableBytesIn = compressingStream.AvailableBytesOut = 1; // force small buffers
rc = compressingStream.Deflate(FlushType.None);
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(1) [{0}]", compressingStream.Message));
}
while (true)
{
compressingStream.AvailableBytesOut = 1;
rc = compressingStream.Deflate(FlushType.Finish);
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Deflate(2) [{0}]", compressingStream.Message));
}
rc = compressingStream.EndDeflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndDeflate() [{0}]", compressingStream.Message));
ZlibCodec decompressingStream = new ZlibCodec();
decompressingStream.InputBuffer = compressedBytes;
decompressingStream.NextIn = 0;
decompressingStream.OutputBuffer = decompressedBytes;
decompressingStream.NextOut = 0;
rc = decompressingStream.InitializeInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at InitializeInflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflateInit");
while (decompressingStream.TotalBytesOut < decompressedBytes.Length && decompressingStream.TotalBytesIn < bufferSize)
{
decompressingStream.AvailableBytesIn = decompressingStream.AvailableBytesOut = 1; /* force small buffers */
rc = decompressingStream.Inflate(FlushType.None);
if (rc == ZlibConstants.Z_STREAM_END)
break;
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at Inflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflate");
}
rc = decompressingStream.EndInflate();
Assert.AreEqual<int>(ZlibConstants.Z_OK, rc, String.Format("at EndInflate() [{0}]", decompressingStream.Message));
//CheckForError(decompressingStream, rc, "inflateEnd");
int j = 0;
for (; j < decompressedBytes.Length; j++)
if (decompressedBytes[j] == 0)
break;
Assert.AreEqual<int>(TextToCompress.Length, j, String.Format("Unequal lengths"));
int i = 0;
for (i = 0; i < j; i++)
if (TextToCompress[i] != decompressedBytes[i])
break;
Assert.AreEqual<int>(j, i, String.Format("Non-identical content"));
var result = System.Text.ASCIIEncoding.ASCII.GetString(decompressedBytes, 0, j);
TestContext.WriteLine("orig length: {0}", TextToCompress.Length);
TestContext.WriteLine("compressed length: {0}", compressingStream.TotalBytesOut);
TestContext.WriteLine("decompressed length: {0}", decompressingStream.TotalBytesOut);
TestContext.WriteLine("result length: {0}", result.Length);
TestContext.WriteLine("result of inflate:\n{0}", result);
return;
}
internal int Initialize(ZlibCodec codec, CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
{
_codec = codec;
_codec.Message = null;
// validation
if (windowBits < 9 || windowBits > 15)
throw new ZlibException("windowBits must be in the range 9..15.");
if (memLevel < 1 || memLevel > MEM_LEVEL_MAX)
throw new ZlibException(String.Format("memLevel must be in the range 1.. {0}", MEM_LEVEL_MAX));
_codec.dstate = this;
w_bits = windowBits;
w_size = 1 << w_bits;
w_mask = w_size - 1;
hash_bits = memLevel + 7;
hash_size = 1 << hash_bits;
hash_mask = hash_size - 1;
hash_shift = ((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
window = new byte[w_size * 2];
prev = new short[w_size];
head = new short[hash_size];
// for memLevel==8, this will be 16384, 16k
lit_bufsize = 1 << (memLevel + 6);
// Use a single array as the buffer for data pending compression,
// the output distance codes, and the output length codes (aka tree).
// orig comment: This works just fine since the average
// output size for (length,distance) codes is <= 24 bits.
pending = new byte[lit_bufsize * 4];
_distanceOffset = lit_bufsize;
_lengthOffset = (1 + 2) * lit_bufsize;
// So, for memLevel 8, the length of the pending buffer is 65536. 64k.
// The first 16k are pending bytes.
// The middle slice, of 32k, is used for distance codes.
// The final 16k are length codes.
this.compressionLevel = level;
this.compressionStrategy = strategy;
Reset();
return ZlibConstants.Z_OK;
}
internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits, CompressionStrategy compressionStrategy)
{
return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, compressionStrategy);
}
internal int Initialize(ZlibCodec codec, CompressionLevel level)
{
return Initialize(codec, level, ZlibConstants.WindowBitsMax);
}
private void end()
{
if (z == null)
return;
if (_wantCompress)
{
_z.EndDeflate();
}
else
{
_z.EndInflate();
}
_z = null;
}
private void _PerpetualWriterMethod(object state)
{
TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod START");
try
{
do
{
// wait for the next session
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch _sessionReset.WaitOne(begin) PWM");
_sessionReset.WaitOne();
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch _sessionReset.WaitOne(done) PWM");
if (_isDisposed) break;
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch _sessionReset.Reset() PWM");
_sessionReset.Reset();
// repeatedly write buffers as they become ready
WorkItem workitem = null;
Alienlab.Zlib.CRC32 c= new Alienlab.Zlib.CRC32();
do
{
workitem = _pool[_nextToWrite % _pc];
lock(workitem)
{
if (_noMoreInputForThisSegment)
TraceOutput(TraceBits.Write,
"Write drain wi({0}) stat({1}) canuse({2}) cba({3})",
workitem.index,
workitem.status,
(workitem.status == (int)WorkItem.Status.Compressed),
workitem.compressedBytesAvailable);
do
{
if (workitem.status == (int)WorkItem.Status.Compressed)
{
TraceOutput(TraceBits.WriteBegin,
"Write begin wi({0}) stat({1}) cba({2})",
workitem.index,
workitem.status,
workitem.compressedBytesAvailable);
workitem.status = (int)WorkItem.Status.Writing;
_outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable);
c.Combine(workitem.crc, workitem.inputBytesAvailable);
_totalBytesProcessed += workitem.inputBytesAvailable;
_nextToWrite++;
workitem.inputBytesAvailable= 0;
workitem.status = (int)WorkItem.Status.Done;
TraceOutput(TraceBits.WriteDone,
"Write done wi({0}) stat({1}) cba({2})",
workitem.index,
workitem.status,
workitem.compressedBytesAvailable);
Monitor.Pulse(workitem);
break;
}
else
{
int wcycles = 0;
// I've locked a workitem I cannot use.
// Therefore, wake someone else up, and then release the lock.
while (workitem.status != (int)WorkItem.Status.Compressed)
{
TraceOutput(TraceBits.WriteWait,
"Write waiting wi({0}) stat({1}) nw({2}) nf({3}) nomore({4})",
workitem.index,
workitem.status,
_nextToWrite, _nextToFill,
_noMoreInputForThisSegment );
if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
break;
wcycles++;
// wake up someone else
Monitor.Pulse(workitem);
// release and wait
Monitor.Wait(workitem);
if (workitem.status == (int)WorkItem.Status.Compressed)
TraceOutput(TraceBits.WriteWait,
"Write A-OK wi({0}) stat({1}) iba({2}) cba({3}) cyc({4})",
workitem.index,
workitem.status,
workitem.inputBytesAvailable,
workitem.compressedBytesAvailable,
wcycles);
}
if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
break;
}
}
while (true);
}
if (_noMoreInputForThisSegment)
TraceOutput(TraceBits.Write,
"Write nomore nw({0}) nf({1}) break({2})",
_nextToWrite, _nextToFill, (_nextToWrite == _nextToFill));
if (_noMoreInputForThisSegment && _nextToWrite == _nextToFill)
break;
} while (true);
// Finish:
// After writing a series of buffers, closing each one with
// Flush.Sync, we now write the final one as Flush.Finish, and
// then stop.
byte[] buffer = new byte[128];
ZlibCodec 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.WriteBegin,
"Write begin flush bytes({0})",
buffer.Length - compressor.AvailableBytesOut);
_outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
TraceOutput(TraceBits.WriteBegin,
"Write done flush");
}
compressor.EndDeflate();
_Crc32 = c.Crc32Result;
// signal that writing is complete:
TraceOutput(TraceBits.Synch, "Synch _writingDone.Set() PWM");
_writingDone.Set();
}
while (true);
}
catch (System.Exception exc1)
{
lock(_eLock)
{
// expose the exception to the main thread
if (_pendingException!=null)
_pendingException = exc1;
}
}
TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod FINIS");
}
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;
}