mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Mirror BrotliEncoderPrepareDictionary (BROTLI_SHARED_DICTIONARY_RAW), CreatePreparedDictionary and BrotliEncoderAttachPreparedDictionary as encoder.add_dictionary, with the prepared hash tables (slot offsets, heads and items) in the workbuf after the dictionary bytes, and the compound dictionary search (FindCompoundDictionaryMatch and LookupCompoundDictionaryMatch) for the hashers whose CreateBackwardReferences variant enables it, the compound dictionary gap for static dictionary distances and the compound branch of ExtendLastCommand. Extend the encoder parity script with a -dict grid that also checks round trips through libbrotlidec and the Wuffs decoder.
1014 lines
41 KiB
Plaintext
1014 lines
41 KiB
Plaintext
// Copyright 2026 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// --------
|
|
|
|
// This file mirrors the parts of encode.c (and ringbuffer.h) that qualities 2
|
|
// to 9 use: the ring buffer, EncodeData, WriteMetaBlockInternal and the
|
|
// literal context modeling heuristics. It also computes the workbuf layout.
|
|
//
|
|
// The workbuf holds, in this order (see README.md's "Encoder Workbuf Layout"
|
|
// section, which compute_layout_offset mirrors):
|
|
// - the storage (the C code's GetBrotliStorage) for one metablock,
|
|
// - the hasher's memory (the C code's common->extra),
|
|
// - the commands (16 bytes each),
|
|
// - at qualities 4 and above, the metablock split (see
|
|
// encode_metablock_greedy.wuffs), the literal context map, the
|
|
// EncodeContextMap symbols and the block encoders' depths and bits, and
|
|
// - the ring buffer (the C code's RingBuffer.data_).
|
|
|
|
// The workbuf layout's region indexes. LAYOUT_END's offset is the total
|
|
// length.
|
|
// The ring buffer is last, so that a workbuf shorter than workbuf_len works
|
|
// for short inputs (see transform_io's rb_short_workbuf check).
|
|
pri const LAYOUT_STORAGE : base.u32 = 0
|
|
pri const LAYOUT_HASH : base.u32 = 1
|
|
pri const LAYOUT_CMDS : base.u32 = 2
|
|
pri const LAYOUT_TYPES_0 : base.u32 = 3
|
|
pri const LAYOUT_LENGTHS_0 : base.u32 = 6
|
|
pri const LAYOUT_HISTO_0 : base.u32 = 9
|
|
pri const LAYOUT_COMB : base.u32 = 12
|
|
pri const LAYOUT_CMAP : base.u32 = 13
|
|
pri const LAYOUT_RLE : base.u32 = 14
|
|
pri const LAYOUT_BE_DEPTH_0 : base.u32 = 15
|
|
pri const LAYOUT_BE_BITS_0 : base.u32 = 18
|
|
pri const LAYOUT_RB : base.u32 = 21
|
|
pri const LAYOUT_END : base.u32 = 22
|
|
|
|
// RB_SHORT_SLACK is how many bytes past the input's end (in the ring buffer)
|
|
// a short workbuf must have: the C code reads at most 7 bytes past the
|
|
// input's end (its kSlackForEightByteHashingEverywhere), rounded up.
|
|
pri const RB_SHORT_SLACK : base.u64 = 16
|
|
|
|
// The C code's MAX_NUM_DELAYED_SYMBOLS (in quality.h).
|
|
pri const MAX_NUM_DELAYED_SYMBOLS : base.u64 = 0x2FFF
|
|
|
|
// The doubles 0.99, 7.92, 1.0 / 13.0, 1.0, 10.0, 0.2, 0.02 and 3.0.
|
|
pri const F64_0_99 : base.u64 = 0x3FEF_AE14_7AE1_47AE
|
|
pri const F64_7_92 : base.u64 = 0x401F_AE14_7AE1_47AE
|
|
pri const F64_INV_13 : base.u64 = 0x3FB3_B13B_13B1_3B14
|
|
pri const F64_1 : base.u64 = 0x3FF0_0000_0000_0000
|
|
pri const F64_10 : base.u64 = 0x4024_0000_0000_0000
|
|
pri const F64_0_2 : base.u64 = 0x3FC9_9999_9999_999A
|
|
pri const F64_0_02 : base.u64 = 0x3F94_7AE1_47AE_147B
|
|
pri const F64_3 : base.u64 = 0x4008_0000_0000_0000
|
|
|
|
// computed_lgblock mirrors ComputeLgBlock in quality.h.
|
|
pri func encoder.computed_lgblock(quality: base.u32[..= 11], lgwin: base.u32[..= 30]) base.u32[..= 30] {
|
|
var lgblock : base.u32
|
|
|
|
if args.quality <= 1 {
|
|
return args.lgwin
|
|
} else if args.quality < 4 {
|
|
return 14
|
|
} else if this.p_lgblock == 0 {
|
|
if (args.quality >= 9) and (args.lgwin > 16) {
|
|
return args.lgwin.min(no_more_than: 18)
|
|
}
|
|
return 16
|
|
}
|
|
lgblock = this.p_lgblock
|
|
if lgblock >= 0x8000_0000 {
|
|
// A negative (int) value.
|
|
lgblock = 16
|
|
}
|
|
return lgblock.max(no_less_than: 16).min(no_more_than: 24)
|
|
}
|
|
|
|
// rb_bits mirrors ComputeRbBits in quality.h.
|
|
pri func encoder.rb_bits(lgwin: base.u32[..= 30], lgblock: base.u32[..= 30]) base.u32[..= 31] {
|
|
return 1 + args.lgwin.max(no_less_than: args.lgblock)
|
|
}
|
|
|
|
// max_metablock_size mirrors MaxMetablockSize in quality.h.
|
|
pri func encoder.max_metablock_size(lgwin: base.u32[..= 30], lgblock: base.u32[..= 30]) base.u64 {
|
|
var b : base.u32[..= 31]
|
|
|
|
b = this.rb_bits(lgwin: args.lgwin, lgblock: args.lgblock)
|
|
return (1 as base.u64) << b.min(no_more_than: 24)
|
|
}
|
|
|
|
// hasher_total_size returns the sum of FN(HashMemAllocInBytes)'s
|
|
// alloc_size[i] for the hasher that ChooseHasher picks for the given
|
|
// quality, lgwin and size_hint (including, for lgwin above 24, the
|
|
// large-window composite hashers' rolling hasher table).
|
|
pri func encoder.hasher_total_size(quality: base.u32[..= 11], lgwin: base.u32[..= 30], size_hint: base.u32) base.u64 {
|
|
var htype : base.u32
|
|
var bucket_bits : base.u32[..= 24]
|
|
var block_bits : base.u32[..= 16]
|
|
var rolling : base.u64
|
|
|
|
if (args.quality == 4) and (args.size_hint >= 0x10_0000) {
|
|
htype = 54
|
|
} else if args.quality < 5 {
|
|
htype = args.quality
|
|
} else if args.lgwin <= 16 {
|
|
htype = 40
|
|
if args.quality >= 9 {
|
|
htype = 42
|
|
}
|
|
} else if (args.size_hint >= 0x10_0000) and (args.lgwin >= 19) {
|
|
htype = 6
|
|
if args.quality <= 6 {
|
|
htype = 68
|
|
}
|
|
bucket_bits = 15
|
|
block_bits = args.quality - 1
|
|
} else {
|
|
htype = 5
|
|
if args.quality <= 6 {
|
|
htype = 58
|
|
}
|
|
bucket_bits = 15
|
|
if args.quality < 7 {
|
|
bucket_bits = 14
|
|
}
|
|
block_bits = args.quality - 1
|
|
}
|
|
rolling = 0
|
|
if args.lgwin > 24 {
|
|
// The large-window composite hashers H35, H55 and H65 (see
|
|
// choose_hasher): HASHER_A plus the rolling hasher's table.
|
|
if (htype == 3) or (htype == 54) {
|
|
rolling = this.hasher_rolling_alloc_size()
|
|
} else if (htype == 6) or (htype == 68) {
|
|
htype = 6
|
|
rolling = this.hasher_rolling_alloc_size()
|
|
}
|
|
}
|
|
return ((this.hasher_alloc_size(htype: htype, bucket_bits: bucket_bits, block_bits: block_bits, i: 0) ~mod+
|
|
this.hasher_alloc_size(htype: htype, bucket_bits: bucket_bits, block_bits: block_bits, i: 1)) ~mod+
|
|
this.hasher_alloc_size(htype: htype, bucket_bits: bucket_bits, block_bits: block_bits, i: 2)) ~mod+
|
|
rolling
|
|
}
|
|
|
|
// hash_region_size returns the workbuf length reserved for the hasher's
|
|
// memory. When the size_hint parameter is unset (zero), the hasher choice
|
|
// depends on the size hint that UpdateSizeHint computes (from the input's
|
|
// length), so this is the larger of the two possible choices.
|
|
pri func encoder.hash_region_size(quality: base.u32[..= 11], lgwin: base.u32[..= 30]) base.u64 {
|
|
var a : base.u64
|
|
var b : base.u64
|
|
|
|
if this.p_size_hint <> 0 {
|
|
return this.hasher_total_size(quality: args.quality, lgwin: args.lgwin, size_hint: this.p_size_hint)
|
|
}
|
|
a = this.hasher_total_size(quality: args.quality, lgwin: args.lgwin, size_hint: 0)
|
|
b = this.hasher_total_size(quality: args.quality, lgwin: args.lgwin, size_hint: 0x10_0000)
|
|
return a.max(no_less_than: b)
|
|
}
|
|
|
|
// commands_capacity returns how many commands EncodeData can hold at once:
|
|
// at most one per two bytes of the metablock (plus the final insert-only
|
|
// command), and at most one per two bytes of an input block on top of those
|
|
// that EncodeData kept (merged with the next block), which is fewer than
|
|
// MaxMetablockSize / 8 (and, below quality 4, fewer than
|
|
// MAX_NUM_DELAYED_SYMBOLS).
|
|
pri func encoder.commands_capacity(quality: base.u32[..= 11], lgwin: base.u32[..= 30], lgblock: base.u32[..= 30]) base.u64 {
|
|
var max_len : base.u64
|
|
var prior : base.u64
|
|
|
|
max_len = this.max_metablock_size(lgwin: args.lgwin, lgblock: args.lgblock)
|
|
prior = (max_len / 8) ~mod- 1
|
|
if args.quality < 4 {
|
|
prior = prior.min(no_more_than: MAX_NUM_DELAYED_SYMBOLS - 1)
|
|
}
|
|
return this.min64(a: (prior ~mod+ (((1 as base.u64) << args.lgblock) / 2)) ~mod+ 1, b: (max_len / 2) + 1)
|
|
}
|
|
|
|
// compute_layout_offset returns the workbuf offset of the given LAYOUT_ETC
|
|
// region, for qualities 2 to 9.
|
|
pri func encoder.compute_layout_offset(quality: base.u32[..= 11], lgwin: base.u32[..= 30], lgblock: base.u32[..= 30], idx: base.u32) base.u64 {
|
|
var max_len : base.u64
|
|
var cmds_cap : base.u64
|
|
var off : base.u64
|
|
var i : base.u32
|
|
var size : base.u64
|
|
var num_histo : base.u64
|
|
var hlen : base.u64
|
|
|
|
max_len = this.max_metablock_size(lgwin: args.lgwin, lgblock: args.lgblock)
|
|
cmds_cap = this.commands_capacity(quality: args.quality, lgwin: args.lgwin, lgblock: args.lgblock)
|
|
off = 0
|
|
i = 0
|
|
while i < args.idx.min(no_more_than: LAYOUT_END) {
|
|
size = 0
|
|
if i == LAYOUT_STORAGE {
|
|
size = ((2 ~mod* max_len) ~mod+ 503) ~mod+ STORAGE_SLACK
|
|
} else if i == LAYOUT_RB {
|
|
size = ((2 + ((1 as base.u64) << this.rb_bits(lgwin: args.lgwin, lgblock: args.lgblock))) ~mod+
|
|
((1 as base.u64) << args.lgblock)) ~mod+ 7
|
|
} else if i == LAYOUT_HASH {
|
|
size = this.hash_region_size(quality: args.quality, lgwin: args.lgwin)
|
|
} else if i == LAYOUT_CMDS {
|
|
size = 16 ~mod* cmds_cap
|
|
} else if args.quality >= 4 {
|
|
if i == (LAYOUT_TYPES_0 + 0) {
|
|
size = (max_len / 512) + 1
|
|
} else if i == (LAYOUT_TYPES_0 + 1) {
|
|
size = (cmds_cap / 1024) ~mod+ 1
|
|
} else if i == (LAYOUT_TYPES_0 + 2) {
|
|
size = (cmds_cap / 512) ~mod+ 1
|
|
} else if i == (LAYOUT_LENGTHS_0 + 0) {
|
|
size = 4 * ((max_len / 512) + 1)
|
|
} else if i == (LAYOUT_LENGTHS_0 + 1) {
|
|
size = 4 ~mod* ((cmds_cap / 1024) ~mod+ 1)
|
|
} else if i == (LAYOUT_LENGTHS_0 + 2) {
|
|
size = 4 ~mod* ((cmds_cap / 512) ~mod+ 1)
|
|
} else if (LAYOUT_HISTO_0 <= i) and (i < (LAYOUT_HISTO_0 + 3)) {
|
|
// At most 260 literal histograms ((256 / 13) + 1 types of 13
|
|
// contexts each), 257 command histograms and 257 distance
|
|
// histograms.
|
|
if i == (LAYOUT_HISTO_0 + 0) {
|
|
size = 260 * 256 * 4
|
|
} else if i == (LAYOUT_HISTO_0 + 1) {
|
|
size = 257 * 704 * 4
|
|
} else {
|
|
size = 257 * 544 * 4
|
|
}
|
|
} else if i == LAYOUT_COMB {
|
|
size = 2 * 13 * 256 * 4
|
|
} else if i == LAYOUT_CMAP {
|
|
size = 256 * 64
|
|
} else if i == LAYOUT_RLE {
|
|
size = 256 * 64 * 4
|
|
} else if (LAYOUT_BE_DEPTH_0 <= i) and (i < (LAYOUT_BE_BITS_0 + 3)) {
|
|
// At most 256 histograms (types times contexts) per category.
|
|
num_histo = 256
|
|
hlen = 256
|
|
if (i == (LAYOUT_BE_DEPTH_0 + 1)) or (i == (LAYOUT_BE_BITS_0 + 1)) {
|
|
hlen = 704
|
|
} else if (i == (LAYOUT_BE_DEPTH_0 + 2)) or (i == (LAYOUT_BE_BITS_0 + 2)) {
|
|
hlen = 544
|
|
}
|
|
size = num_histo ~mod* hlen
|
|
if i >= LAYOUT_BE_BITS_0 {
|
|
size = 2 ~mod* size
|
|
}
|
|
}
|
|
}
|
|
off ~mod+= size
|
|
i ~mod+= 1
|
|
}
|
|
return off
|
|
}
|
|
|
|
// compute_layout sets the workbuf offsets (the this.etc_off fields) for the
|
|
// current parameters, at qualities 2 to 9.
|
|
pri func encoder.compute_layout!() {
|
|
var q : base.u32[..= 11]
|
|
var lw : base.u32[..= 30]
|
|
var lb : base.u32[..= 30]
|
|
var c : base.u32
|
|
|
|
q = this.quality
|
|
lw = this.lgwin
|
|
lb = this.lgblock
|
|
this.rb_off = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_RB)
|
|
this.rb_buf_off = this.rb_off ~mod+ 2
|
|
this.h_off0 = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_HASH)
|
|
this.cmds_off = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_CMDS)
|
|
this.cmds_cap = this.commands_capacity(quality: q, lgwin: lw, lgblock: lb)
|
|
c = 0
|
|
while c < 3 {
|
|
this.gbs_types_off[c] = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_TYPES_0 + c)
|
|
this.gbs_lengths_off[c] = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_LENGTHS_0 + c)
|
|
this.gbs_histo_off_base[c] = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_HISTO_0 + c)
|
|
this.be_depth_off[c] = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_BE_DEPTH_0 + c)
|
|
this.be_bits_off[c] = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_BE_BITS_0 + c)
|
|
c ~mod+= 1
|
|
}
|
|
this.mb_comb_off = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_COMB)
|
|
this.mb_cmap_off = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_CMAP)
|
|
this.mb_rle_off = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_RLE)
|
|
this.workbuf_end = this.compute_layout_offset(quality: q, lgwin: lw, lgblock: lb, idx: LAYOUT_END)
|
|
|
|
// RingBufferSetup.
|
|
this.rb_size = (1 as base.u32) << this.rb_bits(lgwin: lw, lgblock: lb)
|
|
this.rb_mask = this.rb_size ~mod- 1
|
|
this.rb_tail_size = (1 as base.u32) << lb
|
|
this.rb_total_size = this.rb_size ~mod+ this.rb_tail_size
|
|
}
|
|
|
|
// Mirrors BrotliInitDistanceParams in metablock.c (see
|
|
// metablock_builder.init_distance_params), for this.distance_postfix_bits and
|
|
// this.num_direct_distance_codes.
|
|
pri func encoder.init_distance_params!() {
|
|
this.mb.init_distance_params!(
|
|
npostfix: this.distance_postfix_bits,
|
|
ndirect: this.num_direct_distance_codes,
|
|
large_window: this.large_window)
|
|
this.dist_alphabet_size_max = this.mb.dist_alphabet_size_max
|
|
this.dist_alphabet_size_limit = this.mb.dist_alphabet_size_limit
|
|
this.dist_max_distance = this.mb.dist_max_distance
|
|
}
|
|
|
|
// Mirrors WrapPosition in encode.c.
|
|
pri func encoder.wrap_position(position: base.u64) base.u64 {
|
|
var result : base.u32
|
|
var gb : base.u64
|
|
|
|
result = (args.position & 0xFFFF_FFFF) as base.u32
|
|
gb = args.position >> 30
|
|
if gb > 2 {
|
|
// Wrap every 2GiB; The first 3GB are continuous.
|
|
result = (result & 0x3FFF_FFFF) | ((((((gb ~mod- 1) & 1) as base.u32) + 1)) << 30)
|
|
}
|
|
return result as base.u64
|
|
}
|
|
|
|
// Mirrors RingBufferInitBuffer in ringbuffer.h. The buffer's workbuf offset
|
|
// is fixed, so re-allocating it keeps its contents in place.
|
|
pri func encoder.rb_init_buffer!(wb: slice base.u8, buflen: base.u32) {
|
|
this.rb_cur_size = args.buflen
|
|
this.set_byte!(s: args.wb, i: this.rb_off ~mod+ 0, v: 0)
|
|
this.set_byte!(s: args.wb, i: this.rb_off ~mod+ 1, v: 0)
|
|
this.fill_bytes!(s: args.wb, i: this.rb_buf_off ~mod+ (args.buflen as base.u64), n: 7, v: 0)
|
|
}
|
|
|
|
// rb_copy copies src to the workbuf at the ring buffer's position dst.
|
|
pri func encoder.rb_copy!(wb: slice base.u8, dst: base.u64, src: roslice base.u8) {
|
|
var a : base.u64
|
|
var q : slice base.u8
|
|
|
|
a = this.rb_buf_off ~mod+ args.dst
|
|
if a <= args.wb.length() {
|
|
q = args.wb[a ..]
|
|
if args.src.length() <= q.length() {
|
|
q.copy_from_slice!(s: args.src)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mirrors RingBufferWrite (and RingBufferWriteTail) in ringbuffer.h.
|
|
pri func encoder.rb_write!(wb: slice base.u8, bytes: roslice base.u8) {
|
|
var n : base.u64
|
|
var masked_pos : base.u64
|
|
var size : base.u64
|
|
var tail_size : base.u64
|
|
var total_size : base.u64
|
|
var k : base.u64
|
|
var not_first_lap : base.bool
|
|
|
|
n = args.bytes.length()
|
|
size = this.rb_size as base.u64
|
|
tail_size = this.rb_tail_size as base.u64
|
|
total_size = this.rb_total_size as base.u64
|
|
|
|
if (this.rb_pos == 0) and (n < tail_size) {
|
|
// Special case for the first write: to process the first block, we
|
|
// don't need to allocate the whole ring-buffer and we don't need the
|
|
// tail either.
|
|
this.rb_pos = (n & 0xFFFF_FFFF) as base.u32
|
|
this.rb_init_buffer!(wb: args.wb, buflen: this.rb_pos)
|
|
this.rb_copy!(wb: args.wb, dst: 0, src: args.bytes)
|
|
return nothing
|
|
}
|
|
if this.rb_cur_size < this.rb_total_size {
|
|
// Lazily allocate the full buffer.
|
|
this.rb_init_buffer!(wb: args.wb, buflen: this.rb_total_size)
|
|
// Initialize the last two bytes to zero, so that we don't have to
|
|
// worry later when we copy the last two bytes to the first two
|
|
// positions.
|
|
this.set_byte!(s: args.wb, i: (this.rb_buf_off ~mod+ size) ~mod- 2, v: 0)
|
|
this.set_byte!(s: args.wb, i: (this.rb_buf_off ~mod+ size) ~mod- 1, v: 0)
|
|
// Initialize tail; might be touched by "best_len++" optimization
|
|
// when ring buffer is "full".
|
|
this.set_byte!(s: args.wb, i: this.rb_buf_off ~mod+ size, v: 241)
|
|
}
|
|
|
|
masked_pos = (this.rb_pos & this.rb_mask) as base.u64
|
|
// RingBufferWriteTail.
|
|
if masked_pos < tail_size {
|
|
// Just fill the tail buffer with the beginning data.
|
|
k = this.min64(a: n, b: tail_size ~mod- masked_pos)
|
|
if k <= args.bytes.length() {
|
|
this.rb_copy!(wb: args.wb, dst: size ~mod+ masked_pos, src: args.bytes[.. k])
|
|
}
|
|
}
|
|
if (masked_pos ~mod+ n) <= size {
|
|
// A single write fits.
|
|
this.rb_copy!(wb: args.wb, dst: masked_pos, src: args.bytes)
|
|
} else {
|
|
// Split into two writes. Copy into the end of the buffer, including
|
|
// the tail buffer.
|
|
k = this.min64(a: n, b: total_size ~mod- masked_pos)
|
|
if k <= args.bytes.length() {
|
|
this.rb_copy!(wb: args.wb, dst: masked_pos, src: args.bytes[.. k])
|
|
}
|
|
// Copy into the beginning of the buffer.
|
|
k = size ~mod- masked_pos
|
|
if k <= args.bytes.length() {
|
|
this.rb_copy!(wb: args.wb, dst: 0, src: args.bytes[k ..])
|
|
}
|
|
}
|
|
|
|
not_first_lap = (this.rb_pos & 0x8000_0000) <> 0
|
|
this.set_byte!(s: args.wb, i: this.rb_off ~mod+ 0, v: this.byte_at(s: args.wb, i: (this.rb_buf_off ~mod+ size) ~mod- 2))
|
|
this.set_byte!(s: args.wb, i: this.rb_off ~mod+ 1, v: this.byte_at(s: args.wb, i: (this.rb_buf_off ~mod+ size) ~mod- 1))
|
|
this.rb_pos = (this.rb_pos & 0x7FFF_FFFF) ~mod+ ((n & 0x7FFF_FFFF) as base.u32)
|
|
if not_first_lap {
|
|
// Wrap, but preserve not-a-first-lap feature.
|
|
this.rb_pos |= 0x8000_0000
|
|
}
|
|
}
|
|
|
|
// Mirrors CopyInputToRingBuffer in encode.c.
|
|
pri func encoder.copy_input_to_ring_buffer!(wb: slice base.u8, bytes: roslice base.u8) {
|
|
this.rb_write!(wb: args.wb, bytes: args.bytes)
|
|
this.input_pos ~mod+= args.bytes.length()
|
|
if this.rb_pos <= this.rb_mask {
|
|
// This is the first time when the ring buffer is being written. We
|
|
// clear 7 bytes just after the bytes that have been copied from the
|
|
// input buffer.
|
|
this.fill_bytes!(s: args.wb, i: this.rb_buf_off ~mod+ (this.rb_pos as base.u64), n: 7, v: 0)
|
|
}
|
|
}
|
|
|
|
// Mirrors UpdateLastProcessedPos in encode.c.
|
|
pri func encoder.update_last_processed_pos!() base.bool {
|
|
var wrapped_last_processed_pos : base.u64
|
|
var wrapped_input_pos : base.u64
|
|
|
|
wrapped_last_processed_pos = this.wrap_position(position: this.last_processed_pos)
|
|
wrapped_input_pos = this.wrap_position(position: this.input_pos)
|
|
this.last_processed_pos = this.input_pos
|
|
return wrapped_input_pos < wrapped_last_processed_pos
|
|
}
|
|
|
|
// Mirrors RemainingInputBlockSize in encode.c.
|
|
pri func encoder.remaining_input_block_size() base.u64 {
|
|
var delta : base.u64
|
|
var block_size : base.u64
|
|
|
|
delta = this.input_pos ~mod- this.last_processed_pos
|
|
block_size = (1 as base.u64) << this.lgblock
|
|
if delta >= block_size {
|
|
return 0
|
|
}
|
|
return block_size ~mod- delta
|
|
}
|
|
|
|
// Mirrors UpdateSizeHint in encode.c.
|
|
pri func encoder.update_size_hint!(available_in: base.u64) {
|
|
var delta : base.u64
|
|
var tail : base.u64
|
|
var limit : base.u64
|
|
|
|
if this.size_hint == 0 {
|
|
delta = this.input_pos ~mod- this.last_processed_pos
|
|
tail = args.available_in
|
|
limit = 0x4000_0000
|
|
if (delta >= limit) or (tail >= limit) or ((delta ~mod+ tail) >= limit) {
|
|
this.size_hint = 0x4000_0000
|
|
} else {
|
|
this.size_hint = ((delta ~mod+ tail) & 0xFFFF_FFFF) as base.u32
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mirrors ExtendLastCommand in encode.c (see extend_last_command_compound
|
|
// for its compound dictionary branch). It returns how many bytes it extended
|
|
// the last command by: the caller subtracts that from bytes and adds it to
|
|
// wrapped_last_processed_pos.
|
|
pri func encoder.extend_last_command!(wb: slice base.u8, dwb: roslice base.u8, bytes: base.u64, wrapped_last_processed_pos: base.u64) base.u64 {
|
|
var last : base.u64
|
|
var max_backward_distance : base.u64
|
|
var copy_len : base.u32
|
|
var last_copy_len : base.u64
|
|
var last_processed_pos : base.u64
|
|
var max_distance : base.u64
|
|
var cmd_dist : base.u64
|
|
var distance_code : base.u32
|
|
var n : base.u64
|
|
var p : base.u64
|
|
|
|
last = this.num_cmds ~mod- 1
|
|
max_backward_distance = ((1 as base.u64) << this.lgwin) ~mod- 16
|
|
copy_len = this.cmd_copy_len_raw(wb: args.wb, i: last)
|
|
last_copy_len = (copy_len & 0x1FF_FFFF) as base.u64
|
|
last_processed_pos = this.last_processed_pos ~mod- last_copy_len
|
|
max_distance = last_processed_pos.min(no_more_than: max_backward_distance)
|
|
cmd_dist = this.dist_cache_u64(i: 0)
|
|
distance_code = this.cmd_restore_distance_code(wb: args.wb, i: last)
|
|
if (distance_code < 16) or (((distance_code ~mod- 15) as base.u64) == cmd_dist) {
|
|
if cmd_dist <= max_distance {
|
|
p = args.wrapped_last_processed_pos
|
|
while (n < args.bytes) and
|
|
(this.rb_byte(wb: args.wb, pos: p) == this.rb_byte(wb: args.wb, pos: p ~mod- cmd_dist)) {
|
|
copy_len ~mod+= 1
|
|
n ~mod+= 1
|
|
p = (p ~mod+ 1) & 0xFFFF_FFFF
|
|
}
|
|
} else {
|
|
n = this.extend_last_command_compound(wb: args.wb, dwb: args.dwb, bytes: args.bytes,
|
|
wrapped_last_processed_pos: args.wrapped_last_processed_pos,
|
|
cmd_dist: cmd_dist, max_distance: max_distance, last_copy_len: last_copy_len)
|
|
copy_len ~mod+= (n & 0xFFFF_FFFF) as base.u32
|
|
}
|
|
// The copy length is at most the metablock size, and thus
|
|
// expressible.
|
|
this.set_cmd!(wb: args.wb, i: last,
|
|
insert_len: this.cmd_insert_len(wb: args.wb, i: last),
|
|
copy_len: copy_len,
|
|
dist_extra: this.cmd_dist_extra(wb: args.wb, i: last),
|
|
cmd_prefix: this.get_length_code(
|
|
insertlen: this.cmd_insert_len(wb: args.wb, i: last) as base.u64,
|
|
copylen: ((copy_len & 0x1FF_FFFF) ~mod+ (copy_len >> 25)) as base.u64,
|
|
use_last_distance: (this.cmd_dist_prefix(wb: args.wb, i: last) & 0x3FF) == 0),
|
|
dist_prefix: this.cmd_dist_prefix(wb: args.wb, i: last))
|
|
}
|
|
return n
|
|
}
|
|
|
|
// Mirrors EstimateEntropy in encode.c, for the size u32 values of
|
|
// this.ctx_histo starting at off.
|
|
pri func encoder.estimate_entropy(off: base.u32, size: base.u32) base.u64 {
|
|
var total : base.u64
|
|
var result : base.u64
|
|
var i : base.u32
|
|
var p : base.u32
|
|
|
|
i = 0
|
|
while i < args.size {
|
|
p = this.ctx_histo[(args.off ~mod+ i) & 511]
|
|
total ~mod+= p as base.u64
|
|
result = this.sf.f64_add(a: result, b: this.sf.f64_mul(
|
|
a: this.sf.f64_from_u32(a: p), b: this.bc.fast_log2(v: p as base.u64)))
|
|
i ~mod+= 1
|
|
}
|
|
return this.sf.f64_sub(a: this.sf.f64_mul(
|
|
a: this.sf.f64_from_u64(a: total), b: this.bc.fast_log2(v: total)), b: result)
|
|
}
|
|
|
|
// Mirrors ChooseContextMap in encode.c. The bigram_histo is
|
|
// this.ctx_histo[0 .. 9]. It returns num_literal_contexts.
|
|
pri func encoder.choose_context_map!() base.u32 {
|
|
var i : base.u32
|
|
var total : base.u32
|
|
var e0 : base.u64
|
|
var e1 : base.u64
|
|
var e2 : base.u64
|
|
var e3 : base.u64
|
|
|
|
// monogram_histo is this.ctx_histo[16 .. 19] and two_prefix_histo is
|
|
// this.ctx_histo[24 .. 30].
|
|
i = 16
|
|
while i < 32 {
|
|
this.ctx_histo[i] = 0
|
|
i ~mod+= 1
|
|
}
|
|
i = 0
|
|
while i < 9 {
|
|
this.ctx_histo[16 + (i % 3)] ~mod+= this.ctx_histo[i]
|
|
this.ctx_histo[24 + (i % 6)] ~mod+= this.ctx_histo[i]
|
|
i ~mod+= 1
|
|
}
|
|
e1 = this.estimate_entropy(off: 16, size: 3)
|
|
e2 = this.sf.f64_add(a: this.estimate_entropy(off: 24, size: 3), b: this.estimate_entropy(off: 27, size: 3))
|
|
e3 = 0
|
|
i = 0
|
|
while i < 3 {
|
|
e3 = this.sf.f64_add(a: e3, b: this.estimate_entropy(off: 3 * i, size: 3))
|
|
i ~mod+= 1
|
|
}
|
|
|
|
total = (this.ctx_histo[16] ~mod+ this.ctx_histo[17]) ~mod+ this.ctx_histo[18]
|
|
e0 = this.sf.f64_div(a: F64_1, b: this.sf.f64_from_u32(a: total))
|
|
e1 = this.sf.f64_mul(a: e1, b: e0)
|
|
e2 = this.sf.f64_mul(a: e2, b: e0)
|
|
e3 = this.sf.f64_mul(a: e3, b: e0)
|
|
|
|
if this.quality < 7 {
|
|
// 3 context models is a bit slower, don't use it at lower qualities.
|
|
e3 = this.sf.f64_mul(a: e1, b: F64_10)
|
|
}
|
|
// If expected savings by symbol are less than 0.2 bits, skip the context
|
|
// modeling -- in exchange for faster decoding speed.
|
|
if (this.sf.f64_lt(a: this.sf.f64_sub(a: e1, b: e2), b: F64_0_2) <> 0) and
|
|
(this.sf.f64_lt(a: this.sf.f64_sub(a: e1, b: e3), b: F64_0_2) <> 0) {
|
|
return 1
|
|
} else if this.sf.f64_lt(a: this.sf.f64_sub(a: e2, b: e3), b: F64_0_02) <> 0 {
|
|
return 2
|
|
}
|
|
return 3
|
|
}
|
|
|
|
// Mirrors ShouldUseComplexStaticContextMap in encode.c. It returns 13 (the
|
|
// number of literal contexts) if it should, or 0 if it should not. The
|
|
// combined_histo is this.ctx_histo[0 .. 32] and the context_histo is
|
|
// this.ctx_histo[32 .. 448].
|
|
pri func encoder.should_use_complex_static_context_map!(wb: roslice base.u8, start_pos: base.u64, length: base.u64) base.u32 {
|
|
var start_pos : base.u64
|
|
var end_pos : base.u64
|
|
var stride_end_pos : base.u64
|
|
var pos : base.u64
|
|
var total : base.u32
|
|
var prev1 : base.u8
|
|
var prev2 : base.u8
|
|
var literal : base.u8
|
|
var context : base.u32
|
|
var i : base.u32
|
|
var e0 : base.u64
|
|
var e1 : base.u64
|
|
var e2 : base.u64
|
|
|
|
// Try the more complex static context map only for long data.
|
|
if this.size_hint < 0x10_0000 {
|
|
return 0
|
|
}
|
|
start_pos = args.start_pos
|
|
end_pos = start_pos ~mod+ args.length
|
|
i = 0
|
|
while i < 448 {
|
|
this.ctx_histo[i] = 0
|
|
i ~mod+= 1
|
|
}
|
|
while (start_pos ~mod+ 64) <= end_pos {
|
|
stride_end_pos = start_pos ~mod+ 64
|
|
prev2 = this.rb_byte(wb: args.wb, pos: start_pos)
|
|
prev1 = this.rb_byte(wb: args.wb, pos: start_pos ~mod+ 1)
|
|
// To make the analysis of the data faster we only examine 64 byte
|
|
// long strides at every 4kB intervals.
|
|
pos = start_pos ~mod+ 2
|
|
while pos < stride_end_pos {
|
|
literal = this.rb_byte(wb: args.wb, pos: pos)
|
|
context = STATIC_CONTEXT_MAP_COMPLEX_UTF8[(CONTEXT_LOOKUP[1024 + (prev1 as base.u32)] |
|
|
CONTEXT_LOOKUP[1280 + (prev2 as base.u32)]) & 63] as base.u32
|
|
total ~mod+= 1
|
|
this.ctx_histo[(literal >> 3) & 31] ~mod+= 1
|
|
this.ctx_histo[(32 + (context << 5) + ((literal >> 3) as base.u32)) & 511] ~mod+= 1
|
|
prev2 = prev1
|
|
prev1 = literal
|
|
pos ~mod+= 1
|
|
}
|
|
start_pos ~mod+= 4096
|
|
}
|
|
e1 = this.estimate_entropy(off: 0, size: 32)
|
|
e2 = 0
|
|
i = 0
|
|
while i < 13 {
|
|
e2 = this.sf.f64_add(a: e2, b: this.estimate_entropy(off: 32 + (i << 5), size: 32))
|
|
i ~mod+= 1
|
|
}
|
|
e0 = this.sf.f64_div(a: F64_1, b: this.sf.f64_from_u32(a: total))
|
|
e1 = this.sf.f64_mul(a: e1, b: e0)
|
|
e2 = this.sf.f64_mul(a: e2, b: e0)
|
|
// The triggering heuristics below were tuned by compressing the
|
|
// individual files of the silesia corpus.
|
|
if (this.sf.f64_gt(a: e2, b: F64_3) <> 0) or
|
|
(this.sf.f64_lt(a: this.sf.f64_sub(a: e1, b: e2), b: F64_0_2) <> 0) {
|
|
return 0
|
|
}
|
|
return 13
|
|
}
|
|
|
|
// Mirrors DecideOverLiteralContextModeling in encode.c. It returns
|
|
// num_literal_contexts.
|
|
pri func encoder.decide_over_literal_context_modeling!(wb: roslice base.u8, start_pos: base.u64, length: base.u64) base.u32 {
|
|
var start_pos : base.u64
|
|
var end_pos : base.u64
|
|
var stride_end_pos : base.u64
|
|
var pos : base.u64
|
|
var prev : base.u32[..= 6]
|
|
var lit_lut : base.u32[..= 2]
|
|
var i : base.u32
|
|
|
|
if (this.quality < 5) or (args.length < 64) {
|
|
return 1
|
|
}
|
|
i = this.should_use_complex_static_context_map!(wb: args.wb, start_pos: args.start_pos, length: args.length)
|
|
if i <> 0 {
|
|
return 13
|
|
}
|
|
// 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.
|
|
start_pos = args.start_pos
|
|
end_pos = start_pos ~mod+ args.length
|
|
i = 0
|
|
while i < 9 {
|
|
this.ctx_histo[i] = 0
|
|
i ~mod+= 1
|
|
}
|
|
while (start_pos ~mod+ 64) <= end_pos {
|
|
stride_end_pos = start_pos ~mod+ 64
|
|
prev = this.utf8_prefix_lut(b: this.rb_byte(wb: args.wb, pos: start_pos)) * 3
|
|
pos = start_pos ~mod+ 1
|
|
while pos < stride_end_pos {
|
|
lit_lut = this.utf8_prefix_lut(b: this.rb_byte(wb: args.wb, pos: pos))
|
|
this.ctx_histo[(prev + lit_lut) & 511] ~mod+= 1
|
|
prev = lit_lut * 3
|
|
pos ~mod+= 1
|
|
}
|
|
start_pos ~mod+= 4096
|
|
}
|
|
i = this.choose_context_map!()
|
|
return i
|
|
}
|
|
|
|
// utf8_prefix_lut returns DecideOverLiteralContextModeling's lut[b >> 6].
|
|
pri func encoder.utf8_prefix_lut(b: base.u8) base.u32[..= 2] {
|
|
if args.b < 0x80 {
|
|
return 0
|
|
} else if args.b < 0xC0 {
|
|
return 1
|
|
}
|
|
return 2
|
|
}
|
|
|
|
// Mirrors ShouldCompress in encode.c.
|
|
pri func encoder.should_compress!(wb: roslice base.u8, last_flush_pos: base.u64, bytes: base.u64, num_literals: base.u64, num_commands: base.u64) base.bool {
|
|
var bit_cost_threshold : base.u64
|
|
var t : base.u64
|
|
var pos : base.u32
|
|
var i : base.u64
|
|
|
|
if args.bytes <= 2 {
|
|
return false
|
|
}
|
|
if args.num_commands < ((args.bytes >> 8) + 2) {
|
|
if this.sf.f64_gt(
|
|
a: this.sf.f64_from_u64(a: args.num_literals),
|
|
b: this.sf.f64_mul(a: F64_0_99, b: this.sf.f64_from_u64(a: args.bytes))) <> 0 {
|
|
i = 0
|
|
while i < 256 {
|
|
this.ctx_histo[i] = 0
|
|
i ~mod+= 1
|
|
}
|
|
bit_cost_threshold = this.sf.f64_mul(
|
|
a: this.sf.f64_mul(a: this.sf.f64_from_u64(a: args.bytes), b: F64_7_92),
|
|
b: F64_INV_13)
|
|
t = (args.bytes ~mod+ 12) / 13
|
|
pos = (args.last_flush_pos & 0xFFFF_FFFF) as base.u32
|
|
i = 0
|
|
while i < t {
|
|
this.ctx_histo[this.rb_byte(wb: args.wb, pos: pos as base.u64)] ~mod+= 1
|
|
pos ~mod+= 13
|
|
i ~mod+= 1
|
|
}
|
|
if this.sf.f64_gt(a: this.ctx_histo_bits_entropy(), b: bit_cost_threshold) <> 0 {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// ctx_histo_bits_entropy returns BrotliBitsEntropy of this.ctx_histo[0 ..
|
|
// 256], like bit_cost.bits_entropy.
|
|
pri func encoder.ctx_histo_bits_entropy() base.u64 {
|
|
var sum : base.u64
|
|
var retval : base.u64
|
|
var p : base.u64
|
|
var i : base.u32
|
|
|
|
i = 0
|
|
while i < 256 {
|
|
p = this.ctx_histo[i] as base.u64
|
|
sum ~mod+= p
|
|
retval = this.sf.f64_sub(a: retval, b: this.sf.f64_mul(
|
|
a: this.sf.f64_from_u64(a: p), b: this.bc.fast_log2(v: p)))
|
|
i ~mod+= 1
|
|
}
|
|
if sum <> 0 {
|
|
retval = this.sf.f64_add(a: retval, b: this.sf.f64_mul(
|
|
a: this.sf.f64_from_u64(a: sum), b: this.bc.fast_log2(v: sum)))
|
|
}
|
|
if this.sf.f64_lt(a: retval, b: this.sf.f64_from_u64(a: sum)) <> 0 {
|
|
retval = this.sf.f64_from_u64(a: sum)
|
|
}
|
|
return retval
|
|
}
|
|
|
|
// Mirrors WriteMetaBlockInternal in encode.c. The storage is args.s, with
|
|
// args.s[0] and args.s[1] holding the last_bytes and this.bw_ix the
|
|
// last_bytes_bits.
|
|
pri func encoder.write_meta_block_internal!(wb: slice base.u8, last_flush_pos: base.u64, bytes: base.u64, is_last: base.bool,
|
|
prev_byte: base.u8, prev_byte2: base.u8, s: slice base.u8) {
|
|
var wrapped_last_flush_pos : base.u64
|
|
var last_bytes : base.u16
|
|
var last_bytes_bits : base.u64
|
|
var num_literal_contexts : base.u32
|
|
var i : base.u32
|
|
var compress : base.bool
|
|
|
|
wrapped_last_flush_pos = this.wrap_position(position: args.last_flush_pos)
|
|
|
|
if args.bytes == 0 {
|
|
// Write the ISLAST and ISEMPTY bits.
|
|
this.write_bits!(n_bits: 2, bits: 3, s: args.s)
|
|
this.bw_ix = (this.bw_ix ~mod+ 7) & 0xFFFF_FFFF_FFFF_FFF8
|
|
return nothing
|
|
}
|
|
|
|
compress = this.should_compress!(wb: args.wb, last_flush_pos: args.last_flush_pos, bytes: args.bytes,
|
|
num_literals: this.num_lits, num_commands: this.num_cmds)
|
|
if not compress {
|
|
// Restore the distance cache, as its last update by
|
|
// CreateBackwardReferences is now unused.
|
|
i = 0
|
|
while i < 4 {
|
|
this.dist_cache[i] = this.saved_dist_cache[i]
|
|
i ~mod+= 1
|
|
}
|
|
this.store_uncompressed_meta_block!(is_final_block: args.is_last, wb: args.wb,
|
|
position: wrapped_last_flush_pos, len: args.bytes, s: args.s)
|
|
return nothing
|
|
}
|
|
|
|
last_bytes = this.peek_u16(s: args.s, i: 0)
|
|
last_bytes_bits = this.bw_ix
|
|
if this.quality <= 2 {
|
|
this.store_meta_block_fast!(wb: args.wb, start_pos: wrapped_last_flush_pos, length: args.bytes,
|
|
is_last: args.is_last, n_commands: this.num_cmds, s: args.s)
|
|
} else if this.quality < 4 {
|
|
this.store_meta_block_trivial!(wb: args.wb, start_pos: wrapped_last_flush_pos, length: args.bytes,
|
|
is_last: args.is_last, n_commands: this.num_cmds, s: args.s)
|
|
} else {
|
|
num_literal_contexts = 1
|
|
if this.p_disable_lcm == 0 {
|
|
num_literal_contexts = this.decide_over_literal_context_modeling!(
|
|
wb: args.wb, start_pos: wrapped_last_flush_pos, length: args.bytes)
|
|
}
|
|
this.build_meta_block_greedy!(wb: args.wb, pos: wrapped_last_flush_pos,
|
|
prev_byte: args.prev_byte, prev_byte2: args.prev_byte2,
|
|
num_contexts: num_literal_contexts, n_commands: this.num_cmds)
|
|
// MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS is 4.
|
|
this.optimize_histograms!(wb: args.wb, num_distance_codes: this.dist_alphabet_size_limit)
|
|
this.store_meta_block!(wb: args.wb, start_pos: wrapped_last_flush_pos, length: args.bytes,
|
|
prev_byte: args.prev_byte, prev_byte2: args.prev_byte2,
|
|
is_last: args.is_last, n_commands: this.num_cmds, s: args.s)
|
|
}
|
|
if (args.bytes ~mod+ 4) < (this.bw_ix >> 3) {
|
|
// Restore the distance cache and last byte.
|
|
i = 0
|
|
while i < 4 {
|
|
this.dist_cache[i] = this.saved_dist_cache[i]
|
|
i ~mod+= 1
|
|
}
|
|
this.poke_u16!(s: args.s, i: 0, v: last_bytes)
|
|
this.bw_ix = last_bytes_bits
|
|
this.store_uncompressed_meta_block!(is_final_block: args.is_last, wb: args.wb,
|
|
position: wrapped_last_flush_pos, len: args.bytes, s: args.s)
|
|
}
|
|
}
|
|
|
|
// Mirrors EncodeData in encode.c, for qualities 2 to 9. On a new metablock,
|
|
// it sets the pending output (this.out_etc) to the storage (or tiny_buf).
|
|
pri func encoder.encode_data!(wb: slice base.u8, dwb: roslice base.u8, is_last: base.bool, force_flush: base.bool) base.status {
|
|
var status : base.status
|
|
var delta : base.u64
|
|
var bytes : base.u64
|
|
var wrapped_last_processed_pos : base.u64
|
|
var n : base.u64
|
|
var max_length : base.u64
|
|
var processed_bytes : base.u64
|
|
var next_input_fits_metablock : base.bool
|
|
var should_flush : base.bool
|
|
var metablock_size : base.u64
|
|
var storage_len : base.u64
|
|
var ix : base.u64
|
|
var i : base.u32
|
|
var wrapped : base.bool
|
|
|
|
delta = this.input_pos ~mod- this.last_processed_pos
|
|
bytes = delta & 0xFFFF_FFFF
|
|
wrapped_last_processed_pos = this.wrap_position(position: this.last_processed_pos)
|
|
|
|
if delta == 0 {
|
|
// No new input; still might want to flush or finish.
|
|
if this.rb_cur_size == 0 {
|
|
// No input has been processed so far.
|
|
if args.is_last {
|
|
// Emit complete finalized stream.
|
|
this.last_bytes |= ((3 as base.u32) << this.last_bytes_bits) & 0xFFFF
|
|
if this.last_bytes_bits <= 13 {
|
|
this.last_bytes_bits += 2
|
|
}
|
|
this.tiny_buf[0] = (this.last_bytes & 0xFF) as base.u8
|
|
this.tiny_buf[1] = (this.last_bytes >> 8) as base.u8
|
|
this.out_in_tiny_buf = true
|
|
this.out_pos = 0
|
|
this.out_len = ((this.last_bytes_bits + 7) >> 3) as base.u64
|
|
}
|
|
return ok
|
|
} else if (not args.is_last) and (not args.force_flush) {
|
|
// Another no-op.
|
|
return ok
|
|
}
|
|
}
|
|
|
|
// Adding more blocks after "last" block is forbidden.
|
|
if this.is_last_block_emitted {
|
|
return "#internal error: inconsistent encoder state"
|
|
}
|
|
if args.is_last {
|
|
this.is_last_block_emitted = true
|
|
}
|
|
if delta > ((1 as base.u64) << this.lgblock) {
|
|
return "#internal error: inconsistent encoder state"
|
|
}
|
|
|
|
// InitOrStitchToPreviousBlock.
|
|
this.hasher_setup!(wb: args.wb, position: wrapped_last_processed_pos, input_size: bytes, is_last: args.is_last)
|
|
this.hasher_stitch_to_previous_block!(wb: args.wb, num_bytes: bytes, position: wrapped_last_processed_pos)
|
|
|
|
if (this.num_cmds > 0) and (this.last_insert_len == 0) {
|
|
n = this.extend_last_command!(wb: args.wb, dwb: args.dwb, bytes: bytes,
|
|
wrapped_last_processed_pos: wrapped_last_processed_pos)
|
|
bytes ~mod-= n
|
|
wrapped_last_processed_pos = (wrapped_last_processed_pos ~mod+ n) & 0xFFFF_FFFF
|
|
}
|
|
|
|
status = this.create_backward_references!(wb: args.wb, dwb: args.dwb, num_bytes: bytes, position: wrapped_last_processed_pos)
|
|
if not status.is_ok() {
|
|
return status
|
|
}
|
|
|
|
max_length = this.max_metablock_size(lgwin: this.lgwin, lgblock: this.lgblock)
|
|
processed_bytes = this.input_pos ~mod- this.last_flush_pos
|
|
// If maximal possible additional block doesn't fit metablock, flush now.
|
|
next_input_fits_metablock = (processed_bytes ~mod+ ((1 as base.u64) << this.lgblock)) <= max_length
|
|
// If block splitting is not used, then flush as soon as there is some
|
|
// amount of commands / literals produced.
|
|
should_flush = (this.quality < 4) and ((this.num_lits ~mod+ this.num_cmds) >= MAX_NUM_DELAYED_SYMBOLS)
|
|
if (not args.is_last) and (not args.force_flush) and (not should_flush) and
|
|
next_input_fits_metablock and
|
|
(this.num_lits < (max_length / 8)) and
|
|
(this.num_cmds < (max_length / 8)) {
|
|
// Merge with next input block. Everything will happen later.
|
|
wrapped = this.update_last_processed_pos!()
|
|
if wrapped {
|
|
this.h_is_prepared = false
|
|
}
|
|
return ok
|
|
}
|
|
|
|
// Create the last insert-only command.
|
|
if this.last_insert_len > 0 {
|
|
if this.num_cmds >= this.cmds_cap {
|
|
return "#internal error: inconsistent encoder state"
|
|
}
|
|
this.init_insert_command!(wb: args.wb, n: this.num_cmds, insertlen: this.last_insert_len)
|
|
this.num_cmds ~mod+= 1
|
|
this.num_lits ~mod+= this.last_insert_len
|
|
this.last_insert_len = 0
|
|
}
|
|
|
|
if (not args.is_last) and (this.input_pos == this.last_flush_pos) {
|
|
// We have no new input data and we don't have to finish the stream,
|
|
// so nothing to do.
|
|
return ok
|
|
}
|
|
|
|
metablock_size = (this.input_pos ~mod- this.last_flush_pos) & 0xFFFF_FFFF
|
|
storage_len = (2 * metablock_size) + 503 + STORAGE_SLACK
|
|
if (storage_len > this.rb_off) or (this.rb_off > args.wb.length()) {
|
|
return "#internal error: inconsistent encoder state"
|
|
}
|
|
this.set_byte!(s: args.wb, i: 0, v: (this.last_bytes & 0xFF) as base.u8)
|
|
this.set_byte!(s: args.wb, i: 1, v: (this.last_bytes >> 8) as base.u8)
|
|
this.bw_ix = this.last_bytes_bits as base.u64
|
|
if storage_len > args.wb.length() {
|
|
return "#internal error: inconsistent encoder state"
|
|
}
|
|
this.write_meta_block_internal!(wb: args.wb, last_flush_pos: this.last_flush_pos, bytes: metablock_size,
|
|
is_last: args.is_last, prev_byte: this.prev_byte, prev_byte2: this.prev_byte2,
|
|
s: args.wb[.. storage_len])
|
|
ix = this.bw_ix >> 3
|
|
this.last_bytes = this.byte_at(s: args.wb, i: ix) as base.u32
|
|
this.last_bytes_bits = (this.bw_ix & 7) as base.u32
|
|
this.last_flush_pos = this.input_pos
|
|
wrapped = this.update_last_processed_pos!()
|
|
if wrapped {
|
|
this.h_is_prepared = false
|
|
}
|
|
if this.last_flush_pos > 0 {
|
|
this.prev_byte = this.rb_byte(wb: args.wb, pos: ((this.last_flush_pos & 0xFFFF_FFFF) ~mod- 1) & 0xFFFF_FFFF)
|
|
}
|
|
if this.last_flush_pos > 1 {
|
|
this.prev_byte2 = this.rb_byte(wb: args.wb, pos: (this.last_flush_pos ~mod- 2) & 0xFFFF_FFFF)
|
|
}
|
|
this.num_cmds = 0
|
|
this.num_lits = 0
|
|
// Save the state of the distance cache in case we need to restore it for
|
|
// emitting an uncompressed block.
|
|
i = 0
|
|
while i < 4 {
|
|
this.saved_dist_cache[i] = this.dist_cache[i]
|
|
i ~mod+= 1
|
|
}
|
|
this.out_in_tiny_buf = false
|
|
this.out_pos = 0
|
|
this.out_len = ix
|
|
return ok
|
|
}
|