private void m_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];
ZLibCodec compressor = new ZLibCodec();
int rc = compressor.InitializeDeflate(this.m_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)
{
this.TraceOutput(TraceBits.EmitBegin,
"Emit begin flush bytes({0})",
buffer.Length - compressor.AvailableBytesOut);
this.m_outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
this.TraceOutput(TraceBits.EmitDone,
"Emit done flush");
}
compressor.EndDeflate();
this.Crc32 = this.m_runningCrc.Crc32Result;
}
private void m_PerpetualWriterMethod(object state)
{
TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod START");
try
{
do
{
// wait for the next session
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch m_sessionReset.WaitOne(begin) PWM");
m_sessionReset.WaitOne();
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch m_sessionReset.WaitOne(done) PWM");
if (_isDisposed)
{
break;
}
TraceOutput(TraceBits.Synch | TraceBits.WriterThread, "Synch m_sessionReset.Reset() PWM");
m_sessionReset.Reset();
// repeatedly write buffers as they become ready
WorkItem workitem = null;
Supercell.Magic.Servers.Core.Libs.ZLib.CRC32 c = new Supercell.Magic.Servers.Core.Libs.ZLib.CRC32();
do
{
workitem = m_pool[_nextToWrite % m_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;
m_outStream.Write(workitem.compressed, 0, workitem.compressedBytesAvailable);
c.Combine(workitem.crc, workitem.inputBytesAvailable);
m_totalBytesProcessed += workitem.inputBytesAvailable;
m_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,
m_nextToWrite, m_nextToFill,
m_noMoreInputForThisSegment);
if (_noMoreInputForThisSegment && m_nextToWrite == m_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 && m_nextToWrite == m_nextToFill)
{
break;
}
}
}while (true);
}
if (_noMoreInputForThisSegment)
{
TraceOutput(TraceBits.Write,
"Write nomore nw({0}) nf({1}) break({2})",
m_nextToWrite, m_nextToFill, (_nextToWrite == m_nextToFill));
}
if (_noMoreInputForThisSegment && m_nextToWrite == m_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);
m_outStream.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
TraceOutput(TraceBits.WriteBegin,
"Write done flush");
}
compressor.EndDeflate();
m_Crc32 = c.Crc32Result;
// signal that writing is complete:
TraceOutput(TraceBits.Synch, "Synch m_writingDone.Set() PWM");
m_writingDone.Set();
}while (true);
}
catch (System.Exception exc1)
{
lock (_eLock)
{
// expose the exception to the main thread
if (_pendingException != null)
{
m_pendingException = exc1;
}
}
}
TraceOutput(TraceBits.WriterThread, "_PerpetualWriterMethod FINIS");
}