public void GetBlock(DeflateInput input, OutputBuffer output, bool isFinal)
{
int num = 0;
if (input != null)
{
num = Math.Min(input.Count, output.FreeBytes - 5 - output.BitsInBuffer);
if (num > 65531)
{
num = 65531;
}
}
if (isFinal)
{
output.WriteBits(3, 1u);
}
else
{
output.WriteBits(3, 0u);
}
output.FlushBits();
this.WriteLenNLen((ushort)num, output);
if (input != null && num > 0)
{
output.WriteBytes(input.Buffer, input.StartIndex, num);
input.ConsumeBytes(num);
}
}
private void GetCompressedOutput(DeflateInput input, OutputBuffer output, int maxBytesToCopy)
{
int bytesWritten = output.BytesWritten;
int num = 0;
int num2 = this.BytesInHistory + input.Count;
do
{
int num3 = (input.Count < this.inputWindow.FreeWindowSpace) ? input.Count : this.inputWindow.FreeWindowSpace;
if (maxBytesToCopy >= 1)
{
num3 = Math.Min(num3, maxBytesToCopy - num);
}
if (num3 > 0)
{
this.inputWindow.CopyBytes(input.Buffer, input.StartIndex, num3);
input.ConsumeBytes(num3);
num += num3;
}
this.GetCompressedOutput(output);
}while (this.SafeToWriteTo(output) && this.InputAvailable(input) && (maxBytesToCopy < 1 || num < maxBytesToCopy));
int num4 = output.BytesWritten - bytesWritten;
int num5 = this.BytesInHistory + input.Count;
int num6 = num2 - num5;
if (num4 != 0)
{
this.lastCompressionRatio = (double)num4 / (double)num6;
}
}
// maxBytesToCopy limits the number of bytes we can copy from input. Set to any value < 1 if no limit
private void GetCompressedOutput(DeflateInput input, OutputBuffer output, int maxBytesToCopy) {
// snapshot for compression ratio stats
int bytesWrittenPre = output.BytesWritten;
int bytesConsumedFromInput = 0;
int inputBytesPre = BytesInHistory + input.Count;
do {
// read more input data into the window if there is space available
int bytesToCopy = (input.Count < inputWindow.FreeWindowSpace) ?
input.Count : inputWindow.FreeWindowSpace;
if (maxBytesToCopy >= 1) {
bytesToCopy = Math.Min(bytesToCopy, maxBytesToCopy - bytesConsumedFromInput);
}
if (bytesToCopy > 0) {
// copy data into history window
inputWindow.CopyBytes(input.Buffer, input.StartIndex, bytesToCopy);
input.ConsumeBytes(bytesToCopy);
bytesConsumedFromInput += bytesToCopy;
}
GetCompressedOutput(output);
} while (SafeToWriteTo(output) && InputAvailable(input) && (maxBytesToCopy < 1 || bytesConsumedFromInput < maxBytesToCopy));
// determine compression ratio, save
int bytesWrittenPost = output.BytesWritten;
int bytesWritten = bytesWrittenPost - bytesWrittenPre;
int inputBytesPost = BytesInHistory + input.Count;
int totalBytesConsumed = inputBytesPre - inputBytesPost;
if (bytesWritten != 0) {
lastCompressionRatio = (double)bytesWritten / (double)totalBytesConsumed;
}
}
// null input means write an empty payload with formatting info. This is needed for the final block.
public void GetBlock(DeflateInput input, OutputBuffer output, bool isFinal)
{
Debug.Assert(output != null);
Debug.Assert(output.FreeBytes >= PaddingSize);
// determine number of bytes to write
int count = 0;
if (input != null)
{
// allow space for padding and bits not yet flushed to buffer
count = Math.Min(input.Count, output.FreeBytes - PaddingSize - output.BitsInBuffer);
// we don't expect the output buffer to ever be this big (currently 4K), but we'll check this
// just in case that changes.
if (count > MaxUncompressedBlockSize - PaddingSize)
{
count = MaxUncompressedBlockSize - PaddingSize;
}
}
// write header and flush bits
if (isFinal)
{
output.WriteBits(FastEncoderStatics.BFinalNoCompressionHeaderBitCount,
FastEncoderStatics.BFinalNoCompressionHeader);
}
else
{
output.WriteBits(FastEncoderStatics.NoCompressionHeaderBitCount,
FastEncoderStatics.NoCompressionHeader);
}
// now we're aligned
output.FlushBits();
// write len, nlen
WriteLenNLen((ushort)count, output);
// write uncompressed bytes
if (input != null && count > 0)
{
output.WriteBytes(input.Buffer, input.StartIndex, count);
input.ConsumeBytes(count);
}
}
// null input means write an empty payload with formatting info. This is needed for the final block.
public void GetBlock(DeflateInput input, OutputBuffer output, bool isFinal) {
Debug.Assert(output != null);
Debug.Assert(output.FreeBytes >= PaddingSize);
// determine number of bytes to write
int count = 0;
if (input != null) {
// allow space for padding and bits not yet flushed to buffer
count = Math.Min(input.Count, output.FreeBytes - PaddingSize - output.BitsInBuffer);
// we don't expect the output buffer to ever be this big (currently 4K), but we'll check this
// just in case that changes.
if (count > MaxUncompressedBlockSize - PaddingSize) {
count = MaxUncompressedBlockSize - PaddingSize;
}
}
// write header and flush bits
if (isFinal) {
output.WriteBits(FastEncoderStatics.BFinalNoCompressionHeaderBitCount,
FastEncoderStatics.BFinalNoCompressionHeader);
}
else {
output.WriteBits(FastEncoderStatics.NoCompressionHeaderBitCount,
FastEncoderStatics.NoCompressionHeader);
}
// now we're aligned
output.FlushBits();
// write len, nlen
WriteLenNLen((ushort)count, output);
// write uncompressed bytes
if (input != null && count > 0) {
output.WriteBytes(input.Buffer, input.StartIndex, count);
input.ConsumeBytes(count);
}
}
// maxBytesToCopy limits the number of bytes we can copy from input. Set to any value < 1 if no limit
private void GetCompressedOutput(DeflateInput input, OutputBuffer output, int maxBytesToCopy)
{
// snapshot for compression ratio stats
var bytesWrittenPre = output.BytesWritten;
var bytesConsumedFromInput = 0;
var inputBytesPre = BytesInHistory + input.Count;
do
{
// read more input data into the window if there is space available
var bytesToCopy = input.Count < inputWindow.FreeWindowSpace
? input.Count
: inputWindow.FreeWindowSpace;
if (maxBytesToCopy >= 1)
{
bytesToCopy = Math.Min(bytesToCopy, maxBytesToCopy - bytesConsumedFromInput);
}
if (bytesToCopy > 0)
{
// copy data into history window
inputWindow.CopyBytes(input.Buffer, input.StartIndex, bytesToCopy);
input.ConsumeBytes(bytesToCopy);
bytesConsumedFromInput += bytesToCopy;
}
GetCompressedOutput(output);
} while (SafeToWriteTo(output) && InputAvailable(input) &&
(maxBytesToCopy < 1 || bytesConsumedFromInput < maxBytesToCopy));
// determine compression ratio, save
var bytesWrittenPost = output.BytesWritten;
var bytesWritten = bytesWrittenPost - bytesWrittenPre;
var inputBytesPost = BytesInHistory + input.Count;
var totalBytesConsumed = inputBytesPre - inputBytesPost;
if (bytesWritten != 0)
{
LastCompressionRatio = bytesWritten / (double)totalBytesConsumed;
}
}