const offsetCodeCount … const endBlockMarker … const lengthCodesStart … const codegenCodeCount … const badCode … const bufferFlushSize … const bufferSize … var lengthExtraBits … var lengthBase … var offsetExtraBits … var offsetBase … var codegenOrder … type huffmanBitWriter … func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter { … } func (w *huffmanBitWriter) reset(writer io.Writer) { … } func (w *huffmanBitWriter) flush() { … } func (w *huffmanBitWriter) write(b []byte) { … } func (w *huffmanBitWriter) writeBits(b int32, nb uint) { … } func (w *huffmanBitWriter) writeBytes(bytes []byte) { … } // RFC 1951 3.2.7 specifies a special run-length encoding for specifying // the literal and offset lengths arrays (which are concatenated into a single // array). This method generates that run-length encoding. // // The result is written into the codegen array, and the frequencies // of each code is written into the codegenFreq array. // Codes 0-15 are single byte codes. Codes 16-18 are followed by additional // information. Code badCode is an end marker // // numLiterals The number of literals in literalEncoding // numOffsets The number of offsets in offsetEncoding // litenc, offenc The literal and offset encoder to use func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int, litEnc, offEnc *huffmanEncoder) { … } // dynamicSize returns the size of dynamically encoded data in bits. func (w *huffmanBitWriter) dynamicSize(litEnc, offEnc *huffmanEncoder, extraBits int) (size, numCodegens int) { … } // fixedSize returns the size of dynamically encoded data in bits. func (w *huffmanBitWriter) fixedSize(extraBits int) int { … } // storedSize calculates the stored size, including header. // The function returns the size in bits and whether the block // fits inside a single block. func (w *huffmanBitWriter) storedSize(in []byte) (int, bool) { … } func (w *huffmanBitWriter) writeCode(c hcode) { … } // Write the header of a dynamic Huffman block to the output stream. // // numLiterals The number of literals specified in codegen // numOffsets The number of offsets specified in codegen // numCodegens The number of codegens used in codegen func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, numCodegens int, isEof bool) { … } func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) { … } func (w *huffmanBitWriter) writeFixedHeader(isEof bool) { … } // writeBlock will write a block of tokens with the smallest encoding. // The original input can be supplied, and if the huffman encoded data // is larger than the original bytes, the data will be written as a // stored block. // If the input is nil, the tokens will always be Huffman encoded. func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) { … } // writeBlockDynamic encodes a block using a dynamic Huffman table. // This should be used if the symbols used have a disproportionate // histogram distribution. // If input is supplied and the compression savings are below 1/16th of the // input size the block is stored. func (w *huffmanBitWriter) writeBlockDynamic(tokens []token, eof bool, input []byte) { … } // indexTokens indexes a slice of tokens, and updates // literalFreq and offsetFreq, and generates literalEncoding // and offsetEncoding. // The number of literal and offset tokens is returned. func (w *huffmanBitWriter) indexTokens(tokens []token) (numLiterals, numOffsets int) { … } // writeTokens writes a slice of tokens to the output. // codes for literal and offset encoding must be supplied. func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode) { … } var huffOffset … func init() { … } // writeBlockHuff encodes a block of bytes as either // Huffman encoded literals or uncompressed bytes if the // results only gains very little from compression. func (w *huffmanBitWriter) writeBlockHuff(eof bool, input []byte) { … } // histogram accumulates a histogram of b in h. // // len(h) must be >= 256, and h's elements must be all zeroes. func histogram(b []byte, h []int32) { … }