Huffman Codec in netty HPACK

   private void encodeStringLiteral(ByteBuf out, CharSequence string) {
        int huffmanLength;
        if (string.length() >= huffCodeThreshold
                && (huffmanLength = hpackHuffmanEncoder.getEncodedLength(string)) < string.length()) {
            encodeInteger(out, 0x80, 7, huffmanLength);
            hpackHuffmanEncoder.encode(out, string);
        } else {
            encodeInteger(out, 0x00, 7, string.length());
            if (string instanceof AsciiString) {
                // Fast-path
                AsciiString asciiString = (AsciiString) string;
                out.writeBytes(asciiString.array(), asciiString.arrayOffset(), asciiString.length());
            } else {
                // Only ASCII is allowed in http2 headers, so its fine to use this.
                // https://tools.ietf.org/html/rfc7540#section-8.1.2
                out.writeCharSequence(string, CharsetUtil.ISO_8859_1);
            }
        }
    }

    private int getEncodedLengthSlowPath(CharSequence data) {
        long len = 0;
        for (int i = 0; i < data.length(); i++) {
            len += lengths[data.charAt(i) & 0xFF];
        }
        return (int) ((len + 7) >> 3);
    }

    private void encodeSlowPath(ByteBuf out, CharSequence data) {
        long current = 0;
        int n = 0;

        for (int i = 0; i < data.length(); i++) {
            int b = data.charAt(i) & 0xFF;
            int code = codes[b];
            int nbits = lengths[b];

            current <<= nbits;
            current |= code;
            n += nbits;

            while (n >= 8) {
                n -= 8;
                out.writeByte((int) (current >> n));
            }
        }

        if (n > 0) {
            current <<= 8 - n;
            current |= 0xFF >>> n; // this should be EOS symbol
            out.writeByte((int) current);
        }
    }

current <<= nbits;
current |= code;

Get the length of an input string (lo) and its byte count (bo).
∙ Prepare a buffer whose length is lo + bo.
∙ Guess the result length with the factor of 0.8 (le) and its byte count (be).
∙ Huffman encode the string starting from the position of be.
– If we reach the end of the buffer during this encoding, encode lo in the beginning of the buffer and copy the input string as is.
– Otherwise, obtain the real length of the result (lr) and its byte count (br).
    * In the rare case where be is not equal to br, move the result appropriately within the buffer and encode lr in the beginning of the buffer.
    * Otherwise, encode lr in the beginning of the buffe

- 从root state开始，依次处理每k个bits
- 根据当前state以及当前k个bits的取值，在状态迁移表中找到对应的entry，跳转到entry的next state，并根据entry的标志位决定如下动作：
    - 如果标志位中有输出标志，则输出entry中对应的byte
    - 如果标志中有解码失败标志，则终止解码过程，直接通知上层解码失败
- 处理最后4个bits后，如果entry中没有解码完成标志，说明数据有丢失，通知上层解码失败

    //处理单个byte的输入
    public boolean process(byte input) {
        return processNibble(input >> 4) && processNibble(input);
    }

    private boolean processNibble(int input) {
        // The high nibble of the flags byte of each row is always zero
        // (low nibble after shifting row by 12), since there are only 3 flag bits
        int index = state >> 12 | (input & 0x0F);
        state = HUFFS[index];
        if ((state & HUFFMAN_FAIL_SHIFT) != 0) {
            return false;
        }
        if ((state & HUFFMAN_EMIT_SYMBOL_SHIFT) != 0) {
            // state is always positive so can cast without mask here
            dest[k++] = (byte) state;
        }
        return true;
    }