mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
797 lines
28 KiB
Plaintext
797 lines
28 KiB
Plaintext
// Copyright 2022 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.
|
||
|
||
pub status "#bad Huffman code (over-subscribed)"
|
||
pub status "#bad Huffman code (under-subscribed)"
|
||
pub status "#bad block header"
|
||
pub status "#bad block length"
|
||
pub status "#bad checksum"
|
||
pub status "#bad header"
|
||
pub status "#bad number of sections"
|
||
pub status "#truncated input"
|
||
pub status "#unsupported block randomization"
|
||
|
||
pri status "#internal error: inconsistent Huffman decoder state"
|
||
|
||
pub const DECODER_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0
|
||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
|
||
|
||
pri const CLAMP_TO_5 : roarray[8] base.u8[..= 5] = [0, 1, 2, 3, 4, 5, 5, 5]
|
||
|
||
pub struct decoder? implements base.io_transformer(
|
||
bits : base.u32,
|
||
n_bits : base.u32[..= 31],
|
||
|
||
// Block size is measured prior to the RLE1 step.
|
||
max_incl_block_size : base.u32[..= 900000],
|
||
|
||
block_size : base.u32[..= 900000],
|
||
decode_huffman_finished : base.bool,
|
||
decode_huffman_which : base.u8[..= 5],
|
||
decode_huffman_ticks : base.u32[..= 50],
|
||
decode_huffman_section : base.u32,
|
||
decode_huffman_run_shift : base.u32[..= 23],
|
||
|
||
flush_pointer : base.u32[..= 1_048575],
|
||
flush_repeat_count : base.u32[..= 255],
|
||
flush_prev : base.u8,
|
||
|
||
ignore_checksum : base.bool,
|
||
final_checksum_have : base.u32,
|
||
block_checksum_have : base.u32,
|
||
block_checksum_want : base.u32,
|
||
original_pointer : base.u32,
|
||
num_symbols : base.u32[..= 258],
|
||
num_huffman_codes : base.u32[..= 6],
|
||
num_sections : base.u32[..= 18001],
|
||
code_lengths_bitmask : base.u32,
|
||
|
||
util : base.utility,
|
||
) + (
|
||
scratch : base.u32,
|
||
|
||
letter_counts : array[256] base.u32,
|
||
|
||
// presence[i] being non-zero is whether the byte value i occurs in the
|
||
// block's decompressed output.
|
||
presence : array[256] base.u8,
|
||
|
||
// mtft is the Move To Front Transform state.
|
||
mtft : array[256] base.u8,
|
||
|
||
// huffman_selectors selects which of the huffman_trees to use for each
|
||
// 50-symbol section.
|
||
huffman_selectors : array[32768] base.u8,
|
||
|
||
// Each array[2] base.u16 is a branch node in the Huffman tree. The
|
||
// build_huffman_tree method comment details what the base.u16 values mean.
|
||
//
|
||
// Each Huffman tree has num_symbols leaf nodes and hence (num_symbols - 1)
|
||
// branch nodes, also called internal nodes, as per
|
||
// https://stackoverflow.com/questions/69399994/maximum-number-of-nodes-in-a-huffman-tree/69401083#69401083
|
||
//
|
||
// This can be proven inductively. The base case Huffman code (two symbols)
|
||
// has one branch node (the root node). The inductive case, adding one
|
||
// symbol to a (complete but possibly non-canonical) Huffman code replaces
|
||
// one leaf node with one branch node (and two leaf nodes). The net gain in
|
||
// branch nodes is +1.
|
||
//
|
||
// Since num_symbols' inclusive maximum is 258 (for RUNA, RUNB, 255 × mXYZ,
|
||
// EOB), there are at most 257 branch nodes.
|
||
huffman_trees : array[6] array[257] array[2] base.u16,
|
||
|
||
// huffman_tables[which] caches the result of walking huffman_trees[which]
|
||
// for each possible 8-bit input. The base.u16 value decomposes as:
|
||
// - The low 10 bits are the final node, where finality comes either from
|
||
// hitting a leaf node or from spending all 8 bits of the input. As per
|
||
// the build_huffman_tree method, a value of 0x100 = 256 or less means
|
||
// a branch node and 0x201 = 513 or more means a leaf node.
|
||
// - The middle 2 bits are unused.
|
||
// - The high 4 bits are the number of input bits spent.
|
||
huffman_tables : array[6] array[256] base.u16,
|
||
|
||
// bwt is the Burrows Wheeler Transform state. Per the README.md file, each
|
||
// entry is a row with the low 8 bits holding the L column and the high 20
|
||
// bits holding the U column. The middle 4 bits are unused.
|
||
//
|
||
// The read_code_lengths and build_huffman_tree methods also re-purpose
|
||
// this buffer to temporarily hold up to 258 symbols' code lengths.
|
||
bwt : array[1_048576] base.u32,
|
||
)
|
||
|
||
pub func decoder.get_quirk(key: base.u32) base.u64 {
|
||
return 0
|
||
}
|
||
|
||
pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status {
|
||
if args.key == base.QUIRK_IGNORE_CHECKSUM {
|
||
this.ignore_checksum = args.value > 0
|
||
return ok
|
||
}
|
||
return base."#unsupported option"
|
||
}
|
||
|
||
pub func decoder.history_retain_length() base.u64 {
|
||
return 0
|
||
}
|
||
|
||
pub func decoder.workbuf_len() base.range_ii_u64 {
|
||
return this.util.make_range_ii_u64(
|
||
min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE,
|
||
max_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE)
|
||
}
|
||
|
||
pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
|
||
var status : base.status
|
||
|
||
while true {
|
||
status =? this.do_transform_io?(dst: args.dst, src: args.src, workbuf: args.workbuf)
|
||
if (status == base."$short read") and args.src.is_closed() {
|
||
return "#truncated input"
|
||
}
|
||
yield? status
|
||
} endwhile
|
||
}
|
||
|
||
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
|
||
var c : base.u8
|
||
var i : base.u32
|
||
var tag : base.u64
|
||
var status : base.status
|
||
var final_checksum_want : base.u32
|
||
|
||
// Read the header.
|
||
c = args.src.read_u8?()
|
||
if c <> 0x42 {
|
||
return "#bad header"
|
||
}
|
||
c = args.src.read_u8?()
|
||
if c <> 0x5A {
|
||
return "#bad header"
|
||
}
|
||
c = args.src.read_u8?()
|
||
if c <> 0x68 {
|
||
return "#bad header"
|
||
}
|
||
c = args.src.read_u8?()
|
||
if (c < '1') or ('9' < c) {
|
||
return "#bad header"
|
||
}
|
||
this.max_incl_block_size = ((c - '0') as base.u32) * 100000
|
||
|
||
while true {
|
||
// Read the 48-bit tag.
|
||
tag = 0
|
||
i = 0
|
||
while i < 48 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
tag ~mod<<= 1
|
||
tag |= (this.bits >> 31) as base.u64
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
|
||
if tag == 0x1772_4538_5090 {
|
||
break
|
||
} else if tag <> 0x3141_5926_5359 {
|
||
return "#bad block header"
|
||
}
|
||
|
||
this.prepare_block?(src: args.src)
|
||
|
||
this.block_size = 0
|
||
this.decode_huffman_finished = false
|
||
this.decode_huffman_which = CLAMP_TO_5[this.huffman_selectors[0] & 7]
|
||
this.decode_huffman_ticks = 50
|
||
this.decode_huffman_section = 0
|
||
this.decode_huffman_run_shift = 0
|
||
while not this.decode_huffman_finished {
|
||
status = this.decode_huffman_fast!(src: args.src)
|
||
if status.is_error() {
|
||
return status
|
||
} else if this.decode_huffman_finished {
|
||
break
|
||
}
|
||
this.decode_huffman_slow?(src: args.src)
|
||
} endwhile
|
||
|
||
this.invert_bwt!()
|
||
|
||
this.block_checksum_have = 0xFFFF_FFFF
|
||
if this.original_pointer >= this.block_size {
|
||
return "#bad block length"
|
||
}
|
||
assert this.original_pointer < 900000 via "a < b: a < c; c <= b"(c: this.block_size)
|
||
this.flush_pointer = this.bwt[this.original_pointer] >> 12
|
||
this.flush_repeat_count = 0
|
||
this.flush_prev = 0
|
||
|
||
while this.block_size > 0 {
|
||
this.flush_fast!(dst: args.dst)
|
||
if this.block_size <= 0 {
|
||
break
|
||
}
|
||
this.flush_slow?(dst: args.dst)
|
||
} endwhile
|
||
|
||
this.block_checksum_have ^= 0xFFFF_FFFF
|
||
if (not this.ignore_checksum) and (this.block_checksum_have <> this.block_checksum_want) {
|
||
return "#bad checksum"
|
||
}
|
||
this.final_checksum_have = this.block_checksum_have ^ (
|
||
(this.final_checksum_have >> 31) |
|
||
(this.final_checksum_have ~mod<< 1))
|
||
} endwhile
|
||
|
||
// Read the 32-bit final checksum.
|
||
final_checksum_want = 0
|
||
i = 0
|
||
while i < 32 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
final_checksum_want ~mod<<= 1
|
||
final_checksum_want |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
if (not this.ignore_checksum) and (this.final_checksum_have <> final_checksum_want) {
|
||
return "#bad checksum"
|
||
}
|
||
}
|
||
|
||
pri func decoder.prepare_block?(src: base.io_reader) {
|
||
var c : base.u8
|
||
var i : base.u32
|
||
var j : base.u32
|
||
var selector : base.u32
|
||
var sel_ff : base.u32
|
||
var movee : base.u8
|
||
var status : base.status
|
||
|
||
// Read the 32-bit block checksum.
|
||
this.block_checksum_want = 0
|
||
i = 0
|
||
while i < 32 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
this.block_checksum_want ~mod<<= 1
|
||
this.block_checksum_want |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Read the "block randomized" bit.
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
if (this.bits >> 31) <> 0 {
|
||
return "#unsupported block randomization"
|
||
}
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
|
||
// Read the 24-bit original pointer. The BWT technical report calls this I.
|
||
this.original_pointer = 0
|
||
i = 0
|
||
while i < 24 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
this.original_pointer ~mod<<= 1
|
||
this.original_pointer |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Reset the presence bitmap.
|
||
i = 0
|
||
while i < 256 {
|
||
this.presence[i] = 0
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Read the 16-bit high-level presence bitmap.
|
||
i = 0
|
||
while i < 256 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
if (this.bits >> 31) <> 0 {
|
||
this.presence[i] = 1
|
||
}
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 16
|
||
} endwhile
|
||
|
||
// Read the 16-bit low-level presence bitmaps.
|
||
this.scratch = 0
|
||
i = 0
|
||
while i < 256 {
|
||
if this.presence[i] == 0 {
|
||
i += 16
|
||
continue
|
||
}
|
||
while true {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
this.scratch ~mod+= this.bits >> 31
|
||
this.presence[i & 0xFF] = (this.bits >> 31) as base.u8
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i ~mod+= 1
|
||
if (i & 15) == 0 {
|
||
break
|
||
}
|
||
} endwhile
|
||
} endwhile
|
||
if (this.scratch < 1) or (256 < this.scratch) {
|
||
return "#bad block header"
|
||
}
|
||
this.num_symbols = this.scratch + 2
|
||
|
||
// Read the 3-bit number of Huffman codes.
|
||
this.scratch = 0
|
||
i = 0
|
||
while i < 3 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
this.scratch ~mod<<= 1
|
||
this.scratch |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
if (this.scratch < 2) or (6 < this.scratch) {
|
||
return "#bad block header"
|
||
}
|
||
this.num_huffman_codes = this.scratch
|
||
|
||
// Read the 15-bit number of sections.
|
||
this.scratch = 0
|
||
i = 0
|
||
while i < 15 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
this.scratch ~mod<<= 1
|
||
this.scratch |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
if (this.scratch < 1) or (18001 < this.scratch) {
|
||
return "#bad block header"
|
||
}
|
||
this.num_sections = this.scratch
|
||
|
||
// Initialize the MTFT state.
|
||
i = 0
|
||
while i < this.num_huffman_codes {
|
||
assert i < 6 via "a < b: a < c; c <= b"(c: this.num_huffman_codes)
|
||
this.mtft[i] = i as base.u8
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Read each section's Huffman code selector, applying the MTFT.
|
||
i = 0
|
||
while i < this.num_sections {
|
||
assert i < 18001 via "a < b: a < c; c <= b"(c: this.num_sections)
|
||
selector = 0
|
||
|
||
// Read a unary encoded natural number.
|
||
while true,
|
||
inv i < 18001,
|
||
{
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
if (this.bits >> 31) == 0 {
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
break
|
||
}
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
selector ~mod+= 1
|
||
if selector >= this.num_huffman_codes {
|
||
return "#bad block header"
|
||
}
|
||
} endwhile
|
||
|
||
// Move to front.
|
||
if selector == 0 {
|
||
this.huffman_selectors[i] = this.mtft[0]
|
||
} else {
|
||
sel_ff = selector & 0xFF
|
||
movee = this.mtft[sel_ff]
|
||
this.mtft[1 .. 1 + sel_ff].copy_from_slice!(
|
||
s: this.mtft[.. sel_ff])
|
||
this.mtft[0] = movee
|
||
this.huffman_selectors[i] = movee
|
||
}
|
||
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Read the Huffman codes.
|
||
i = 0
|
||
while i < this.num_huffman_codes {
|
||
assert i < 6 via "a < b: a < c; c <= b"(c: this.num_huffman_codes)
|
||
this.read_code_lengths?(src: args.src)
|
||
status = this.build_huffman_tree!(which: i)
|
||
if status.is_error() {
|
||
return status
|
||
}
|
||
this.build_huffman_table!(which: i)
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Initialize the MTFT state.
|
||
i = 0
|
||
j = 0
|
||
while i < 256 {
|
||
if this.presence[i] <> 0 {
|
||
this.mtft[j & 0xFF] = i as base.u8
|
||
j ~mod+= 1
|
||
}
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Initialize the letter counts.
|
||
i = 0
|
||
while i < 256 {
|
||
this.letter_counts[i] = 0
|
||
i += 1
|
||
} endwhile
|
||
}
|
||
|
||
pri func decoder.read_code_lengths?(src: base.io_reader) {
|
||
var c : base.u8
|
||
var i : base.u32
|
||
var code_length : base.u32
|
||
|
||
this.code_lengths_bitmask = 0
|
||
|
||
// Read the 5-bit starting value.
|
||
i = 0
|
||
while i < 5 {
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
code_length ~mod<<= 1
|
||
code_length |= this.bits >> 31
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Read the code lengths.
|
||
i = 0
|
||
while i < this.num_symbols {
|
||
assert i < 258 via "a < b: a < c; c <= b"(c: this.num_symbols)
|
||
while true,
|
||
inv i < 258,
|
||
{
|
||
if (code_length < 1) or (20 < code_length) {
|
||
return "#bad block header"
|
||
}
|
||
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
if (this.bits >> 31) == 0 {
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
break
|
||
}
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
|
||
if this.n_bits <= 0 {
|
||
c = args.src.read_u8?()
|
||
this.bits = (c as base.u32) << 24
|
||
this.n_bits = 8
|
||
assert this.n_bits > 0
|
||
}
|
||
if (this.bits >> 31) == 0 {
|
||
code_length ~mod+= 1
|
||
} else {
|
||
code_length ~mod-= 1
|
||
}
|
||
this.bits ~mod<<= 1
|
||
this.n_bits -= 1
|
||
} endwhile
|
||
|
||
this.code_lengths_bitmask |= (1 as base.u32) << (code_length & 31)
|
||
this.bwt[i] = code_length
|
||
i += 1
|
||
} endwhile
|
||
}
|
||
|
||
// build_huffman_tree builds a canonical Huffman tree given the symbols' code
|
||
// lengths. For the "abraca.txt.bz2" example, the code lengths are:
|
||
// - symbol=0x301 (RUNA) cl=3
|
||
// - symbol=0x302 (RUNB) cl=3
|
||
// - symbol=0x201 (m01) cl=2
|
||
// - symbol=0x202 (m02) cl=3
|
||
// - symbol=0x203 (m03) cl=2
|
||
// - symbol=0x300 (EOB) cl=3
|
||
//
|
||
// The bitstring mapping is:
|
||
// - "00" 0x201 (m01)
|
||
// - "01" 0x203 (m03)
|
||
// - "100" 0x301 (RUNA)
|
||
// - "101" 0x302 (RUNB)
|
||
// - "110" 0x202 (m02)
|
||
// - "111" 0x300 (EOB)
|
||
//
|
||
// The Huffman tree has 5 branch nodes (where 5+1 is both the number of leaf
|
||
// nodes and the number of symbols). Each branch node has two children,
|
||
// represented by a base.u16 value. 0x100 = 256 or less means that the child is
|
||
// a branch node. 0x201 ..= 0x2FF means an mNN leaf node. 0x300, 0x301 and
|
||
// 0x302 mean EOB, RUNA and RUNB leaf nodes.
|
||
// - node0 = [0x001 (node1), 0x002 (node2)]
|
||
// - node1 = [0x201 (m01) , 0x203 (m03) ]
|
||
// - node2 = [0x003 (node3), 0x004 (node4)]
|
||
// - node3 = [0x301 (RUNA) , 0x302 (RUNB) ]
|
||
// - node4 = [0x202 (m02) , 0x300 (EOB) ]
|
||
//
|
||
// For example, the tree walk from node0 right (1) to node2 left (0) to node3
|
||
// left (0) to RUNA means that the RUNA bitstring is "100".
|
||
//
|
||
// The tree is built incrementally by considering symbols in increasing code
|
||
// length order, maintaining a stack of nodes that's the path from the root
|
||
// (node0) to the latest created-but-unfinished node. Created means that their
|
||
// left child is assigned (non-zero). Unfinished means that their right child
|
||
// is pending (zero). For example, after adding the 0x201, 0x203 and 0x301
|
||
// symbols, we would have this (in-progress) tree:
|
||
// - node0 = [0x001 (node1), 0x002 (node2)]
|
||
// - node1 = [0x201 (m01) , 0x203 (m03) ]
|
||
// - node2 = [0x003 (node3), 0 ]
|
||
// - node3 = [0x301 (RUNA) , 0 ]
|
||
//
|
||
// The stack would be [node0, node2, node3]. The next symbol would fill in the
|
||
// top of the stack, node3. If that symbol's code length matches the stack
|
||
// height (here, 3) then it would pop the stack. Otherwise it would push new
|
||
// nodes onto the stack until the stack height matched that code length.
|
||
pri func decoder.build_huffman_tree!(which: base.u32[..= 5]) base.status {
|
||
var code_length : base.u32
|
||
var symbol_index : base.u32
|
||
var num_branch_nodes : base.u32[..= 257]
|
||
var stack_height : base.u32[..= 21]
|
||
var stack_values : array[21] base.u32[..= 256]
|
||
var node_index : base.u32[..= 256]
|
||
var leaf_value : base.u16
|
||
|
||
// Push a root node.
|
||
this.huffman_trees[args.which][0][0] = 0
|
||
this.huffman_trees[args.which][0][1] = 0
|
||
num_branch_nodes = 1
|
||
stack_height = 1
|
||
stack_values[0] = 0
|
||
|
||
code_length = 1
|
||
while code_length <= 20 {
|
||
if (this.code_lengths_bitmask & ((1 as base.u32) << code_length)) == 0 {
|
||
code_length += 1
|
||
continue
|
||
}
|
||
symbol_index = 0
|
||
while symbol_index < this.num_symbols,
|
||
inv code_length <= 20,
|
||
{
|
||
assert symbol_index < 258 via "a < b: a < c; c <= b"(c: this.num_symbols)
|
||
if this.bwt[symbol_index] <> code_length {
|
||
symbol_index += 1
|
||
continue
|
||
}
|
||
|
||
while true,
|
||
inv code_length <= 20,
|
||
inv symbol_index < 258,
|
||
post stack_height > 0,
|
||
{
|
||
if stack_height <= 0 {
|
||
return "#bad Huffman code (over-subscribed)"
|
||
} else if stack_height >= code_length {
|
||
break
|
||
}
|
||
assert stack_height < 20 via "a < b: a < c; c <= b"(c: code_length)
|
||
|
||
node_index = stack_values[stack_height - 1]
|
||
if this.huffman_trees[args.which][node_index][0] == 0 {
|
||
this.huffman_trees[args.which][node_index][0] = num_branch_nodes as base.u16
|
||
} else {
|
||
this.huffman_trees[args.which][node_index][1] = num_branch_nodes as base.u16
|
||
}
|
||
if num_branch_nodes >= 257 {
|
||
return "#bad Huffman code (under-subscribed)"
|
||
}
|
||
stack_values[stack_height] = num_branch_nodes
|
||
this.huffman_trees[args.which][num_branch_nodes][0] = 0
|
||
this.huffman_trees[args.which][num_branch_nodes][1] = 0
|
||
num_branch_nodes += 1
|
||
stack_height += 1
|
||
} endwhile
|
||
|
||
node_index = stack_values[stack_height - 1]
|
||
if symbol_index < 2 {
|
||
leaf_value = (0x301 + symbol_index) as base.u16
|
||
} else if (symbol_index + 1) < this.num_symbols {
|
||
leaf_value = (0x1FF + symbol_index) as base.u16
|
||
} else {
|
||
leaf_value = 0x300
|
||
}
|
||
|
||
if this.huffman_trees[args.which][node_index][0] == 0 {
|
||
this.huffman_trees[args.which][node_index][0] = leaf_value
|
||
} else {
|
||
this.huffman_trees[args.which][node_index][1] = leaf_value
|
||
stack_height -= 1
|
||
while stack_height > 0,
|
||
inv code_length <= 20,
|
||
inv symbol_index < 258,
|
||
{
|
||
node_index = stack_values[stack_height - 1]
|
||
if this.huffman_trees[args.which][node_index][1] == 0 {
|
||
break
|
||
}
|
||
stack_height -= 1
|
||
} endwhile
|
||
}
|
||
|
||
symbol_index += 1
|
||
} endwhile
|
||
code_length += 1
|
||
} endwhile
|
||
|
||
if stack_height <> 0 {
|
||
return "#bad Huffman code (under-subscribed)"
|
||
}
|
||
return ok
|
||
}
|
||
|
||
pri func decoder.build_huffman_table!(which: base.u32[..= 5]) {
|
||
var i : base.u32
|
||
var bits : base.u32
|
||
var n_bits : base.u16[..= 8]
|
||
var child : base.u16
|
||
|
||
while i < 256 {
|
||
bits = i << 24
|
||
n_bits = 0
|
||
child = 0
|
||
while (child < 257) and (n_bits < 8),
|
||
inv i < 256,
|
||
{
|
||
child = this.huffman_trees[args.which][child][bits >> 31]
|
||
bits ~mod<<= 1
|
||
n_bits += 1
|
||
} endwhile
|
||
this.huffman_tables[args.which][i] = (child | (n_bits << 12)) as base.u16
|
||
i += 1
|
||
} endwhile
|
||
}
|
||
|
||
// invert_bwt performs "two passes over the data, and one pass over the
|
||
// alphabet", per the BWT technical report, except that the first data pass
|
||
// (accumulating this.letter_counts) is integrated into the decode_huffman_etc
|
||
// methods.
|
||
pri func decoder.invert_bwt!() {
|
||
var i : base.u32
|
||
var letter : base.u32[..= 255]
|
||
var sum : base.u32
|
||
var old_sum : base.u32
|
||
|
||
// Alphabet pass.
|
||
sum = 0
|
||
i = 0
|
||
while i < 256 {
|
||
old_sum = sum
|
||
sum ~mod+= this.letter_counts[i]
|
||
this.letter_counts[i] = old_sum
|
||
i += 1
|
||
} endwhile
|
||
|
||
// Second data pass, but per the README.md file, calculate the U column
|
||
// instead of the BWT technical report's T column.
|
||
i = 0
|
||
while i < this.block_size {
|
||
assert i < 900000 via "a < b: a < c; c <= b"(c: this.block_size)
|
||
letter = this.bwt[i] & 0xFF
|
||
this.bwt[this.letter_counts[letter] & 1_048575] |= i << 12
|
||
this.letter_counts[letter] ~mod+= 1
|
||
i += 1
|
||
} endwhile
|
||
}
|
||
|
||
// The table below was created by script/print-crc32-magic-numbers.go with the
|
||
// -reverse flag set.
|
||
|
||
pri const REV_CRC32_TABLE : roarray[256] base.u32 = [
|
||
0x0000_0000, 0x04C1_1DB7, 0x0982_3B6E, 0x0D43_26D9, 0x1304_76DC, 0x17C5_6B6B, 0x1A86_4DB2, 0x1E47_5005,
|
||
0x2608_EDB8, 0x22C9_F00F, 0x2F8A_D6D6, 0x2B4B_CB61, 0x350C_9B64, 0x31CD_86D3, 0x3C8E_A00A, 0x384F_BDBD,
|
||
0x4C11_DB70, 0x48D0_C6C7, 0x4593_E01E, 0x4152_FDA9, 0x5F15_ADAC, 0x5BD4_B01B, 0x5697_96C2, 0x5256_8B75,
|
||
0x6A19_36C8, 0x6ED8_2B7F, 0x639B_0DA6, 0x675A_1011, 0x791D_4014, 0x7DDC_5DA3, 0x709F_7B7A, 0x745E_66CD,
|
||
0x9823_B6E0, 0x9CE2_AB57, 0x91A1_8D8E, 0x9560_9039, 0x8B27_C03C, 0x8FE6_DD8B, 0x82A5_FB52, 0x8664_E6E5,
|
||
0xBE2B_5B58, 0xBAEA_46EF, 0xB7A9_6036, 0xB368_7D81, 0xAD2F_2D84, 0xA9EE_3033, 0xA4AD_16EA, 0xA06C_0B5D,
|
||
0xD432_6D90, 0xD0F3_7027, 0xDDB0_56FE, 0xD971_4B49, 0xC736_1B4C, 0xC3F7_06FB, 0xCEB4_2022, 0xCA75_3D95,
|
||
0xF23A_8028, 0xF6FB_9D9F, 0xFBB8_BB46, 0xFF79_A6F1, 0xE13E_F6F4, 0xE5FF_EB43, 0xE8BC_CD9A, 0xEC7D_D02D,
|
||
0x3486_7077, 0x3047_6DC0, 0x3D04_4B19, 0x39C5_56AE, 0x2782_06AB, 0x2343_1B1C, 0x2E00_3DC5, 0x2AC1_2072,
|
||
0x128E_9DCF, 0x164F_8078, 0x1B0C_A6A1, 0x1FCD_BB16, 0x018A_EB13, 0x054B_F6A4, 0x0808_D07D, 0x0CC9_CDCA,
|
||
0x7897_AB07, 0x7C56_B6B0, 0x7115_9069, 0x75D4_8DDE, 0x6B93_DDDB, 0x6F52_C06C, 0x6211_E6B5, 0x66D0_FB02,
|
||
0x5E9F_46BF, 0x5A5E_5B08, 0x571D_7DD1, 0x53DC_6066, 0x4D9B_3063, 0x495A_2DD4, 0x4419_0B0D, 0x40D8_16BA,
|
||
0xACA5_C697, 0xA864_DB20, 0xA527_FDF9, 0xA1E6_E04E, 0xBFA1_B04B, 0xBB60_ADFC, 0xB623_8B25, 0xB2E2_9692,
|
||
0x8AAD_2B2F, 0x8E6C_3698, 0x832F_1041, 0x87EE_0DF6, 0x99A9_5DF3, 0x9D68_4044, 0x902B_669D, 0x94EA_7B2A,
|
||
0xE0B4_1DE7, 0xE475_0050, 0xE936_2689, 0xEDF7_3B3E, 0xF3B0_6B3B, 0xF771_768C, 0xFA32_5055, 0xFEF3_4DE2,
|
||
0xC6BC_F05F, 0xC27D_EDE8, 0xCF3E_CB31, 0xCBFF_D686, 0xD5B8_8683, 0xD179_9B34, 0xDC3A_BDED, 0xD8FB_A05A,
|
||
0x690C_E0EE, 0x6DCD_FD59, 0x608E_DB80, 0x644F_C637, 0x7A08_9632, 0x7EC9_8B85, 0x738A_AD5C, 0x774B_B0EB,
|
||
0x4F04_0D56, 0x4BC5_10E1, 0x4686_3638, 0x4247_2B8F, 0x5C00_7B8A, 0x58C1_663D, 0x5582_40E4, 0x5143_5D53,
|
||
0x251D_3B9E, 0x21DC_2629, 0x2C9F_00F0, 0x285E_1D47, 0x3619_4D42, 0x32D8_50F5, 0x3F9B_762C, 0x3B5A_6B9B,
|
||
0x0315_D626, 0x07D4_CB91, 0x0A97_ED48, 0x0E56_F0FF, 0x1011_A0FA, 0x14D0_BD4D, 0x1993_9B94, 0x1D52_8623,
|
||
0xF12F_560E, 0xF5EE_4BB9, 0xF8AD_6D60, 0xFC6C_70D7, 0xE22B_20D2, 0xE6EA_3D65, 0xEBA9_1BBC, 0xEF68_060B,
|
||
0xD727_BBB6, 0xD3E6_A601, 0xDEA5_80D8, 0xDA64_9D6F, 0xC423_CD6A, 0xC0E2_D0DD, 0xCDA1_F604, 0xC960_EBB3,
|
||
0xBD3E_8D7E, 0xB9FF_90C9, 0xB4BC_B610, 0xB07D_ABA7, 0xAE3A_FBA2, 0xAAFB_E615, 0xA7B8_C0CC, 0xA379_DD7B,
|
||
0x9B36_60C6, 0x9FF7_7D71, 0x92B4_5BA8, 0x9675_461F, 0x8832_161A, 0x8CF3_0BAD, 0x81B0_2D74, 0x8571_30C3,
|
||
0x5D8A_9099, 0x594B_8D2E, 0x5408_ABF7, 0x50C9_B640, 0x4E8E_E645, 0x4A4F_FBF2, 0x470C_DD2B, 0x43CD_C09C,
|
||
0x7B82_7D21, 0x7F43_6096, 0x7200_464F, 0x76C1_5BF8, 0x6886_0BFD, 0x6C47_164A, 0x6104_3093, 0x65C5_2D24,
|
||
0x119B_4BE9, 0x155A_565E, 0x1819_7087, 0x1CD8_6D30, 0x029F_3D35, 0x065E_2082, 0x0B1D_065B, 0x0FDC_1BEC,
|
||
0x3793_A651, 0x3352_BBE6, 0x3E11_9D3F, 0x3AD0_8088, 0x2497_D08D, 0x2056_CD3A, 0x2D15_EBE3, 0x29D4_F654,
|
||
0xC5A9_2679, 0xC168_3BCE, 0xCC2B_1D17, 0xC8EA_00A0, 0xD6AD_50A5, 0xD26C_4D12, 0xDF2F_6BCB, 0xDBEE_767C,
|
||
0xE3A1_CBC1, 0xE760_D676, 0xEA23_F0AF, 0xEEE2_ED18, 0xF0A5_BD1D, 0xF464_A0AA, 0xF927_8673, 0xFDE6_9BC4,
|
||
0x89B8_FD09, 0x8D79_E0BE, 0x803A_C667, 0x84FB_DBD0, 0x9ABC_8BD5, 0x9E7D_9662, 0x933E_B0BB, 0x97FF_AD0C,
|
||
0xAFB0_10B1, 0xAB71_0D06, 0xA632_2BDF, 0xA2F3_3668, 0xBCB4_666D, 0xB875_7BDA, 0xB536_5D03, 0xB1F7_40B4,
|
||
]
|