mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
- encode_float.wuffs: package-private fast paths for the f32/f64 add, sub, mul, compare and int conversion calls in the encoder's hot loops. Calling std/softfloat is a cross-package public call (a receiver check, never inlined). Each fast path returns exactly the softfloat result and falls back to it for the uncommon cases. script/manual-test-brotli-float.c cross-checks them against hardware float and double arithmetic. - Zopfli update_nodes: compute a length's cost only when its copy code changes, hoist the distance cache values and the continuation byte, and use a table for small int to f32 conversions. - FindBlocks: memoize (block_switch_bitcost + insert_cost) for capped costs and skip the subtraction for costs at or above a per-byte threshold (S(c) = c - min_cost is monotone, so such costs would be capped anyway). - BrotliPopulationCost: per-call memo of each count's term and depth, and skip the zero terms of the entropy sums. - std/softfloat: a 64-bit f32_add_mags. Output is unchanged (mimic tests on gcc and clang, parity sweeps). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UZ978BikvkegL2JUkqoB1e
353 lines
13 KiB
Plaintext
353 lines
13 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 literal_cost.c (BrotliEstimateBitCostsForLiterals) and
|
|
// utf8_util.c (BrotliIsMostlyUTF8), which qualities 10 and 11 use. The C
|
|
// code's float cost array is in the workbuf, as the u32le bits of each
|
|
// binary32 value. Its size_t histogram array is this.lc_histogram.
|
|
|
|
// The doubles 0.02905, 0.029, 0.5, 1.0, 0.35, 0.35 / 2000 (folded at compile
|
|
// time by the C compiler) and 0.75 (kMinUTF8Ratio in utf8_util.h).
|
|
pri const LC_F64_0_02905 : base.u64 = 0x3F9D_BF48_7FCB_923A
|
|
pri const LC_F64_0_029 : base.u64 = 0x3F9D_B22D_0E56_0419
|
|
pri const LC_F64_0_5 : base.u64 = 0x3FE0_0000_0000_0000
|
|
pri const LC_F64_1 : base.u64 = 0x3FF0_0000_0000_0000
|
|
pri const LC_F64_0_35 : base.u64 = 0x3FD6_6666_6666_6666
|
|
pri const LC_F64_MULT : base.u64 = 0x3F26_F006_8DB8_BAC7
|
|
pri const LC_F64_UTF8_FRAC : base.u64 = 0x3FE8_0000_0000_0000
|
|
|
|
// rb_raw returns the ring buffer's byte at masked position mpos plus k (the
|
|
// C code's data[(pos + i) & mask] followed by k unmasked bytes).
|
|
pri func encoder.rb_raw(wb: roslice base.u8, mpos: base.u64, k: base.u64) base.u8 {
|
|
return this.byte_at(s: args.wb, i: (this.rb_buf_off ~mod+ args.mpos) ~mod+ args.k)
|
|
}
|
|
|
|
// Mirrors BrotliParseAsUTF8 in utf8_util.c, for the input at masked ring
|
|
// buffer position mpos, with size bytes available. It sets this.lc_symbol
|
|
// and returns the number of bytes read.
|
|
pri func encoder.parse_as_utf8!(wb: roslice base.u8, mpos: base.u64, size: base.u64) base.u64 {
|
|
var i0 : base.u32
|
|
var i1 : base.u32
|
|
var i2 : base.u32
|
|
var i3 : base.u32
|
|
|
|
i0 = this.rb_raw(wb: args.wb, mpos: args.mpos, k: 0) as base.u32
|
|
i1 = this.rb_raw(wb: args.wb, mpos: args.mpos, k: 1) as base.u32
|
|
i2 = this.rb_raw(wb: args.wb, mpos: args.mpos, k: 2) as base.u32
|
|
i3 = this.rb_raw(wb: args.wb, mpos: args.mpos, k: 3) as base.u32
|
|
// ASCII.
|
|
if (i0 & 0x80) == 0 {
|
|
this.lc_symbol = i0
|
|
if i0 > 0 {
|
|
return 1
|
|
}
|
|
}
|
|
// 2-byte UTF8.
|
|
if (args.size > 1) and ((i0 & 0xE0) == 0xC0) and ((i1 & 0xC0) == 0x80) {
|
|
this.lc_symbol = ((i0 & 0x1F) << 6) | (i1 & 0x3F)
|
|
if this.lc_symbol > 0x7F {
|
|
return 2
|
|
}
|
|
}
|
|
// 3-byte UFT8.
|
|
if (args.size > 2) and ((i0 & 0xF0) == 0xE0) and ((i1 & 0xC0) == 0x80) and ((i2 & 0xC0) == 0x80) {
|
|
this.lc_symbol = ((i0 & 0x0F) << 12) | ((i1 & 0x3F) << 6) | (i2 & 0x3F)
|
|
if this.lc_symbol > 0x7FF {
|
|
return 3
|
|
}
|
|
}
|
|
// 4-byte UFT8.
|
|
if (args.size > 3) and ((i0 & 0xF8) == 0xF0) and ((i1 & 0xC0) == 0x80) and
|
|
((i2 & 0xC0) == 0x80) and ((i3 & 0xC0) == 0x80) {
|
|
this.lc_symbol = ((i0 & 0x07) << 18) | ((i1 & 0x3F) << 12) | ((i2 & 0x3F) << 6) | (i3 & 0x3F)
|
|
if (this.lc_symbol > 0xFFFF) and (this.lc_symbol <= 0x10_FFFF) {
|
|
return 4
|
|
}
|
|
}
|
|
// Not UTF8, emit a special symbol above the UTF8-code space.
|
|
this.lc_symbol = 0x11_0000 | i0
|
|
return 1
|
|
}
|
|
|
|
// Mirrors BrotliIsMostlyUTF8 in utf8_util.c, with a min_fraction of
|
|
// kMinUTF8Ratio (0.75).
|
|
pri func encoder.is_mostly_utf8!(wb: roslice base.u8, pos: base.u64, length: base.u64) base.bool {
|
|
var size_utf8 : base.u64
|
|
var i : base.u64
|
|
var bytes_read : base.u64
|
|
|
|
while i < args.length {
|
|
bytes_read = this.parse_as_utf8!(wb: args.wb, mpos: (args.pos ~mod+ i) & (this.rb_mask as base.u64),
|
|
size: args.length ~mod- i)
|
|
i ~mod+= bytes_read
|
|
if this.lc_symbol < 0x11_0000 {
|
|
size_utf8 ~mod+= bytes_read
|
|
}
|
|
}
|
|
return this.bc.f64_gt(
|
|
a: this.bc.f64_from_u64(a: size_utf8),
|
|
b: this.bc.f64_mul(a: LC_F64_UTF8_FRAC, b: this.bc.f64_from_u64(a: args.length))) <> 0
|
|
}
|
|
|
|
// Mirrors UTF8Position in literal_cost.c.
|
|
pri func encoder.utf8_position(last: base.u32, c: base.u32, clamp: base.u32) base.u32[..= 2] {
|
|
if args.c < 128 {
|
|
// Next one is the 'Byte 1' again.
|
|
return 0
|
|
} else if args.c >= 192 {
|
|
// Next one is the 'Byte 2' of utf-8 encoding.
|
|
return args.clamp.min(no_more_than: 1)
|
|
} else if args.last < 0xE0 {
|
|
// Completed two or three byte coding.
|
|
return 0
|
|
}
|
|
// Next one is the 'Byte 3' of utf-8 encoding.
|
|
return args.clamp.min(no_more_than: 2)
|
|
}
|
|
|
|
// Mirrors DecideMultiByteStatsLevel in literal_cost.c.
|
|
pri func encoder.decide_multi_byte_stats_level(wb: roslice base.u8, pos: base.u64, len: base.u64) base.u32 {
|
|
var counts1 : base.u64
|
|
var counts2 : base.u64
|
|
var max_utf8 : base.u32
|
|
var last_c : base.u32
|
|
var c : base.u32
|
|
var i : base.u64
|
|
var p : base.u32
|
|
|
|
// max_utf8 should be 2, but 1 compresses better.
|
|
max_utf8 = 1
|
|
while i < args.len {
|
|
c = this.rb_byte(wb: args.wb, pos: args.pos ~mod+ i) as base.u32
|
|
p = this.utf8_position(last: last_c, c: c, clamp: 2)
|
|
// C also counts p == 0 (counts[0]) but never uses that count.
|
|
if p == 1 {
|
|
counts1 ~mod+= 1
|
|
} else if p == 2 {
|
|
counts2 ~mod+= 1
|
|
}
|
|
last_c = c
|
|
i ~mod+= 1
|
|
}
|
|
if counts2 < 500 {
|
|
max_utf8 = 1
|
|
}
|
|
if (counts1 ~mod+ counts2) < 25 {
|
|
max_utf8 = 0
|
|
}
|
|
return max_utf8
|
|
}
|
|
|
|
// lc_finish_cost applies literal_cost.c's common tail to lit_cost (a double):
|
|
// the < 1.0 adjustment, the prologue_length adjustment (if utf8) and the
|
|
// conversion to float. It stores the float at args.wb[cost_off + (4 * i) ..].
|
|
pri func encoder.lc_finish_cost!(wb: slice base.u8, cost_off: base.u64, i: base.u64, lit_cost: base.u64, utf8: base.bool) {
|
|
var lit_cost : base.u64
|
|
|
|
lit_cost = args.lit_cost
|
|
if this.bc.f64_lt(a: lit_cost, b: LC_F64_1) <> 0 {
|
|
lit_cost = this.bc.f64_mul(a: lit_cost, b: LC_F64_0_5)
|
|
lit_cost = this.bc.f64_add(a: lit_cost, b: LC_F64_0_5)
|
|
}
|
|
// Make the first bytes more expensive -- seems to help, not sure why.
|
|
// Perhaps because the entropy source is changing its properties rapidly
|
|
// in the beginning of the file, perhaps because the beginning of the data
|
|
// is a statistical "anomaly".
|
|
if args.utf8 and (args.i < 2000) {
|
|
lit_cost = this.bc.f64_add(a: lit_cost, b: this.bc.f64_add(a: LC_F64_0_35,
|
|
b: this.bc.f64_mul(a: LC_F64_MULT, b: this.bc.f64_from_u64(a: args.i))))
|
|
}
|
|
this.poke_u32!(s: args.wb, i: args.cost_off ~mod+ (args.i ~mod* 4), v: this.sf.f64_to_f32(a: lit_cost))
|
|
}
|
|
|
|
// Mirrors EstimateBitCostsForLiteralsUTF8 in literal_cost.c.
|
|
pri func encoder.estimate_bit_costs_for_literals_utf8!(wb: slice base.u8, pos: base.u64, len: base.u64, cost_off: base.u64) {
|
|
var max_utf8 : base.u32
|
|
var window_half : base.u64[..= 495]
|
|
var in_window : base.u64
|
|
var iwu0 : base.u64
|
|
var iwu1 : base.u64
|
|
var iwu2 : base.u64
|
|
var i : base.u64
|
|
var last_c : base.u32
|
|
var c : base.u32
|
|
var utf8_pos : base.u32[..= 2]
|
|
var utf8_pos2 : base.u32[..= 2]
|
|
var histo : base.u64
|
|
var iw : base.u64
|
|
var lit_cost : base.u64
|
|
var hi : base.u32[..= 767]
|
|
|
|
// max_utf8 is 0 (normal ASCII single byte modeling), 1 (for 2-byte UTF-8
|
|
// modeling), or 2 (for 3-byte UTF-8 modeling).
|
|
max_utf8 = this.decide_multi_byte_stats_level(wb: args.wb, pos: args.pos, len: args.len)
|
|
window_half = 495
|
|
in_window = window_half.min(no_more_than: args.len)
|
|
hi = 0
|
|
while true {
|
|
this.lc_histogram[hi] = 0
|
|
if hi >= 767 {
|
|
break
|
|
}
|
|
hi += 1
|
|
}
|
|
|
|
// Bootstrap histograms.
|
|
i = 0
|
|
while i < in_window {
|
|
c = this.rb_byte(wb: args.wb, pos: args.pos ~mod+ i) as base.u32
|
|
this.lc_histogram[this.lc_hidx(pos2: utf8_pos, b: (c & 0xFF) as base.u8)] ~mod+= 1
|
|
if utf8_pos == 0 {
|
|
iwu0 ~mod+= 1
|
|
} else if utf8_pos == 1 {
|
|
iwu1 ~mod+= 1
|
|
} else {
|
|
iwu2 ~mod+= 1
|
|
}
|
|
utf8_pos = this.utf8_position(last: last_c, c: c, clamp: max_utf8)
|
|
last_c = c
|
|
i ~mod+= 1
|
|
}
|
|
|
|
// Compute bit costs with sliding window.
|
|
i = 0
|
|
while i < args.len {
|
|
if i >= window_half {
|
|
// Remove a byte in the past.
|
|
c = 0
|
|
if i >= (window_half + 1) {
|
|
c = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- (window_half + 1)) as base.u32
|
|
}
|
|
last_c = 0
|
|
if i >= (window_half + 2) {
|
|
last_c = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- (window_half + 2)) as base.u32
|
|
}
|
|
utf8_pos2 = this.utf8_position(last: last_c, c: c, clamp: max_utf8)
|
|
hi = this.lc_hidx(pos2: utf8_pos2, b: this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- window_half))
|
|
this.lc_histogram[hi] ~mod-= 1
|
|
if utf8_pos2 == 0 {
|
|
iwu0 ~mod-= 1
|
|
} else if utf8_pos2 == 1 {
|
|
iwu1 ~mod-= 1
|
|
} else {
|
|
iwu2 ~mod-= 1
|
|
}
|
|
}
|
|
if (i ~mod+ window_half) < args.len {
|
|
// Add a byte in the future.
|
|
c = this.rb_byte(wb: args.wb, pos: ((args.pos ~mod+ i) ~mod+ window_half) ~mod- 1) as base.u32
|
|
last_c = this.rb_byte(wb: args.wb, pos: ((args.pos ~mod+ i) ~mod+ window_half) ~mod- 2) as base.u32
|
|
utf8_pos2 = this.utf8_position(last: last_c, c: c, clamp: max_utf8)
|
|
hi = this.lc_hidx(pos2: utf8_pos2, b: this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod+ window_half))
|
|
this.lc_histogram[hi] ~mod+= 1
|
|
if utf8_pos2 == 0 {
|
|
iwu0 ~mod+= 1
|
|
} else if utf8_pos2 == 1 {
|
|
iwu1 ~mod+= 1
|
|
} else {
|
|
iwu2 ~mod+= 1
|
|
}
|
|
}
|
|
c = 0
|
|
if i >= 1 {
|
|
c = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- 1) as base.u32
|
|
}
|
|
last_c = 0
|
|
if i >= 2 {
|
|
last_c = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- 2) as base.u32
|
|
}
|
|
utf8_pos = this.utf8_position(last: last_c, c: c, clamp: max_utf8)
|
|
hi = this.lc_hidx(pos2: utf8_pos, b: this.rb_byte(wb: args.wb, pos: args.pos ~mod+ i))
|
|
histo = this.lc_histogram[hi] as base.u64
|
|
if histo == 0 {
|
|
histo = 1
|
|
}
|
|
iw = iwu0
|
|
if utf8_pos == 1 {
|
|
iw = iwu1
|
|
} else if utf8_pos == 2 {
|
|
iw = iwu2
|
|
}
|
|
lit_cost = this.bc.fast_log2_memo!(v: iw)
|
|
lit_cost = this.bc.f64_sub(a: lit_cost, b: this.bc.fast_log2(v: histo))
|
|
lit_cost = this.bc.f64_add(a: lit_cost, b: LC_F64_0_02905)
|
|
this.lc_finish_cost!(wb: args.wb, cost_off: args.cost_off, i: i, lit_cost: lit_cost, utf8: true)
|
|
i ~mod+= 1
|
|
}
|
|
}
|
|
|
|
// Mirrors BrotliEstimateBitCostsForLiterals in literal_cost.c. The len
|
|
// floats go to args.wb[cost_off ..].
|
|
pri func encoder.estimate_bit_costs_for_literals!(wb: slice base.u8, pos: base.u64, len: base.u64, cost_off: base.u64) {
|
|
var window_half : base.u64
|
|
var in_window : base.u64
|
|
var i : base.u64
|
|
var histo : base.u64
|
|
var lit_cost : base.u64
|
|
var hi : base.u32
|
|
var b : base.u8
|
|
var utf8 : base.bool
|
|
|
|
utf8 = this.is_mostly_utf8!(wb: args.wb, pos: args.pos, length: args.len)
|
|
if utf8 {
|
|
this.estimate_bit_costs_for_literals_utf8!(wb: args.wb, pos: args.pos, len: args.len, cost_off: args.cost_off)
|
|
return nothing
|
|
}
|
|
window_half = 2000
|
|
in_window = window_half.min(no_more_than: args.len)
|
|
hi = 0
|
|
while hi < 256 {
|
|
this.lc_histogram[hi] = 0
|
|
hi ~mod+= 1
|
|
}
|
|
|
|
// Bootstrap histogram.
|
|
i = 0
|
|
while i < in_window {
|
|
b = this.rb_byte(wb: args.wb, pos: args.pos ~mod+ i)
|
|
this.lc_histogram[b] ~mod+= 1
|
|
i ~mod+= 1
|
|
}
|
|
|
|
// Compute bit costs with sliding window.
|
|
i = 0
|
|
while i < args.len {
|
|
if i >= window_half {
|
|
// Remove a byte in the past.
|
|
b = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod- window_half)
|
|
this.lc_histogram[b] ~mod-= 1
|
|
in_window ~mod-= 1
|
|
}
|
|
if (i ~mod+ window_half) < args.len {
|
|
// Add a byte in the future.
|
|
b = this.rb_byte(wb: args.wb, pos: (args.pos ~mod+ i) ~mod+ window_half)
|
|
this.lc_histogram[b] ~mod+= 1
|
|
in_window ~mod+= 1
|
|
}
|
|
b = this.rb_byte(wb: args.wb, pos: args.pos ~mod+ i)
|
|
histo = this.lc_histogram[b] as base.u64
|
|
if histo == 0 {
|
|
histo = 1
|
|
}
|
|
lit_cost = this.bc.fast_log2_memo!(v: in_window)
|
|
lit_cost = this.bc.f64_sub(a: lit_cost, b: this.bc.fast_log2(v: histo))
|
|
lit_cost = this.bc.f64_add(a: lit_cost, b: LC_F64_0_029)
|
|
this.lc_finish_cost!(wb: args.wb, cost_off: args.cost_off, i: i, lit_cost: lit_cost, utf8: false)
|
|
i ~mod+= 1
|
|
}
|
|
}
|
|
|
|
// lc_hidx returns the histogram index (256 * pos2) + b.
|
|
pri func encoder.lc_hidx(pos2: base.u32[..= 2], b: base.u8) base.u32[..= 767] {
|
|
return (256 * args.pos2) + (args.b as base.u32)
|
|
}
|