◆ DecodeDynamicBlockHeader()

bool System.IO.Compression.InflaterManaged.DecodeDynamicBlockHeader ( )
inlineprivate
Definition at line 382 of file InflaterManaged.cs.
    {
        switch (_state)
        {
        case InflaterState.ReadingNumLitCodes:
            _literalLengthCodeCount = _input.GetBits(5);
            if (_literalLengthCodeCount < 0)
            {
                return false;
            }
            _literalLengthCodeCount += 257;
            _state = InflaterState.ReadingNumDistCodes;
            goto case InflaterState.ReadingNumDistCodes;
        case InflaterState.ReadingNumDistCodes:
            _distanceCodeCount = _input.GetBits(5);
            if (_distanceCodeCount < 0)
            {
                return false;
            }
            _distanceCodeCount++;
            _state = InflaterState.ReadingNumCodeLengthCodes;
            goto case InflaterState.ReadingNumCodeLengthCodes;
        case InflaterState.ReadingNumCodeLengthCodes:
            _codeLengthCodeCount = _input.GetBits(4);
            if (_codeLengthCodeCount < 0)
            {
                return false;
            }
            _codeLengthCodeCount += 4;
            _loopCounter = 0;
            _state = InflaterState.ReadingCodeLengthCodes;
            goto case InflaterState.ReadingCodeLengthCodes;
        case InflaterState.ReadingCodeLengthCodes:
        {
            while (_loopCounter < _codeLengthCodeCount)
            {
                int bits = _input.GetBits(3);
                if (bits < 0)
                {
                    return false;
                }
                _codeLengthTreeCodeLength[s_codeOrder[_loopCounter]] = (byte)bits;
                _loopCounter++;
            }
            for (int l = _codeLengthCodeCount; l < s_codeOrder.Length; l++)
            {
                _codeLengthTreeCodeLength[s_codeOrder[l]] = 0;
            }
            _codeLengthTree = new HuffmanTree(_codeLengthTreeCodeLength);
            _codeArraySize = _literalLengthCodeCount + _distanceCodeCount;
            _loopCounter = 0;
            _state = InflaterState.ReadingTreeCodesBefore;
            goto case InflaterState.ReadingTreeCodesBefore;
        }
        case InflaterState.ReadingTreeCodesBefore:
        case InflaterState.ReadingTreeCodesAfter:
        {
            while (_loopCounter < _codeArraySize)
            {
                if (_state == InflaterState.ReadingTreeCodesBefore && (_lengthCode = _codeLengthTree.GetNextSymbol(_input)) < 0)
                {
                    return false;
                }
                if (_lengthCode <= 15)
                {
                    _codeList[_loopCounter++] = (byte)_lengthCode;
                }
                else if (_lengthCode == 16)
                {
                    if (!_input.EnsureBitsAvailable(2))
                    {
                        _state = InflaterState.ReadingTreeCodesAfter;
                        return false;
                    }
                    if (_loopCounter == 0)
                    {
                        throw new InvalidDataException();
                    }
                    byte b = _codeList[_loopCounter - 1];
                    int num = _input.GetBits(2) + 3;
                    if (_loopCounter + num > _codeArraySize)
                    {
                        throw new InvalidDataException();
                    }
                    for (int i = 0; i < num; i++)
                    {
                        _codeList[_loopCounter++] = b;
                    }
                }
                else if (_lengthCode == 17)
                {
                    if (!_input.EnsureBitsAvailable(3))
                    {
                        _state = InflaterState.ReadingTreeCodesAfter;
                        return false;
                    }
                    int num = _input.GetBits(3) + 3;
                    if (_loopCounter + num > _codeArraySize)
                    {
                        throw new InvalidDataException();
                    }
                    for (int j = 0; j < num; j++)
                    {
                        _codeList[_loopCounter++] = 0;
                    }
                }
                else
                {
                    if (!_input.EnsureBitsAvailable(7))
                    {
                        _state = InflaterState.ReadingTreeCodesAfter;
                        return false;
                    }
                    int num = _input.GetBits(7) + 11;
                    if (_loopCounter + num > _codeArraySize)
                    {
                        throw new InvalidDataException();
                    }
                    for (int k = 0; k < num; k++)
                    {
                        _codeList[_loopCounter++] = 0;
                    }
                }
                _state = InflaterState.ReadingTreeCodesBefore;
            }
            byte[] array = new byte[288];
            byte[] array2 = new byte[32];
            Array.Copy(_codeList, array, _literalLengthCodeCount);
            Array.Copy(_codeList, _literalLengthCodeCount, array2, 0, _distanceCodeCount);
            if (array[256] == 0)
            {
                throw new InvalidDataException();
            }
            _literalLengthTree = new HuffmanTree(array);
            _distanceTree = new HuffmanTree(array2);
            _state = InflaterState.DecodeTop;
            return true;
        }
        default:
            throw new InvalidDataException(System.SR.UnknownState);
        }
    }
Referenced by System.IO.Compression.InflaterManaged.Decode().