// 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);
}
// 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);
}
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);
}
internal DeflaterManaged()
{
deflateEncoder = new FastEncoder();
copyEncoder = new CopyEncoder();
input = new DeflateInput();
output = new OutputBuffer();
processingState = DeflaterState.NotStarted;
}
private void WriteLenNLen(ushort len, OutputBuffer output)
{
// len
output.WriteUInt16(len);
// nlen
ushort onesComp = (ushort)(~(ushort)len);
output.WriteUInt16(onesComp);
}
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);
}
}
}
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);
}
}
}
// 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;
}
}
// 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 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]);
}
}
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);
}
// 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);
}
}
}
// Can we safely continue writing to output buffer private bool SafeToWriteTo(OutputBuffer output) => output.FreeBytes > FastEncoderStatics.MaxCodeLen;
private void WriteLenNLen(ushort len, OutputBuffer output)
{
output.WriteUInt16(len);
ushort num = ~len;
output.WriteUInt16(num);
}
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 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);
}
internal void GetBlock(DeflateInput input, OutputBuffer output, int maxBytesToCopy)
{
WriteDeflatePreamble(output);
this.GetCompressedOutput(input, output, maxBytesToCopy);
this.WriteEndOfBlock(output);
}
private bool SafeToWriteTo(OutputBuffer output) // can we safely continue writing to output buffer
{
return(output.FreeBytes > FastEncoderStatics.MaxCodeLen);
}
internal void GetBlockHeader(OutputBuffer output)
{
WriteDeflatePreamble(output);
}
internal static void WriteDeflatePreamble(OutputBuffer output)
{
output.WriteBytes(FastEncoderStatics.FastEncoderTreeStructureData, 0, FastEncoderStatics.FastEncoderTreeStructureData.Length);
output.WriteBits(9, 0x22);
}
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);
}