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; } }