mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Add the metablock_builder struct, mirroring BrotliSplitBlock (with its MyRand sampling, InitialEntropyCodes, RefineEntropyCodes, FindBlocks, RemapBlockIds, BuildBlockHistograms and ClusterBlocks), the histogram clustering functions (BrotliCompareAndPushToQueue, BrotliHistogramCombine, BrotliHistogramBitCostDistance, BrotliHistogramRemap, BrotliHistogramReindex, BrotliClusterHistograms), BrotliInitDistanceParams, BrotliBuildMetaBlock (including the distance parameter search) and BrotliOptimizeHistograms (with BrotliOptimizeHuffmanCountsForRle). All memory that the C code allocates lives in a caller-supplied workbuf, carved out by a bump allocator. bit_cost gets an optional 64Ki-entry FastLog2 cache (filled by the same softfloat log2), which makes the clustering several times faster. Extend the metablock_tester and the parity harness to compare SplitBlock, ClusterHistograms*, BuildMetaBlock and OptimizeHistograms results with libbrotlienc v1.2.1.
356 lines
12 KiB
Plaintext
356 lines
12 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 bit_cost.c, bit_cost_inc.h and fast_log.h. The functions
|
|
// are methods of the bit_cost struct (whose only state is the stateless
|
|
// softfloat arith), so that other structs (the encoder, the
|
|
// metablock_builder) can embed one with a single field.
|
|
//
|
|
// Doubles are IEEE 754 binary64 bit patterns (base.u64). A uint32_t array
|
|
// (e.g. a histogram's data_) is a slice of little-endian bytes, because
|
|
// Wuffs' C code generator does not support "slice base.u32" arguments.
|
|
//
|
|
// A histogram (the C code's HistogramLiteral, HistogramCommand and
|
|
// HistogramDistance structs) is (4 * data_size) + 16 bytes, exactly the C
|
|
// struct's memory layout on a 64-bit little-endian machine:
|
|
//
|
|
// [0 .. 4 * data_size) data_, as u32le values
|
|
// [4 * data_size .. (4 * data_size) + 8) total_count_, as a u64le
|
|
// [(4 * data_size) + 8 .. (4 * data_size) + 16) bit_cost_, as the u64le
|
|
// bits of a binary64
|
|
//
|
|
// data_size is 256 (HISTOGRAM_LITERAL_DATA_SIZE), 704
|
|
// (HISTOGRAM_COMMAND_DATA_SIZE) or 544 (HISTOGRAM_DISTANCE_DATA_SIZE). The C
|
|
// code's templated functions (the FN(X) macros, instantiated three times) are
|
|
// one Wuffs function each, with a data_size argument.
|
|
|
|
pri const HISTOGRAM_LITERAL_DATA_SIZE : base.u32 = 256
|
|
pri const HISTOGRAM_COMMAND_DATA_SIZE : base.u32 = 704
|
|
pri const HISTOGRAM_DISTANCE_DATA_SIZE : base.u32 = 544
|
|
|
|
// The byte sizes of the three histogram types.
|
|
pri const HISTOGRAM_LITERAL_SIZE : base.u64 = 1040
|
|
pri const HISTOGRAM_COMMAND_SIZE : base.u64 = 2832
|
|
pri const HISTOGRAM_DISTANCE_SIZE : base.u64 = 2192
|
|
|
|
// F64_HUGE_VAL is +infinity (the C code's HUGE_VAL).
|
|
pri const F64_HUGE_VAL : base.u64 = 0x7FF0_0000_0000_0000
|
|
|
|
// F64_1E99 is the C code's 1e99.
|
|
pri const F64_1E99 : base.u64 = 0x547D_42AE_A287_9F2E
|
|
|
|
// LOG2_CACHE_SIZE is the size of the bit_cost.log2_cache table.
|
|
pri const LOG2_CACHE_SIZE : base.u64 = 65536
|
|
|
|
pri struct bit_cost?(
|
|
// log2_cache_ready is whether log2_cache has been filled (by
|
|
// init_log2_cache).
|
|
log2_cache_ready : base.bool,
|
|
|
|
sf : softfloat.arith,
|
|
) + (
|
|
// log2_cache[v] is FastLog2(v), for v < LOG2_CACHE_SIZE. It is only a
|
|
// speed optimization (glibc's log2 is expensive to emulate): the
|
|
// values are computed by the same functions, so the results are
|
|
// identical with or without it.
|
|
log2_cache : array[65536] base.u64,
|
|
)
|
|
|
|
// init_log2_cache fills the log2_cache table (if it is not already filled).
|
|
// Calling it is optional, but it makes fast_log2 faster.
|
|
pri func bit_cost.init_log2_cache!() {
|
|
var v : base.u64
|
|
|
|
if this.log2_cache_ready {
|
|
return nothing
|
|
}
|
|
v = 0
|
|
while v < 256 {
|
|
this.log2_cache[v] = LOG2_TABLE[v]
|
|
v += 1
|
|
}
|
|
while v < 65536 {
|
|
this.log2_cache[v] = this.sf.log2_u64(v: v)
|
|
v += 1
|
|
}
|
|
this.log2_cache_ready = true
|
|
}
|
|
|
|
// ld32 returns the u32le at s[i ..], or 0 if that is out of bounds (which
|
|
// the callers never do).
|
|
pri func bit_cost.ld32(s: roslice base.u8, i: base.u64) base.u32 {
|
|
var q : roslice base.u8
|
|
|
|
if args.i < args.s.length() {
|
|
q = args.s[args.i ..]
|
|
if q.length() >= 4 {
|
|
return q.peek_u32le()
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// ld64 is like ld32 but for a u64le.
|
|
pri func bit_cost.ld64(s: roslice base.u8, i: base.u64) base.u64 {
|
|
var q : roslice base.u8
|
|
|
|
if args.i < args.s.length() {
|
|
q = args.s[args.i ..]
|
|
if q.length() >= 8 {
|
|
return q.peek_u64le()
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// st32 stores v as a u32le at s[i ..], or does nothing if that is out of
|
|
// bounds (which the callers never do).
|
|
pri func bit_cost.st32!(s: slice base.u8, i: base.u64, v: base.u32) {
|
|
var q : slice base.u8
|
|
|
|
if args.i < args.s.length() {
|
|
q = args.s[args.i ..]
|
|
if q.length() >= 4 {
|
|
q.poke_u32le!(a: args.v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// st64 is like st32 but for a u64le.
|
|
pri func bit_cost.st64!(s: slice base.u8, i: base.u64, v: base.u64) {
|
|
var q : slice base.u8
|
|
|
|
if args.i < args.s.length() {
|
|
q = args.s[args.i ..]
|
|
if q.length() >= 8 {
|
|
q.poke_u64le!(a: args.v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mirrors FastLog2 in fast_log.h. The result is the bit pattern of an IEEE
|
|
// 754 binary64 value.
|
|
pri func bit_cost.fast_log2(v: base.u64) base.u64 {
|
|
if args.v < 256 {
|
|
return LOG2_TABLE[args.v]
|
|
} else if this.log2_cache_ready and (args.v < 65536) {
|
|
return this.log2_cache[args.v]
|
|
}
|
|
return this.sf.log2_u64(v: args.v)
|
|
}
|
|
|
|
// Mirrors BrotliBitsEntropy in bit_cost.c. population holds (at least) size
|
|
// u32le values. The C code's "goto odd_number_of_elements_left" only changes
|
|
// the loop's unrolling, not the order of the operations.
|
|
pri func bit_cost.bits_entropy(population: roslice base.u8, size: base.u64) base.u64 {
|
|
var sum : base.u64
|
|
var retval : base.u64
|
|
var p : base.u64
|
|
var q : roslice base.u8
|
|
var n : base.u64
|
|
|
|
q = args.population
|
|
n = args.size
|
|
while n > 0 {
|
|
n -= 1
|
|
p = 0
|
|
if q.length() >= 4 {
|
|
p = q.peek_u32le() as base.u64
|
|
q = q[4 ..]
|
|
}
|
|
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.fast_log2(v: p)))
|
|
}
|
|
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.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 BrotliPopulationCostLiteral, BrotliPopulationCostCommand and
|
|
// BrotliPopulationCostDistance (FN(BrotliPopulationCost) in bit_cost_inc.h).
|
|
// histogram is a histogram of data_size symbols (see the layout above).
|
|
pri func bit_cost.population_cost(histogram: roslice base.u8, data_size: base.u32[..= 704]) base.u64 {
|
|
var total : base.u64
|
|
var count : base.u32
|
|
var s : array[4] base.u32
|
|
var bits : base.u64
|
|
var i : base.u32
|
|
var j : base.u32
|
|
var k : base.u32
|
|
var c : base.u32
|
|
var histo : array[4] base.u32
|
|
var h0 : base.u32
|
|
var h1 : base.u32
|
|
var h2 : base.u32
|
|
var h23 : base.u32
|
|
var histomax : base.u32
|
|
var max_depth : base.u64[..= 15]
|
|
var depth_histo : array[18] base.u32
|
|
var log2total : base.u64
|
|
var log2p : base.u64
|
|
var depth : base.u64
|
|
var reps : base.u32
|
|
var sum : base.u64
|
|
var retval : base.u64
|
|
var p : base.u64
|
|
|
|
total = this.ld64(s: args.histogram, i: (args.data_size as base.u64) * 4)
|
|
if total == 0 {
|
|
// kOneSymbolHistogramCost.
|
|
return 0x4028_0000_0000_0000
|
|
}
|
|
i = 0
|
|
while i < args.data_size {
|
|
if this.ld32(s: args.histogram, i: (i as base.u64) * 4) > 0 {
|
|
if count < 4 {
|
|
s[count] = i
|
|
}
|
|
count ~mod+= 1
|
|
if count > 4 {
|
|
break
|
|
}
|
|
}
|
|
i ~mod+= 1
|
|
}
|
|
if count == 1 {
|
|
// kOneSymbolHistogramCost.
|
|
return 0x4028_0000_0000_0000
|
|
}
|
|
if count == 2 {
|
|
// kTwoSymbolHistogramCost + (double)total_count_.
|
|
return this.sf.f64_add(a: 0x4034_0000_0000_0000, b: this.sf.f64_from_u64(a: total))
|
|
}
|
|
if count == 3 {
|
|
h0 = this.ld32(s: args.histogram, i: (s[0] as base.u64) * 4)
|
|
h1 = this.ld32(s: args.histogram, i: (s[1] as base.u64) * 4)
|
|
h2 = this.ld32(s: args.histogram, i: (s[2] as base.u64) * 4)
|
|
histomax = h0.max(no_less_than: h1.max(no_less_than: h2))
|
|
// kThreeSymbolHistogramCost + 2 * (histo0 + histo1 + histo2) -
|
|
// histomax, where the integer expression is uint32_t arithmetic.
|
|
return this.sf.f64_sub(
|
|
a: this.sf.f64_add(
|
|
a: 0x403C_0000_0000_0000,
|
|
b: this.sf.f64_from_u32(a: 2 ~mod* ((h0 ~mod+ h1) ~mod+ h2))),
|
|
b: this.sf.f64_from_u32(a: histomax))
|
|
}
|
|
if count == 4 {
|
|
i = 0
|
|
while i < 4 {
|
|
histo[i] = this.ld32(s: args.histogram, i: (s[i] as base.u64) * 4)
|
|
i ~mod+= 1
|
|
}
|
|
// Sort.
|
|
i = 0
|
|
while i < 4 {
|
|
j = i ~mod+ 1
|
|
while j < 4 {
|
|
if histo[j] > histo[i & 3] {
|
|
k = histo[j]
|
|
histo[j] = histo[i & 3]
|
|
histo[i & 3] = k
|
|
}
|
|
j ~mod+= 1
|
|
}
|
|
i ~mod+= 1
|
|
}
|
|
h23 = histo[2] ~mod+ histo[3]
|
|
histomax = h23.max(no_less_than: histo[0])
|
|
// kFourSymbolHistogramCost + 3 * h23 + 2 * (histo[0] + histo[1]) -
|
|
// histomax, evaluated left to right.
|
|
return this.sf.f64_sub(
|
|
a: this.sf.f64_add(
|
|
a: this.sf.f64_add(
|
|
a: 0x4042_8000_0000_0000,
|
|
b: this.sf.f64_from_u32(a: 3 ~mod* h23)),
|
|
b: this.sf.f64_from_u32(a: 2 ~mod* (histo[0] ~mod+ histo[1]))),
|
|
b: this.sf.f64_from_u32(a: histomax))
|
|
}
|
|
|
|
// Compute the entropy of the histogram and simultaneously build a
|
|
// simplified histogram of the code length codes.
|
|
max_depth = 1
|
|
log2total = this.fast_log2(v: total)
|
|
i = 0
|
|
while i < args.data_size {
|
|
c = this.ld32(s: args.histogram, i: (i as base.u64) * 4)
|
|
if c > 0 {
|
|
log2p = this.sf.f64_sub(a: log2total, b: this.fast_log2(v: c as base.u64))
|
|
depth = this.sf.f64_to_u64_trunc(a: this.sf.f64_add(a: log2p, b: 0x3FE0_0000_0000_0000))
|
|
bits = this.sf.f64_add(a: bits, b: this.sf.f64_mul(
|
|
a: this.sf.f64_from_u32(a: c), b: log2p))
|
|
if depth > 15 {
|
|
depth = 15
|
|
}
|
|
if depth > (max_depth as base.u64) {
|
|
max_depth = depth & 15
|
|
}
|
|
depth_histo[depth & 15] ~mod+= 1
|
|
i ~mod+= 1
|
|
} else {
|
|
// Compute the run length of zeros.
|
|
reps = 1
|
|
k = i ~mod+ 1
|
|
while k < args.data_size {
|
|
if this.ld32(s: args.histogram, i: (k as base.u64) * 4) <> 0 {
|
|
break
|
|
}
|
|
reps ~mod+= 1
|
|
k ~mod+= 1
|
|
}
|
|
i ~sat+= reps
|
|
if i >= args.data_size {
|
|
// Don't add any cost for the last zero run.
|
|
break
|
|
}
|
|
if reps < 3 {
|
|
depth_histo[0] ~mod+= reps
|
|
} else {
|
|
reps -= 2
|
|
while reps > 0 {
|
|
depth_histo[17] ~mod+= 1
|
|
// Add the 3 extra bits for the 17 code length code.
|
|
bits = this.sf.f64_add(a: bits, b: 0x4008_0000_0000_0000)
|
|
reps >>= 3
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Add the estimated encoding cost of the code length code histogram.
|
|
bits = this.sf.f64_add(a: bits, b: this.sf.f64_from_u64(a: 18 + (2 * max_depth)))
|
|
|
|
// Add the entropy of the code length code histogram. This is
|
|
// BrotliBitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES), inlined
|
|
// because depth_histo is a local array.
|
|
i = 0
|
|
while i < 18 {
|
|
p = depth_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.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.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 this.sf.f64_add(a: bits, b: retval)
|
|
}
|