public WorkItem(int size, CompressionLevel compressLevel, CompressionStrategy strategy)
{
buffer = new byte[size];
// alloc 5 bytes overhead for every block (margin of safety= 2)
int n = size + ((size / 32768) + 1) * 5 * 2;
compressed = new byte[n];
status = (int)Status.None;
compressor = new ZlibCodec();
compressor.InitializeDeflate(compressLevel, false);
compressor.OutputBuffer = compressed;
compressor.InputBuffer = buffer;
}
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;
var c = new 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.
var 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.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 (Exception exc1)
{
lock (_eLock)
{
// expose the exception to the main thread
if (_pendingException != null)
_pendingException = exc1;
}
}
TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod FINIS");
}
private void _PerpetualWriterMethod(object state)
{
try
{
WorkItem item;
CRC32 crc;
TR_0020:
while (true)
{
this._sessionReset.WaitOne();
if (this._isDisposed)
{
break;
}
this._sessionReset.Reset();
item = null;
crc = new CRC32();
goto TR_001C;
}
return;
TR_000E:
if (this._noMoreInputForThisSegment)
{
}
if (!this._noMoreInputForThisSegment || (this._nextToWrite != this._nextToFill))
{
goto TR_001C;
}
else
{
byte[] buffer = new byte[0x80];
ZlibCodec codec = new ZlibCodec();
int num2 = codec.InitializeDeflate(this._compressLevel, false);
codec.InputBuffer = null;
codec.NextIn = 0;
codec.AvailableBytesIn = 0;
codec.OutputBuffer = buffer;
codec.NextOut = 0;
codec.AvailableBytesOut = buffer.Length;
num2 = codec.Deflate(FlushType.Finish);
if ((num2 != 1) && (num2 != 0))
{
throw new Exception("deflating: " + codec.Message);
}
if ((buffer.Length - codec.AvailableBytesOut) > 0)
{
this._outStream.Write(buffer, 0, buffer.Length - codec.AvailableBytesOut);
}
codec.EndDeflate();
this._Crc32 = crc.Crc32Result;
this._writingDone.Set();
}
goto TR_0020;
TR_001C:
while (true)
{
item = this._pool[this._nextToWrite % this._pc];
object obj2 = item;
lock (obj2)
{
if (this._noMoreInputForThisSegment)
{
}
while (true)
{
if (item.status != 4)
{
int num = 0;
while (true)
{
if ((item.status != 4) && (!this._noMoreInputForThisSegment || (this._nextToWrite != this._nextToFill)))
{
num++;
Monitor.Pulse(item);
Monitor.Wait(item);
if (item.status == 4)
{
}
continue;
}
if (!this._noMoreInputForThisSegment || (this._nextToWrite != this._nextToFill))
{
break;
}
break;
}
continue;
}
else
{
item.status = 5;
this._outStream.Write(item.compressed, 0, item.compressedBytesAvailable);
crc.Combine(item.crc, item.inputBytesAvailable);
this._totalBytesProcessed += item.inputBytesAvailable;
this._nextToWrite++;
item.inputBytesAvailable = 0;
item.status = 6;
Monitor.Pulse(item);
}
break;
}
}
break;
}
goto TR_000E;
}
catch (Exception exception)
{
lock (this._eLock)
{
if (this._pendingException != null)
{
this._pendingException = exception;
}
}
}
}
