public bool ReadFooter(InputBuffer input)
{
input.SkipToByteBoundary();
if (gzipFooterSubstate == GzipHeaderState.ReadingCRC)
{
while (loopCounter < 4)
{
int bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
expectedCrc32 |= ((uint)bits << (8 * loopCounter));
loopCounter++;
}
gzipFooterSubstate = GzipHeaderState.ReadingFileSize;
loopCounter = 0;
}
if (gzipFooterSubstate == GzipHeaderState.ReadingFileSize)
{
if (loopCounter == 0)
{
expectedOutputStreamSize = 0;
}
while (loopCounter < 4)
{
int bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
expectedOutputStreamSize |= ((uint)bits << (8 * loopCounter));
loopCounter++;
}
}
return(true);
}
//Each block of compressed data begins with 3 header bits
// containing the following data:
// first bit BFINAL
// next 2 bits BTYPE
// Note that the header bits do not necessarily begin on a byte
// boundary, since a block does not necessarily occupy an integral
// number of bytes.
// BFINAL is set if and only if this is the last block of the data
// set.
// BTYPE specifies how the data are compressed, as follows:
// 00 - no compression
// 01 - compressed with fixed Huffman codes
// 10 - compressed with dynamic Huffman codes
// 11 - reserved (error)
// The only difference between the two compressed cases is how the
// Huffman codes for the literal/length and distance alphabets are
// defined.
//
// This function returns true for success (end of block or output window is full,)
// false if we are short of input
//
private bool Decode()
{
bool eob = false;
bool result = false;
if (Finished())
{
return(true);
}
if (hasFormatReader)
{
if (state == InflaterState.ReadingHeader)
{
if (!formatReader.ReadHeader(input))
{
return(false);
}
state = InflaterState.ReadingBFinal;
}
else if (state == InflaterState.StartReadingFooter || state == InflaterState.ReadingFooter)
{
if (!formatReader.ReadFooter(input))
{
return(false);
}
state = InflaterState.VerifyingFooter;
return(true);
}
}
if (state == InflaterState.ReadingBFinal)
{ // reading bfinal bit
// Need 1 bit
if (!input.EnsureBitsAvailable(1))
{
return(false);
}
bfinal = input.GetBits(1);
state = InflaterState.ReadingBType;
}
if (state == InflaterState.ReadingBType)
{
// Need 2 bits
if (!input.EnsureBitsAvailable(2))
{
state = InflaterState.ReadingBType;
return(false);
}
blockType = (BlockType)input.GetBits(2);
if (blockType == BlockType.Dynamic)
{
Debug.WriteLineIf(CompressionTracingSwitch.Informational, "Decoding Dynamic Block", "Compression");
state = InflaterState.ReadingNumLitCodes;
}
else if (blockType == BlockType.Static)
{
Debug.WriteLineIf(CompressionTracingSwitch.Informational, "Decoding Static Block", "Compression");
literalLengthTree = HuffmanTree.StaticLiteralLengthTree;
distanceTree = HuffmanTree.StaticDistanceTree;
state = InflaterState.DecodeTop;
}
else if (blockType == BlockType.Uncompressed)
{
Debug.WriteLineIf(CompressionTracingSwitch.Informational, "Decoding UnCompressed Block", "Compression");
state = InflaterState.UncompressedAligning;
}
else
{
throw new InvalidDataException("UnknownBlockType");
}
}
if (blockType == BlockType.Dynamic)
{
if (state < InflaterState.DecodeTop)
{ // we are reading the header
result = DecodeDynamicBlockHeader();
}
else
{
result = DecodeBlock(out eob); // this can returns true when output is full
}
}
else if (blockType == BlockType.Static)
{
result = DecodeBlock(out eob);
}
else if (blockType == BlockType.Uncompressed)
{
result = DecodeUncompressedBlock(out eob);
}
else
{
throw new InvalidDataException("UnknownBlockType");
}
//
// If we reached the end of the block and the block we were decoding had
// bfinal=1 (final block)
//
if (eob && (bfinal != 0))
{
if (hasFormatReader)
{
state = InflaterState.StartReadingFooter;
}
else
{
state = InflaterState.Done;
}
}
return(result);
}
public bool ReadHeader(InputBuffer input)
{
while (true)
{
int bits;
switch (gzipHeaderSubstate)
{
case GzipHeaderState.ReadingID1:
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
if (bits != GZipConstants.ID1)
{
throw new InvalidDataException("CorruptedGZipHeader");
}
gzipHeaderSubstate = GzipHeaderState.ReadingID2;
goto case GzipHeaderState.ReadingID2;
case GzipHeaderState.ReadingID2:
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
if (bits != GZipConstants.ID2)
{
throw new InvalidDataException("CorruptedGZipHeader");
}
gzipHeaderSubstate = GzipHeaderState.ReadingCM;
goto case GzipHeaderState.ReadingCM;
case GzipHeaderState.ReadingCM:
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
if (bits != GZipConstants.Deflate)
{ // compression mode must be 8 (deflate)
throw new InvalidDataException("UnknownCompressionMode");
}
gzipHeaderSubstate = GzipHeaderState.ReadingFLG;;
goto case GzipHeaderState.ReadingFLG;
case GzipHeaderState.ReadingFLG:
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
gzip_header_flag = bits;
gzipHeaderSubstate = GzipHeaderState.ReadingMMTime;
loopCounter = 0; // 4 MMTIME bytes
goto case GzipHeaderState.ReadingMMTime;
case GzipHeaderState.ReadingMMTime:
bits = 0;
while (loopCounter < 4)
{
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
loopCounter++;
}
gzipHeaderSubstate = GzipHeaderState.ReadingXFL;
loopCounter = 0;
goto case GzipHeaderState.ReadingXFL;
case GzipHeaderState.ReadingXFL: // ignore XFL
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
gzipHeaderSubstate = GzipHeaderState.ReadingOS;
goto case GzipHeaderState.ReadingOS;
case GzipHeaderState.ReadingOS: // ignore OS
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
gzipHeaderSubstate = GzipHeaderState.ReadingXLen1;
goto case GzipHeaderState.ReadingXLen1;
case GzipHeaderState.ReadingXLen1:
if ((gzip_header_flag & (int)GZipOptionalHeaderFlags.ExtraFieldsFlag) == 0)
{
goto case GzipHeaderState.ReadingFileName;
}
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
gzip_header_xlen = bits;
gzipHeaderSubstate = GzipHeaderState.ReadingXLen2;
goto case GzipHeaderState.ReadingXLen2;
case GzipHeaderState.ReadingXLen2:
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
gzip_header_xlen |= (bits << 8);
gzipHeaderSubstate = GzipHeaderState.ReadingXLenData;
loopCounter = 0; // 0 bytes of XLEN data read so far
goto case GzipHeaderState.ReadingXLenData;
case GzipHeaderState.ReadingXLenData:
bits = 0;
while (loopCounter < gzip_header_xlen)
{
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
loopCounter++;
}
gzipHeaderSubstate = GzipHeaderState.ReadingFileName;
loopCounter = 0;
goto case GzipHeaderState.ReadingFileName;
case GzipHeaderState.ReadingFileName:
if ((gzip_header_flag & (int)GZipOptionalHeaderFlags.FileNameFlag) == 0)
{
gzipHeaderSubstate = GzipHeaderState.ReadingComment;
goto case GzipHeaderState.ReadingComment;
}
do
{
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
if (bits == 0)
{ // see '\0' in the file name string
break;
}
} while (true);
gzipHeaderSubstate = GzipHeaderState.ReadingComment;
goto case GzipHeaderState.ReadingComment;
case GzipHeaderState.ReadingComment:
if ((gzip_header_flag & (int)GZipOptionalHeaderFlags.CommentFlag) == 0)
{
gzipHeaderSubstate = GzipHeaderState.ReadingCRC16Part1;
goto case GzipHeaderState.ReadingCRC16Part1;
}
do
{
bits = input.GetBits(8);
if (bits < 0)
{
return(false);
}
if (bits == 0)
{ // see '\0' in the file name string
break;
}
} while (true);
gzipHeaderSubstate = GzipHeaderState.ReadingCRC16Part1;
goto case GzipHeaderState.ReadingCRC16Part1;
case GzipHeaderState.ReadingCRC16Part1:
if ((gzip_header_flag & (int)GZipOptionalHeaderFlags.CRCFlag) == 0)
{
gzipHeaderSubstate = GzipHeaderState.Done;
goto case GzipHeaderState.Done;
}
bits = input.GetBits(8); // ignore crc
if (bits < 0)
{
return(false);
}
gzipHeaderSubstate = GzipHeaderState.ReadingCRC16Part2;
goto case GzipHeaderState.ReadingCRC16Part2;
case GzipHeaderState.ReadingCRC16Part2:
bits = input.GetBits(8); // ignore crc
if (bits < 0)
{
return(false);
}
gzipHeaderSubstate = GzipHeaderState.Done;
goto case GzipHeaderState.Done;
case GzipHeaderState.Done:
return(true);
default:
Debug.Assert(false, "We should not reach unknown state!");
throw new InvalidDataException("UnknownState");
}
}
}