vendor.github.com.andybalholm.brotli.encode.go Maven / Gradle / Ivy
The newest version!
package brotli
import (
"io"
"math"
)
/* Copyright 2016 Google Inc. All Rights Reserved.
Distributed under MIT license.
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/
/** Minimal value for ::BROTLI_PARAM_LGWIN parameter. */
const minWindowBits = 10
/**
* Maximal value for ::BROTLI_PARAM_LGWIN parameter.
*
* @note equal to @c BROTLI_MAX_DISTANCE_BITS constant.
*/
const maxWindowBits = 24
/**
* Maximal value for ::BROTLI_PARAM_LGWIN parameter
* in "Large Window Brotli" (32-bit).
*/
const largeMaxWindowBits = 30
/** Minimal value for ::BROTLI_PARAM_LGBLOCK parameter. */
const minInputBlockBits = 16
/** Maximal value for ::BROTLI_PARAM_LGBLOCK parameter. */
const maxInputBlockBits = 24
/** Minimal value for ::BROTLI_PARAM_QUALITY parameter. */
const minQuality = 0
/** Maximal value for ::BROTLI_PARAM_QUALITY parameter. */
const maxQuality = 11
/** Options for ::BROTLI_PARAM_MODE parameter. */
const (
modeGeneric = 0
modeText = 1
modeFont = 2
)
/** Default value for ::BROTLI_PARAM_QUALITY parameter. */
const defaultQuality = 11
/** Default value for ::BROTLI_PARAM_LGWIN parameter. */
const defaultWindow = 22
/** Default value for ::BROTLI_PARAM_MODE parameter. */
const defaultMode = modeGeneric
/** Operations that can be performed by streaming encoder. */
const (
operationProcess = 0
operationFlush = 1
operationFinish = 2
operationEmitMetadata = 3
)
const (
streamProcessing = 0
streamFlushRequested = 1
streamFinished = 2
streamMetadataHead = 3
streamMetadataBody = 4
)
type Writer struct {
dst io.Writer
options WriterOptions
err error
params encoderParams
hasher_ hasherHandle
input_pos_ uint64
ringbuffer_ ringBuffer
commands []command
num_literals_ uint
last_insert_len_ uint
last_flush_pos_ uint64
last_processed_pos_ uint64
dist_cache_ [numDistanceShortCodes]int
saved_dist_cache_ [4]int
last_bytes_ uint16
last_bytes_bits_ byte
prev_byte_ byte
prev_byte2_ byte
storage []byte
small_table_ [1 << 10]int
large_table_ []int
large_table_size_ uint
cmd_depths_ [128]byte
cmd_bits_ [128]uint16
cmd_code_ [512]byte
cmd_code_numbits_ uint
command_buf_ []uint32
literal_buf_ []byte
tiny_buf_ struct {
u64 [2]uint64
u8 [16]byte
}
remaining_metadata_bytes_ uint32
stream_state_ int
is_last_block_emitted_ bool
is_initialized_ bool
}
func inputBlockSize(s *Writer) uint {
return uint(1) << uint(s.params.lgblock)
}
func unprocessedInputSize(s *Writer) uint64 {
return s.input_pos_ - s.last_processed_pos_
}
func remainingInputBlockSize(s *Writer) uint {
var delta uint64 = unprocessedInputSize(s)
var block_size uint = inputBlockSize(s)
if delta >= uint64(block_size) {
return 0
}
return block_size - uint(delta)
}
/* Wraps 64-bit input position to 32-bit ring-buffer position preserving
"not-a-first-lap" feature. */
func wrapPosition(position uint64) uint32 {
var result uint32 = uint32(position)
var gb uint64 = position >> 30
if gb > 2 {
/* Wrap every 2GiB; The first 3GB are continuous. */
result = result&((1<<30)-1) | (uint32((gb-1)&1)+1)<<30
}
return result
}
func (s *Writer) getStorage(size int) []byte {
if len(s.storage) < size {
s.storage = make([]byte, size)
}
return s.storage
}
func hashTableSize(max_table_size uint, input_size uint) uint {
var htsize uint = 256
for htsize < max_table_size && htsize < input_size {
htsize <<= 1
}
return htsize
}
func getHashTable(s *Writer, quality int, input_size uint, table_size *uint) []int {
var max_table_size uint = maxHashTableSize(quality)
var htsize uint = hashTableSize(max_table_size, input_size)
/* Use smaller hash table when input.size() is smaller, since we
fill the table, incurring O(hash table size) overhead for
compression, and if the input is short, we won't need that
many hash table entries anyway. */
var table []int
assert(max_table_size >= 256)
if quality == fastOnePassCompressionQuality {
/* Only odd shifts are supported by fast-one-pass. */
if htsize&0xAAAAA == 0 {
htsize <<= 1
}
}
if htsize <= uint(len(s.small_table_)) {
table = s.small_table_[:]
} else {
if htsize > s.large_table_size_ {
s.large_table_size_ = htsize
s.large_table_ = nil
s.large_table_ = make([]int, htsize)
}
table = s.large_table_
}
*table_size = htsize
for i := 0; i < int(htsize); i++ {
table[i] = 0
}
return table
}
func encodeWindowBits(lgwin int, large_window bool, last_bytes *uint16, last_bytes_bits *byte) {
if large_window {
*last_bytes = uint16((lgwin&0x3F)<<8 | 0x11)
*last_bytes_bits = 14
} else {
if lgwin == 16 {
*last_bytes = 0
*last_bytes_bits = 1
} else if lgwin == 17 {
*last_bytes = 1
*last_bytes_bits = 7
} else if lgwin > 17 {
*last_bytes = uint16((lgwin-17)<<1 | 0x01)
*last_bytes_bits = 4
} else {
*last_bytes = uint16((lgwin-8)<<4 | 0x01)
*last_bytes_bits = 7
}
}
}
/* Decide about the context map based on the ability of the prediction
ability of the previous byte UTF8-prefix on the next byte. The
prediction ability is calculated as Shannon entropy. Here we need
Shannon entropy instead of 'BitsEntropy' since the prefix will be
encoded with the remaining 6 bits of the following byte, and
BitsEntropy will assume that symbol to be stored alone using Huffman
coding. */
var kStaticContextMapContinuation = [64]uint32{
1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
}
var kStaticContextMapSimpleUTF8 = [64]uint32{
0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
}
func chooseContextMap(quality int, bigram_histo []uint32, num_literal_contexts *uint, literal_context_map *[]uint32) {
var monogram_histo = [3]uint32{0}
var two_prefix_histo = [6]uint32{0}
var total uint
var i uint
var dummy uint
var entropy [4]float64
for i = 0; i < 9; i++ {
monogram_histo[i%3] += bigram_histo[i]
two_prefix_histo[i%6] += bigram_histo[i]
}
entropy[1] = shannonEntropy(monogram_histo[:], 3, &dummy)
entropy[2] = (shannonEntropy(two_prefix_histo[:], 3, &dummy) + shannonEntropy(two_prefix_histo[3:], 3, &dummy))
entropy[3] = 0
for i = 0; i < 3; i++ {
entropy[3] += shannonEntropy(bigram_histo[3*i:], 3, &dummy)
}
total = uint(monogram_histo[0] + monogram_histo[1] + monogram_histo[2])
assert(total != 0)
entropy[0] = 1.0 / float64(total)
entropy[1] *= entropy[0]
entropy[2] *= entropy[0]
entropy[3] *= entropy[0]
if quality < minQualityForHqContextModeling {
/* 3 context models is a bit slower, don't use it at lower qualities. */
entropy[3] = entropy[1] * 10
}
/* If expected savings by symbol are less than 0.2 bits, skip the
context modeling -- in exchange for faster decoding speed. */
if entropy[1]-entropy[2] < 0.2 && entropy[1]-entropy[3] < 0.2 {
*num_literal_contexts = 1
} else if entropy[2]-entropy[3] < 0.02 {
*num_literal_contexts = 2
*literal_context_map = kStaticContextMapSimpleUTF8[:]
} else {
*num_literal_contexts = 3
*literal_context_map = kStaticContextMapContinuation[:]
}
}
/* Decide if we want to use a more complex static context map containing 13
context values, based on the entropy reduction of histograms over the
first 5 bits of literals. */
var kStaticContextMapComplexUTF8 = [64]uint32{
11, 11, 12, 12, /* 0 special */
0, 0, 0, 0, /* 4 lf */
1, 1, 9, 9, /* 8 space */
2, 2, 2, 2, /* !, first after space/lf and after something else. */
1, 1, 1, 1, /* " */
8, 3, 3, 3, /* % */
1, 1, 1, 1, /* ({[ */
2, 2, 2, 2, /* }]) */
8, 4, 4, 4, /* :; */
8, 7, 4, 4, /* . */
8, 0, 0, 0, /* > */
3, 3, 3, 3, /* [0..9] */
5, 5, 10, 5, /* [A-Z] */
5, 5, 10, 5,
6, 6, 6, 6, /* [a-z] */
6, 6, 6, 6,
}
func shouldUseComplexStaticContextMap(input []byte, start_pos uint, length uint, mask uint, quality int, size_hint uint, num_literal_contexts *uint, literal_context_map *[]uint32) bool {
/* Try the more complex static context map only for long data. */
if size_hint < 1<<20 {
return false
} else {
var end_pos uint = start_pos + length
var combined_histo = [32]uint32{0}
var context_histo = [13][32]uint32{[32]uint32{0}}
var total uint32 = 0
var entropy [3]float64
var dummy uint
var i uint
var utf8_lut contextLUT = getContextLUT(contextUTF8)
/* To make entropy calculations faster and to fit on the stack, we collect
histograms over the 5 most significant bits of literals. One histogram
without context and 13 additional histograms for each context value. */
for ; start_pos+64 <= end_pos; start_pos += 4096 {
var stride_end_pos uint = start_pos + 64
var prev2 byte = input[start_pos&mask]
var prev1 byte = input[(start_pos+1)&mask]
var pos uint
/* To make the analysis of the data faster we only examine 64 byte long
strides at every 4kB intervals. */
for pos = start_pos + 2; pos < stride_end_pos; pos++ {
var literal byte = input[pos&mask]
var context byte = byte(kStaticContextMapComplexUTF8[getContext(prev1, prev2, utf8_lut)])
total++
combined_histo[literal>>3]++
context_histo[context][literal>>3]++
prev2 = prev1
prev1 = literal
}
}
entropy[1] = shannonEntropy(combined_histo[:], 32, &dummy)
entropy[2] = 0
for i = 0; i < 13; i++ {
entropy[2] += shannonEntropy(context_histo[i][0:], 32, &dummy)
}
entropy[0] = 1.0 / float64(total)
entropy[1] *= entropy[0]
entropy[2] *= entropy[0]
/* The triggering heuristics below were tuned by compressing the individual
files of the silesia corpus. If we skip this kind of context modeling
for not very well compressible input (i.e. entropy using context modeling
is 60% of maximal entropy) or if expected savings by symbol are less
than 0.2 bits, then in every case when it triggers, the final compression
ratio is improved. Note however that this heuristics might be too strict
for some cases and could be tuned further. */
if entropy[2] > 3.0 || entropy[1]-entropy[2] < 0.2 {
return false
} else {
*num_literal_contexts = 13
*literal_context_map = kStaticContextMapComplexUTF8[:]
return true
}
}
}
func decideOverLiteralContextModeling(input []byte, start_pos uint, length uint, mask uint, quality int, size_hint uint, num_literal_contexts *uint, literal_context_map *[]uint32) {
if quality < minQualityForContextModeling || length < 64 {
return
} else if shouldUseComplexStaticContextMap(input, start_pos, length, mask, quality, size_hint, num_literal_contexts, literal_context_map) {
} else /* Context map was already set, nothing else to do. */
{
var end_pos uint = start_pos + length
/* Gather bi-gram data of the UTF8 byte prefixes. To make the analysis of
UTF8 data faster we only examine 64 byte long strides at every 4kB
intervals. */
var bigram_prefix_histo = [9]uint32{0}
for ; start_pos+64 <= end_pos; start_pos += 4096 {
var lut = [4]int{0, 0, 1, 2}
var stride_end_pos uint = start_pos + 64
var prev int = lut[input[start_pos&mask]>>6] * 3
var pos uint
for pos = start_pos + 1; pos < stride_end_pos; pos++ {
var literal byte = input[pos&mask]
bigram_prefix_histo[prev+lut[literal>>6]]++
prev = lut[literal>>6] * 3
}
}
chooseContextMap(quality, bigram_prefix_histo[0:], num_literal_contexts, literal_context_map)
}
}
func shouldCompress_encode(data []byte, mask uint, last_flush_pos uint64, bytes uint, num_literals uint, num_commands uint) bool {
/* TODO: find more precise minimal block overhead. */
if bytes <= 2 {
return false
}
if num_commands < (bytes>>8)+2 {
if float64(num_literals) > 0.99*float64(bytes) {
var literal_histo = [256]uint32{0}
const kSampleRate uint32 = 13
const kMinEntropy float64 = 7.92
var bit_cost_threshold float64 = float64(bytes) * kMinEntropy / float64(kSampleRate)
var t uint = uint((uint32(bytes) + kSampleRate - 1) / kSampleRate)
var pos uint32 = uint32(last_flush_pos)
var i uint
for i = 0; i < t; i++ {
literal_histo[data[pos&uint32(mask)]]++
pos += kSampleRate
}
if bitsEntropy(literal_histo[:], 256) > bit_cost_threshold {
return false
}
}
}
return true
}
/* Chooses the literal context mode for a metablock */
func chooseContextMode(params *encoderParams, data []byte, pos uint, mask uint, length uint) int {
/* We only do the computation for the option of something else than
CONTEXT_UTF8 for the highest qualities */
if params.quality >= minQualityForHqBlockSplitting && !isMostlyUTF8(data, pos, mask, length, kMinUTF8Ratio) {
return contextSigned
}
return contextUTF8
}
func writeMetaBlockInternal(data []byte, mask uint, last_flush_pos uint64, bytes uint, is_last bool, literal_context_mode int, params *encoderParams, prev_byte byte, prev_byte2 byte, num_literals uint, commands []command, saved_dist_cache []int, dist_cache []int, storage_ix *uint, storage []byte) {
var wrapped_last_flush_pos uint32 = wrapPosition(last_flush_pos)
var last_bytes uint16
var last_bytes_bits byte
var literal_context_lut contextLUT = getContextLUT(literal_context_mode)
var block_params encoderParams = *params
if bytes == 0 {
/* Write the ISLAST and ISEMPTY bits. */
writeBits(2, 3, storage_ix, storage)
*storage_ix = (*storage_ix + 7) &^ 7
return
}
if !shouldCompress_encode(data, mask, last_flush_pos, bytes, num_literals, uint(len(commands))) {
/* Restore the distance cache, as its last update by
CreateBackwardReferences is now unused. */
copy(dist_cache, saved_dist_cache[:4])
storeUncompressedMetaBlock(is_last, data, uint(wrapped_last_flush_pos), mask, bytes, storage_ix, storage)
return
}
assert(*storage_ix <= 14)
last_bytes = uint16(storage[1])<<8 | uint16(storage[0])
last_bytes_bits = byte(*storage_ix)
if params.quality <= maxQualityForStaticEntropyCodes {
storeMetaBlockFast(data, uint(wrapped_last_flush_pos), bytes, mask, is_last, params, commands, storage_ix, storage)
} else if params.quality < minQualityForBlockSplit {
storeMetaBlockTrivial(data, uint(wrapped_last_flush_pos), bytes, mask, is_last, params, commands, storage_ix, storage)
} else {
mb := getMetaBlockSplit()
if params.quality < minQualityForHqBlockSplitting {
var num_literal_contexts uint = 1
var literal_context_map []uint32 = nil
if !params.disable_literal_context_modeling {
decideOverLiteralContextModeling(data, uint(wrapped_last_flush_pos), bytes, mask, params.quality, params.size_hint, &num_literal_contexts, &literal_context_map)
}
buildMetaBlockGreedy(data, uint(wrapped_last_flush_pos), mask, prev_byte, prev_byte2, literal_context_lut, num_literal_contexts, literal_context_map, commands, mb)
} else {
buildMetaBlock(data, uint(wrapped_last_flush_pos), mask, &block_params, prev_byte, prev_byte2, commands, literal_context_mode, mb)
}
if params.quality >= minQualityForOptimizeHistograms {
/* The number of distance symbols effectively used for distance
histograms. It might be less than distance alphabet size
for "Large Window Brotli" (32-bit). */
var num_effective_dist_codes uint32 = block_params.dist.alphabet_size
if num_effective_dist_codes > numHistogramDistanceSymbols {
num_effective_dist_codes = numHistogramDistanceSymbols
}
optimizeHistograms(num_effective_dist_codes, mb)
}
storeMetaBlock(data, uint(wrapped_last_flush_pos), bytes, mask, prev_byte, prev_byte2, is_last, &block_params, literal_context_mode, commands, mb, storage_ix, storage)
freeMetaBlockSplit(mb)
}
if bytes+4 < *storage_ix>>3 {
/* Restore the distance cache and last byte. */
copy(dist_cache, saved_dist_cache[:4])
storage[0] = byte(last_bytes)
storage[1] = byte(last_bytes >> 8)
*storage_ix = uint(last_bytes_bits)
storeUncompressedMetaBlock(is_last, data, uint(wrapped_last_flush_pos), mask, bytes, storage_ix, storage)
}
}
func chooseDistanceParams(params *encoderParams) {
var distance_postfix_bits uint32 = 0
var num_direct_distance_codes uint32 = 0
if params.quality >= minQualityForNonzeroDistanceParams {
var ndirect_msb uint32
if params.mode == modeFont {
distance_postfix_bits = 1
num_direct_distance_codes = 12
} else {
distance_postfix_bits = params.dist.distance_postfix_bits
num_direct_distance_codes = params.dist.num_direct_distance_codes
}
ndirect_msb = (num_direct_distance_codes >> distance_postfix_bits) & 0x0F
if distance_postfix_bits > maxNpostfix || num_direct_distance_codes > maxNdirect || ndirect_msb<>25)), (last_command.dist_prefix_&0x3FF == 0), &last_command.cmd_prefix_)
}
}
/*
Processes the accumulated input data and writes
the new output meta-block to s.dest, if one has been
created (otherwise the processed input data is buffered internally).
If |is_last| or |force_flush| is true, an output meta-block is
always created. However, until |is_last| is true encoder may retain up
to 7 bits of the last byte of output. To force encoder to dump the remaining
bits use WriteMetadata() to append an empty meta-data block.
Returns false if the size of the input data is larger than
input_block_size().
*/
func encodeData(s *Writer, is_last bool, force_flush bool) bool {
var delta uint64 = unprocessedInputSize(s)
var bytes uint32 = uint32(delta)
var wrapped_last_processed_pos uint32 = wrapPosition(s.last_processed_pos_)
var data []byte
var mask uint32
var literal_context_mode int
data = s.ringbuffer_.buffer_
mask = s.ringbuffer_.mask_
/* Adding more blocks after "last" block is forbidden. */
if s.is_last_block_emitted_ {
return false
}
if is_last {
s.is_last_block_emitted_ = true
}
if delta > uint64(inputBlockSize(s)) {
return false
}
if s.params.quality == fastTwoPassCompressionQuality {
if s.command_buf_ == nil || cap(s.command_buf_) < int(kCompressFragmentTwoPassBlockSize) {
s.command_buf_ = make([]uint32, kCompressFragmentTwoPassBlockSize)
s.literal_buf_ = make([]byte, kCompressFragmentTwoPassBlockSize)
} else {
s.command_buf_ = s.command_buf_[:kCompressFragmentTwoPassBlockSize]
s.literal_buf_ = s.literal_buf_[:kCompressFragmentTwoPassBlockSize]
}
}
if s.params.quality == fastOnePassCompressionQuality || s.params.quality == fastTwoPassCompressionQuality {
var storage []byte
var storage_ix uint = uint(s.last_bytes_bits_)
var table_size uint
var table []int
if delta == 0 && !is_last {
/* We have no new input data and we don't have to finish the stream, so
nothing to do. */
return true
}
storage = s.getStorage(int(2*bytes + 503))
storage[0] = byte(s.last_bytes_)
storage[1] = byte(s.last_bytes_ >> 8)
table = getHashTable(s, s.params.quality, uint(bytes), &table_size)
if s.params.quality == fastOnePassCompressionQuality {
compressFragmentFast(data[wrapped_last_processed_pos&mask:], uint(bytes), is_last, table, table_size, s.cmd_depths_[:], s.cmd_bits_[:], &s.cmd_code_numbits_, s.cmd_code_[:], &storage_ix, storage)
} else {
compressFragmentTwoPass(data[wrapped_last_processed_pos&mask:], uint(bytes), is_last, s.command_buf_, s.literal_buf_, table, table_size, &storage_ix, storage)
}
s.last_bytes_ = uint16(storage[storage_ix>>3])
s.last_bytes_bits_ = byte(storage_ix & 7)
updateLastProcessedPos(s)
s.writeOutput(storage[:storage_ix>>3])
return true
}
{
/* Theoretical max number of commands is 1 per 2 bytes. */
newsize := len(s.commands) + int(bytes)/2 + 1
if newsize > cap(s.commands) {
/* Reserve a bit more memory to allow merging with a next block
without reallocation: that would impact speed. */
newsize += int(bytes/4) + 16
new_commands := make([]command, len(s.commands), newsize)
if s.commands != nil {
copy(new_commands, s.commands)
}
s.commands = new_commands
}
}
initOrStitchToPreviousBlock(&s.hasher_, data, uint(mask), &s.params, uint(wrapped_last_processed_pos), uint(bytes), is_last)
literal_context_mode = chooseContextMode(&s.params, data, uint(wrapPosition(s.last_flush_pos_)), uint(mask), uint(s.input_pos_-s.last_flush_pos_))
if len(s.commands) != 0 && s.last_insert_len_ == 0 {
extendLastCommand(s, &bytes, &wrapped_last_processed_pos)
}
if s.params.quality == zopflificationQuality {
assert(s.params.hasher.type_ == 10)
createZopfliBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_.(*h10), s.dist_cache_[:], &s.last_insert_len_, &s.commands, &s.num_literals_)
} else if s.params.quality == hqZopflificationQuality {
assert(s.params.hasher.type_ == 10)
createHqZopfliBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_, s.dist_cache_[:], &s.last_insert_len_, &s.commands, &s.num_literals_)
} else {
createBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_, s.dist_cache_[:], &s.last_insert_len_, &s.commands, &s.num_literals_)
}
{
var max_length uint = maxMetablockSize(&s.params)
var max_literals uint = max_length / 8
max_commands := int(max_length / 8)
var processed_bytes uint = uint(s.input_pos_ - s.last_flush_pos_)
var next_input_fits_metablock bool = (processed_bytes+inputBlockSize(s) <= max_length)
var should_flush bool = (s.params.quality < minQualityForBlockSplit && s.num_literals_+uint(len(s.commands)) >= maxNumDelayedSymbols)
/* If maximal possible additional block doesn't fit metablock, flush now. */
/* TODO: Postpone decision until next block arrives? */
/* If block splitting is not used, then flush as soon as there is some
amount of commands / literals produced. */
if !is_last && !force_flush && !should_flush && next_input_fits_metablock && s.num_literals_ < max_literals && len(s.commands) < max_commands {
/* Merge with next input block. Everything will happen later. */
if updateLastProcessedPos(s) {
hasherReset(s.hasher_)
}
return true
}
}
/* Create the last insert-only command. */
if s.last_insert_len_ > 0 {
s.commands = append(s.commands, makeInsertCommand(s.last_insert_len_))
s.num_literals_ += s.last_insert_len_
s.last_insert_len_ = 0
}
if !is_last && s.input_pos_ == s.last_flush_pos_ {
/* We have no new input data and we don't have to finish the stream, so
nothing to do. */
return true
}
assert(s.input_pos_ >= s.last_flush_pos_)
assert(s.input_pos_ > s.last_flush_pos_ || is_last)
assert(s.input_pos_-s.last_flush_pos_ <= 1<<24)
{
var metablock_size uint32 = uint32(s.input_pos_ - s.last_flush_pos_)
var storage []byte = s.getStorage(int(2*metablock_size + 503))
var storage_ix uint = uint(s.last_bytes_bits_)
storage[0] = byte(s.last_bytes_)
storage[1] = byte(s.last_bytes_ >> 8)
writeMetaBlockInternal(data, uint(mask), s.last_flush_pos_, uint(metablock_size), is_last, literal_context_mode, &s.params, s.prev_byte_, s.prev_byte2_, s.num_literals_, s.commands, s.saved_dist_cache_[:], s.dist_cache_[:], &storage_ix, storage)
s.last_bytes_ = uint16(storage[storage_ix>>3])
s.last_bytes_bits_ = byte(storage_ix & 7)
s.last_flush_pos_ = s.input_pos_
if updateLastProcessedPos(s) {
hasherReset(s.hasher_)
}
if s.last_flush_pos_ > 0 {
s.prev_byte_ = data[(uint32(s.last_flush_pos_)-1)&mask]
}
if s.last_flush_pos_ > 1 {
s.prev_byte2_ = data[uint32(s.last_flush_pos_-2)&mask]
}
s.commands = s.commands[:0]
s.num_literals_ = 0
/* Save the state of the distance cache in case we need to restore it for
emitting an uncompressed block. */
copy(s.saved_dist_cache_[:], s.dist_cache_[:])
s.writeOutput(storage[:storage_ix>>3])
return true
}
}
/* Dumps remaining output bits and metadata header to |header|.
Returns number of produced bytes.
REQUIRED: |header| should be 8-byte aligned and at least 16 bytes long.
REQUIRED: |block_size| <= (1 << 24). */
func writeMetadataHeader(s *Writer, block_size uint, header []byte) uint {
storage_ix := uint(s.last_bytes_bits_)
header[0] = byte(s.last_bytes_)
header[1] = byte(s.last_bytes_ >> 8)
s.last_bytes_ = 0
s.last_bytes_bits_ = 0
writeBits(1, 0, &storage_ix, header)
writeBits(2, 3, &storage_ix, header)
writeBits(1, 0, &storage_ix, header)
if block_size == 0 {
writeBits(2, 0, &storage_ix, header)
} else {
var nbits uint32
if block_size == 1 {
nbits = 0
} else {
nbits = log2FloorNonZero(uint(uint32(block_size)-1)) + 1
}
var nbytes uint32 = (nbits + 7) / 8
writeBits(2, uint64(nbytes), &storage_ix, header)
writeBits(uint(8*nbytes), uint64(block_size)-1, &storage_ix, header)
}
return (storage_ix + 7) >> 3
}
func injectBytePaddingBlock(s *Writer) {
var seal uint32 = uint32(s.last_bytes_)
var seal_bits uint = uint(s.last_bytes_bits_)
s.last_bytes_ = 0
s.last_bytes_bits_ = 0
/* is_last = 0, data_nibbles = 11, reserved = 0, meta_nibbles = 00 */
seal |= 0x6 << seal_bits
seal_bits += 6
destination := s.tiny_buf_.u8[:]
destination[0] = byte(seal)
if seal_bits > 8 {
destination[1] = byte(seal >> 8)
}
if seal_bits > 16 {
destination[2] = byte(seal >> 16)
}
s.writeOutput(destination[:(seal_bits+7)>>3])
}
func checkFlushComplete(s *Writer) {
if s.stream_state_ == streamFlushRequested && s.err == nil {
s.stream_state_ = streamProcessing
}
}
func encoderCompressStreamFast(s *Writer, op int, available_in *uint, next_in *[]byte) bool {
var block_size_limit uint = uint(1) << s.params.lgwin
var buf_size uint = brotli_min_size_t(kCompressFragmentTwoPassBlockSize, brotli_min_size_t(*available_in, block_size_limit))
var command_buf []uint32 = nil
var literal_buf []byte = nil
if s.params.quality != fastOnePassCompressionQuality && s.params.quality != fastTwoPassCompressionQuality {
return false
}
if s.params.quality == fastTwoPassCompressionQuality {
if s.command_buf_ == nil || cap(s.command_buf_) < int(buf_size) {
s.command_buf_ = make([]uint32, buf_size)
s.literal_buf_ = make([]byte, buf_size)
} else {
s.command_buf_ = s.command_buf_[:buf_size]
s.literal_buf_ = s.literal_buf_[:buf_size]
}
command_buf = s.command_buf_
literal_buf = s.literal_buf_
}
for {
if s.stream_state_ == streamFlushRequested && s.last_bytes_bits_ != 0 {
injectBytePaddingBlock(s)
continue
}
/* Compress block only when stream is not
finished, there is no pending flush request, and there is either
additional input or pending operation. */
if s.stream_state_ == streamProcessing && (*available_in != 0 || op != int(operationProcess)) {
var block_size uint = brotli_min_size_t(block_size_limit, *available_in)
var is_last bool = (*available_in == block_size) && (op == int(operationFinish))
var force_flush bool = (*available_in == block_size) && (op == int(operationFlush))
var max_out_size uint = 2*block_size + 503
var storage []byte = nil
var storage_ix uint = uint(s.last_bytes_bits_)
var table_size uint
var table []int
if force_flush && block_size == 0 {
s.stream_state_ = streamFlushRequested
continue
}
storage = s.getStorage(int(max_out_size))
storage[0] = byte(s.last_bytes_)
storage[1] = byte(s.last_bytes_ >> 8)
table = getHashTable(s, s.params.quality, block_size, &table_size)
if s.params.quality == fastOnePassCompressionQuality {
compressFragmentFast(*next_in, block_size, is_last, table, table_size, s.cmd_depths_[:], s.cmd_bits_[:], &s.cmd_code_numbits_, s.cmd_code_[:], &storage_ix, storage)
} else {
compressFragmentTwoPass(*next_in, block_size, is_last, command_buf, literal_buf, table, table_size, &storage_ix, storage)
}
*next_in = (*next_in)[block_size:]
*available_in -= block_size
var out_bytes uint = storage_ix >> 3
s.writeOutput(storage[:out_bytes])
s.last_bytes_ = uint16(storage[storage_ix>>3])
s.last_bytes_bits_ = byte(storage_ix & 7)
if force_flush {
s.stream_state_ = streamFlushRequested
}
if is_last {
s.stream_state_ = streamFinished
}
continue
}
break
}
checkFlushComplete(s)
return true
}
func processMetadata(s *Writer, available_in *uint, next_in *[]byte) bool {
if *available_in > 1<<24 {
return false
}
/* Switch to metadata block workflow, if required. */
if s.stream_state_ == streamProcessing {
s.remaining_metadata_bytes_ = uint32(*available_in)
s.stream_state_ = streamMetadataHead
}
if s.stream_state_ != streamMetadataHead && s.stream_state_ != streamMetadataBody {
return false
}
for {
if s.stream_state_ == streamFlushRequested && s.last_bytes_bits_ != 0 {
injectBytePaddingBlock(s)
continue
}
if s.input_pos_ != s.last_flush_pos_ {
var result bool = encodeData(s, false, true)
if !result {
return false
}
continue
}
if s.stream_state_ == streamMetadataHead {
n := writeMetadataHeader(s, uint(s.remaining_metadata_bytes_), s.tiny_buf_.u8[:])
s.writeOutput(s.tiny_buf_.u8[:n])
s.stream_state_ = streamMetadataBody
continue
} else {
/* Exit workflow only when there is no more input and no more output.
Otherwise client may continue producing empty metadata blocks. */
if s.remaining_metadata_bytes_ == 0 {
s.remaining_metadata_bytes_ = math.MaxUint32
s.stream_state_ = streamProcessing
break
}
/* This guarantees progress in "TakeOutput" workflow. */
var c uint32 = brotli_min_uint32_t(s.remaining_metadata_bytes_, 16)
copy(s.tiny_buf_.u8[:], (*next_in)[:c])
*next_in = (*next_in)[c:]
*available_in -= uint(c)
s.remaining_metadata_bytes_ -= c
s.writeOutput(s.tiny_buf_.u8[:c])
continue
}
}
return true
}
func updateSizeHint(s *Writer, available_in uint) {
if s.params.size_hint == 0 {
var delta uint64 = unprocessedInputSize(s)
var tail uint64 = uint64(available_in)
var limit uint32 = 1 << 30
var total uint32
if (delta >= uint64(limit)) || (tail >= uint64(limit)) || ((delta + tail) >= uint64(limit)) {
total = limit
} else {
total = uint32(delta + tail)
}
s.params.size_hint = uint(total)
}
}
func encoderCompressStream(s *Writer, op int, available_in *uint, next_in *[]byte) bool {
if !ensureInitialized(s) {
return false
}
/* Unfinished metadata block; check requirements. */
if s.remaining_metadata_bytes_ != math.MaxUint32 {
if uint32(*available_in) != s.remaining_metadata_bytes_ {
return false
}
if op != int(operationEmitMetadata) {
return false
}
}
if op == int(operationEmitMetadata) {
updateSizeHint(s, 0) /* First data metablock might be emitted here. */
return processMetadata(s, available_in, next_in)
}
if s.stream_state_ == streamMetadataHead || s.stream_state_ == streamMetadataBody {
return false
}
if s.stream_state_ != streamProcessing && *available_in != 0 {
return false
}
if s.params.quality == fastOnePassCompressionQuality || s.params.quality == fastTwoPassCompressionQuality {
return encoderCompressStreamFast(s, op, available_in, next_in)
}
for {
var remaining_block_size uint = remainingInputBlockSize(s)
if remaining_block_size != 0 && *available_in != 0 {
var copy_input_size uint = brotli_min_size_t(remaining_block_size, *available_in)
copyInputToRingBuffer(s, copy_input_size, *next_in)
*next_in = (*next_in)[copy_input_size:]
*available_in -= copy_input_size
continue
}
if s.stream_state_ == streamFlushRequested && s.last_bytes_bits_ != 0 {
injectBytePaddingBlock(s)
continue
}
/* Compress data only when stream is not
finished and there is no pending flush request. */
if s.stream_state_ == streamProcessing {
if remaining_block_size == 0 || op != int(operationProcess) {
var is_last bool = ((*available_in == 0) && op == int(operationFinish))
var force_flush bool = ((*available_in == 0) && op == int(operationFlush))
var result bool
updateSizeHint(s, *available_in)
result = encodeData(s, is_last, force_flush)
if !result {
return false
}
if force_flush {
s.stream_state_ = streamFlushRequested
}
if is_last {
s.stream_state_ = streamFinished
}
continue
}
}
break
}
checkFlushComplete(s)
return true
}
func (w *Writer) writeOutput(data []byte) {
if w.err != nil {
return
}
_, w.err = w.dst.Write(data)
if w.err == nil {
checkFlushComplete(w)
}
}