// Copy the compressed bytes to output buffer as a block. maxBytesToCopy limits the number of // bytes we can copy from input. Set to any value < 1 if no limit internal void GetBlock(DeflateInput input, OutputBuffer output, int maxBytesToCopy) { Debug.Assert(InputAvailable(input), "call SetInput before trying to compress!"); WriteDeflatePreamble(output); GetCompressedOutput(input, output, maxBytesToCopy); WriteEndOfBlock(output); }
// 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; } }
internal static void WriteMatch(int matchLen, int matchPos, OutputBuffer output) { Debug.Assert(matchLen >= FastEncoderWindow.MinMatch && matchLen <= FastEncoderWindow.MaxMatch, "Illegal currentMatch length!"); // Get the code information for a match code uint codeInfo = FastEncoderStatics.FastEncoderLiteralCodeInfo[(FastEncoderStatics.NumChars + 1 - FastEncoderWindow.MinMatch) + matchLen]; int codeLen = (int)codeInfo & 31; Debug.Assert(codeLen != 0, "Invalid Match Length!"); if (codeLen <= 16) { output.WriteBits(codeLen, codeInfo >> 5); } else { output.WriteBits(16, (codeInfo >> 5) & 65535); output.WriteBits(codeLen - 16, codeInfo >> (5 + 16)); } // Get the code information for a distance code codeInfo = FastEncoderStatics.FastEncoderDistanceCodeInfo[FastEncoderStatics.GetSlot(matchPos)]; output.WriteBits((int)(codeInfo & 15), codeInfo >> 8); int extraBits = (int)(codeInfo >> 4) & 15; if (extraBits != 0) { output.WriteBits(extraBits, (uint)matchPos & FastEncoderStatics.BitMask[extraBits]); } }
private void GetCompressedOutput(DeflateInput input, OutputBuffer output, int maxBytesToCopy) { int bytesWritten = output.BytesWritten; int num2 = 0; int num3 = this.BytesInHistory + input.Count; do { int num4 = (input.Count < this.inputWindow.FreeWindowSpace) ? input.Count : this.inputWindow.FreeWindowSpace; if (maxBytesToCopy >= 1) { num4 = Math.Min(num4, maxBytesToCopy - num2); } if (num4 > 0) { this.inputWindow.CopyBytes(input.Buffer, input.StartIndex, num4); input.ConsumeBytes(num4); num2 += num4; } this.GetCompressedOutput(output); }while ((this.SafeToWriteTo(output) && this.InputAvailable(input)) && ((maxBytesToCopy < 1) || (num2 < maxBytesToCopy))); int num6 = output.BytesWritten - bytesWritten; int num7 = this.BytesInHistory + input.Count; int num8 = num3 - num7; if (num6 != 0) { this.lastCompressionRatio = ((double)num6) / ((double)num8); } }
public void GetBlock(DeflateInput input, OutputBuffer output, bool isFinal) { int count = 0; if (input != null) { count = Math.Min(input.Count, (output.FreeBytes - 5) - output.BitsInBuffer); if (count > 0xfffb) { count = 0xfffb; } } if (isFinal) { output.WriteBits(3, 1); } else { output.WriteBits(3, 0); } output.FlushBits(); this.WriteLenNLen((ushort)count, output); if ((input != null) && (count > 0)) { output.WriteBytes(input.Buffer, input.StartIndex, count); input.ConsumeBytes(count); } }
private void GetCompressedOutput(DeflateInput input, OutputBuffer output, int maxBytesToCopy) { int bytesWritten = output.BytesWritten; int num2 = 0; int num3 = this.BytesInHistory + input.Count; do { int num4 = (input.Count < this.inputWindow.FreeWindowSpace) ? input.Count : this.inputWindow.FreeWindowSpace; if (maxBytesToCopy >= 1) { num4 = Math.Min(num4, maxBytesToCopy - num2); } if (num4 > 0) { this.inputWindow.CopyBytes(input.Buffer, input.StartIndex, num4); input.ConsumeBytes(num4); num2 += num4; } this.GetCompressedOutput(output); } while ((this.SafeToWriteTo(output) && this.InputAvailable(input)) && ((maxBytesToCopy < 1) || (num2 < maxBytesToCopy))); int num6 = output.BytesWritten - bytesWritten; int num7 = this.BytesInHistory + input.Count; int num8 = num3 - num7; if (num6 != 0) { this.lastCompressionRatio = ((double) num6) / ((double) num8); } }
private void WriteEndOfBlock(OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[0x100]; int n = ((int)num) & 0x1f; output.WriteBits(n, num >> 5); }
private void WriteLenNLen(ushort len, OutputBuffer output) { output.WriteUInt16(len); ushort num = ~len; output.WriteUInt16(num); }
public void GetBlock(DeflateInput input, OutputBuffer output, bool isFinal) { int count = 0; if (input != null) { count = Math.Min(input.Count, (output.FreeBytes - 5) - output.BitsInBuffer); if (count > 0xfffb) { count = 0xfffb; } } if (isFinal) { output.WriteBits(3, 1); } else { output.WriteBits(3, 0); } output.FlushBits(); this.WriteLenNLen((ushort) count, output); if ((input != null) && (count > 0)) { output.WriteBytes(input.Buffer, input.StartIndex, count); input.ConsumeBytes(count); } }
// Output the block type and tree structure for our hard-coded trees. // Contains following data: // "final" block flag 1 bit // BLOCKTYPE_DYNAMIC 2 bits // FastEncoderLiteralTreeLength // FastEncoderDistanceTreeLength // internal static void WriteDeflatePreamble(OutputBuffer output) { //Debug.Assert( bitCount == 0, "bitCount must be zero before writing tree bit!"); output.WriteBytes(FastEncoderStatics.FastEncoderTreeStructureData, 0, FastEncoderStatics.FastEncoderTreeStructureData.Length); output.WriteBits(FastEncoderStatics.FastEncoderPostTreeBitCount, FastEncoderStatics.FastEncoderPostTreeBitBuf); }
static internal void WriteChar(byte b, OutputBuffer output) { Debug.WriteLineIf(CompressionTracingSwitch.Verbose, String.Format(CultureInfo.InvariantCulture, "Literal: {0}", b), "Compression"); uint code = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits((int)code & 31, code >> 5); }
internal DeflaterManaged() { deflateEncoder = new FastEncoder(); copyEncoder = new CopyEncoder(); input = new DeflateInput(); output = new OutputBuffer(); processingState = DeflaterState.NotStarted; }
private void WriteEndOfBlock(OutputBuffer output) { // The fast encoder outputs one long block, so it just needs to terminate this block const int EndOfBlockCode = 256; uint code_info = FastEncoderStatics.FastEncoderLiteralCodeInfo[EndOfBlockCode]; int code_len = (int)(code_info & 31); output.WriteBits(code_len, code_info >> 5); }
private void WriteLenNLen(ushort len, OutputBuffer output) { // len output.WriteUInt16(len); // nlen ushort onesComp = (ushort)(~(ushort)len); output.WriteUInt16(onesComp); }
/// <summary> /// null input means write an empty payload with formatting info. This is needed for the final block. /// </summary> 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); } }
private void GetCompressedOutput(OutputBuffer output) { while ((this.inputWindow.BytesAvailable > 0) && this.SafeToWriteTo(output)) { this.inputWindow.GetNextSymbolOrMatch(this.currentMatch); if (this.currentMatch.State == MatchState.HasSymbol) { WriteChar(this.currentMatch.Symbol, output); } else { if (this.currentMatch.State == MatchState.HasMatch) { WriteMatch(this.currentMatch.Length, this.currentMatch.Position, output); continue; } WriteChar(this.currentMatch.Symbol, output); WriteMatch(this.currentMatch.Length, this.currentMatch.Position, output); } } }
// compress the bytes in input history window private void GetCompressedOutput(OutputBuffer output) { while (inputWindow.BytesAvailable > 0 && SafeToWriteTo(output)) { // Find next match. A match can be a symbol, // a distance/length pair, a symbol followed by a distance/Length pair inputWindow.GetNextSymbolOrMatch(currentMatch); if (currentMatch.State == MatchState.HasSymbol) { WriteChar(currentMatch.Symbol, output); } else if (currentMatch.State == MatchState.HasMatch) { WriteMatch(currentMatch.Length, currentMatch.Position, output); } else { WriteChar(currentMatch.Symbol, output); WriteMatch(currentMatch.Length, currentMatch.Position, output); } } }
internal static void WriteMatch(int matchLen, int matchPos, OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[0xfe + matchLen]; int n = ((int)num) & 0x1f; if (n <= 0x10) { output.WriteBits(n, num >> 5); } else { output.WriteBits(0x10, (num >> 5) & 0xffff); output.WriteBits(n - 0x10, num >> 0x15); } num = FastEncoderStatics.FastEncoderDistanceCodeInfo[FastEncoderStatics.GetSlot(matchPos)]; output.WriteBits(((int)num) & 15, num >> 8); int num3 = ((int)(num >> 4)) & 15; if (num3 != 0) { output.WriteBits(num3, ((uint)matchPos) & FastEncoderStatics.BitMask[num3]); } }
internal void GetBlockHeader(OutputBuffer output) { WriteDeflatePreamble(output); }
internal static void WriteChar(byte b, OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits(((int)num) & 0x1f, num >> 5); }
// Compress data but don't format as block (doesn't have header and footer) internal void GetCompressedData(DeflateInput input, OutputBuffer output) { GetCompressedOutput(input, output, -1); }
static internal void WriteMatch(int matchLen, int matchPos, OutputBuffer output) { Debug.Assert(matchLen >= FastEncoderWindow.MinMatch && matchLen <= FastEncoderWindow.MaxMatch, "Illegal currentMatch length!"); Debug.WriteLineIf(CompressionTracingSwitch.Verbose, String.Format(CultureInfo.InvariantCulture, "Match: {0}:{1}", matchLen, matchPos), "Compression"); // Get the code information for a match code uint codeInfo = FastEncoderStatics.FastEncoderLiteralCodeInfo[(FastEncoderStatics.NumChars + 1 - FastEncoderWindow.MinMatch) + matchLen]; int codeLen = (int)codeInfo & 31; Debug.Assert(codeLen != 0, "Invalid Match Length!"); if (codeLen <= 16) { output.WriteBits(codeLen, codeInfo >> 5); } else { output.WriteBits(16, (codeInfo >> 5) & 65535); output.WriteBits(codeLen - 16, codeInfo >> (5 + 16)); } // Get the code information for a distance code codeInfo = FastEncoderStatics.FastEncoderDistanceCodeInfo[FastEncoderStatics.GetSlot(matchPos)]; output.WriteBits((int)(codeInfo & 15), codeInfo >> 8); int extraBits = (int)(codeInfo >> 4) & 15; if (extraBits != 0) { output.WriteBits(extraBits, (uint)matchPos & FastEncoderStatics.BitMask[extraBits]); } }
// Compress data but don't format as block (doesn't have header and footer) internal void GetCompressedData(DeflateInput input, OutputBuffer output) => GetCompressedOutput(input, output, maxBytesToCopy: -1);
internal static void WriteDeflatePreamble(OutputBuffer output) { output.WriteBytes(FastEncoderStatics.FastEncoderTreeStructureData, 0, FastEncoderStatics.FastEncoderTreeStructureData.Length); output.WriteBits(9, 0x22); }
private bool SafeToWriteTo(OutputBuffer output) { return(output.FreeBytes > 0x10); }
internal void GetBlock(DeflateInput input, OutputBuffer output, int maxBytesToCopy) { WriteDeflatePreamble(output); this.GetCompressedOutput(input, output, maxBytesToCopy); this.WriteEndOfBlock(output); }
static internal void WriteChar(byte b, OutputBuffer output) { uint code = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits((int)code & 31, code >> 5); }
// Can we safely continue writing to output buffer private bool SafeToWriteTo(OutputBuffer output) => output.FreeBytes > FastEncoderStatics.MaxCodeLen;
internal static void WriteChar(byte b, OutputBuffer output) { uint code = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits((int)code & 31, code >> 5); }
internal void GetBlockFooter(OutputBuffer output) { WriteEndOfBlock(output); }
internal static void WriteMatch(int matchLen, int matchPos, OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[0xfe + matchLen]; int n = ((int) num) & 0x1f; if (n <= 0x10) { output.WriteBits(n, num >> 5); } else { output.WriteBits(0x10, (num >> 5) & 0xffff); output.WriteBits(n - 0x10, num >> 0x15); } num = FastEncoderStatics.FastEncoderDistanceCodeInfo[FastEncoderStatics.GetSlot(matchPos)]; output.WriteBits(((int) num) & 15, num >> 8); int num3 = ((int) (num >> 4)) & 15; if (num3 != 0) { output.WriteBits(num3, ((uint) matchPos) & FastEncoderStatics.BitMask[num3]); } }
private bool SafeToWriteTo(OutputBuffer output) { // can we safely continue writing to output buffer return output.FreeBytes > FastEncoderStatics.MaxCodeLen; }
internal void GetBlockFooter(OutputBuffer output) { this.WriteEndOfBlock(output); }
internal static void WriteChar(byte b, OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits(((int) num) & 0x1f, num >> 5); }
internal void GetCompressedData(DeflateInput input, OutputBuffer output) { this.GetCompressedOutput(input, output, -1); }
private void WriteEndOfBlock(OutputBuffer output) { uint num = FastEncoderStatics.FastEncoderLiteralCodeInfo[0x100]; int n = ((int) num) & 0x1f; output.WriteBits(n, num >> 5); }
private bool SafeToWriteTo(OutputBuffer output) // can we safely continue writing to output buffer { return(output.FreeBytes > FastEncoderStatics.MaxCodeLen); }
static internal void WriteChar(byte b, OutputBuffer output) { Debug.WriteLineIf(CompressionTracingSwitch.Verbose, String.Format(CultureInfo.InvariantCulture, "Literal: {0}", b ), "Compression"); uint code = FastEncoderStatics.FastEncoderLiteralCodeInfo[b]; output.WriteBits((int)code & 31, code >> 5); }
internal void RestoreState(OutputBuffer.BufferState state) { _pos = state.pos; _bitBuf = state.bitBuf; _bitCount = state.bitCount; }
private bool SafeToWriteTo(OutputBuffer output) { return (output.FreeBytes > 0x10); }
// Output the block type and tree structure for our hard-coded trees. // Contains following data: // "final" block flag 1 bit // BLOCKTYPE_DYNAMIC 2 bits // FastEncoderLiteralTreeLength // FastEncoderDistanceTreeLength // static internal void WriteDeflatePreamble(OutputBuffer output) { //Debug.Assert( bitCount == 0, "bitCount must be zero before writing tree bit!"); output.WriteBytes(FastEncoderStatics.FastEncoderTreeStructureData, 0, FastEncoderStatics.FastEncoderTreeStructureData.Length); output.WriteBits(FastEncoderStatics.FastEncoderPostTreeBitCount, FastEncoderStatics.FastEncoderPostTreeBitBuf); }