mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Place std/deflate vars at the top of functions
This commit is contained in:
1 parent
9bcdd1e028
commit
cd9ab50f63
4 files changed
+239
-93
No files matched your search
@@ -5346,6 +5346,10 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_z = 0;
|
||||
v_written = ((wuffs_base__slice_u8){});
|
||||
v_n_copied = 0;
|
||||
v_already_full = 0;
|
||||
while (true) {
|
||||
wuffs_base__io_writer__set_mark(&a_dst, iop_a_dst);
|
||||
{
|
||||
@@ -5481,6 +5485,8 @@ wuffs_deflate__decoder__decode_blocks(wuffs_deflate__decoder* self,
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_final = 0;
|
||||
v_b0 = 0;
|
||||
v_type = 0;
|
||||
label_0_continue:;
|
||||
while (v_final == 0) {
|
||||
while (self->private_impl.f_n_bits < 3) {
|
||||
@@ -5654,6 +5660,8 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_length = 0;
|
||||
v_n_copied = 0;
|
||||
if ((self->private_impl.f_n_bits >= 8) ||
|
||||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
|
||||
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
|
||||
@@ -5846,6 +5854,22 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_bits = 0;
|
||||
v_n_bits = 0;
|
||||
v_b0 = 0;
|
||||
v_n_lit = 0;
|
||||
v_n_dist = 0;
|
||||
v_n_clen = 0;
|
||||
v_i = 0;
|
||||
v_b1 = 0;
|
||||
v_mask = 0;
|
||||
v_table_entry = 0;
|
||||
v_table_entry_n_bits = 0;
|
||||
v_b2 = 0;
|
||||
v_n_extra_bits = 0;
|
||||
v_rep_symbol = 0;
|
||||
v_rep_count = 0;
|
||||
v_b3 = 0;
|
||||
v_bits = self->private_impl.f_bits;
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
while (v_n_bits < 14) {
|
||||
@@ -5909,7 +5933,6 @@ wuffs_deflate__decoder__init_dynamic_huffman(wuffs_deflate__decoder* self,
|
||||
v_i = 0;
|
||||
label_0_continue:;
|
||||
while (v_i < (v_n_lit + v_n_dist)) {
|
||||
v_table_entry = 0;
|
||||
while (true) {
|
||||
v_table_entry = self->private_impl.f_huffs[0][(v_bits & v_mask)];
|
||||
v_table_entry_n_bits = (v_table_entry & 15);
|
||||
@@ -6081,6 +6104,30 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
|
||||
uint32_t v_delta;
|
||||
|
||||
memset(v_counts, 0, sizeof(v_counts));
|
||||
v_i = 0;
|
||||
v_remaining = 0;
|
||||
memset(v_offsets, 0, sizeof(v_offsets));
|
||||
v_n_symbols = 0;
|
||||
v_count = 0;
|
||||
memset(v_symbols, 0, sizeof(v_symbols));
|
||||
v_min_cl = 0;
|
||||
v_max_cl = 0;
|
||||
v_initial_high_bits = 0;
|
||||
v_prev_cl = 0;
|
||||
v_prev_redirect_key = 0;
|
||||
v_top = 0;
|
||||
v_next_top = 0;
|
||||
v_code = 0;
|
||||
v_key = 0;
|
||||
v_value = 0;
|
||||
v_cl = 0;
|
||||
v_tmp = 0;
|
||||
v_redirect_key = 0;
|
||||
v_j = 0;
|
||||
v_reversed_key = 0;
|
||||
v_symbol = 0;
|
||||
v_high_bits = 0;
|
||||
v_delta = 0;
|
||||
v_i = a_n_codes0;
|
||||
while (v_i < a_n_codes1) {
|
||||
if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) {
|
||||
@@ -6115,8 +6162,6 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
|
||||
status = wuffs_deflate__error__bad_huffman_code_under_subscribed;
|
||||
goto exit;
|
||||
}
|
||||
memset(v_offsets, 0, sizeof(v_offsets));
|
||||
v_n_symbols = 0;
|
||||
v_i = 1;
|
||||
while (v_i <= 15) {
|
||||
v_offsets[v_i] = ((uint16_t)(v_n_symbols));
|
||||
@@ -6134,7 +6179,6 @@ wuffs_deflate__decoder__init_huff(wuffs_deflate__decoder* self,
|
||||
wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
|
||||
goto exit;
|
||||
}
|
||||
memset(v_symbols, 0, sizeof(v_symbols));
|
||||
v_i = a_n_codes0;
|
||||
while (v_i < a_n_codes1) {
|
||||
if (v_i < a_n_codes0) {
|
||||
@@ -6383,6 +6427,19 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
|
||||
io1_a_src = a_src.private_impl.limit;
|
||||
}
|
||||
|
||||
v_bits = 0;
|
||||
v_n_bits = 0;
|
||||
v_table_entry = 0;
|
||||
v_table_entry_n_bits = 0;
|
||||
v_lmask = 0;
|
||||
v_dmask = 0;
|
||||
v_redir_top = 0;
|
||||
v_redir_mask = 0;
|
||||
v_length = 0;
|
||||
v_dist_minus_1 = 0;
|
||||
v_n_copied = 0;
|
||||
v_hlen = 0;
|
||||
v_hdist = 0;
|
||||
if ((self->private_impl.f_n_bits >= 8) ||
|
||||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
|
||||
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
|
||||
@@ -6390,8 +6447,6 @@ wuffs_deflate__decoder__decode_huffman_fast(wuffs_deflate__decoder* self,
|
||||
}
|
||||
v_bits = self->private_impl.f_bits;
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_table_entry = 0;
|
||||
v_table_entry_n_bits = 0;
|
||||
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
label_0_continue:;
|
||||
@@ -6734,6 +6789,25 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_bits = 0;
|
||||
v_n_bits = 0;
|
||||
v_table_entry = 0;
|
||||
v_table_entry_n_bits = 0;
|
||||
v_lmask = 0;
|
||||
v_dmask = 0;
|
||||
v_b0 = 0;
|
||||
v_redir_top = 0;
|
||||
v_redir_mask = 0;
|
||||
v_b1 = 0;
|
||||
v_length = 0;
|
||||
v_b2 = 0;
|
||||
v_b3 = 0;
|
||||
v_b4 = 0;
|
||||
v_dist_minus_1 = 0;
|
||||
v_b5 = 0;
|
||||
v_n_copied = 0;
|
||||
v_hlen = 0;
|
||||
v_hdist = 0;
|
||||
if ((self->private_impl.f_n_bits >= 8) ||
|
||||
((self->private_impl.f_bits >> self->private_impl.f_n_bits) != 0)) {
|
||||
status = wuffs_deflate__error__internal_error_inconsistent_n_bits;
|
||||
@@ -6741,8 +6815,6 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
}
|
||||
v_bits = self->private_impl.f_bits;
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_table_entry = 0;
|
||||
v_table_entry_n_bits = 0;
|
||||
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
label_0_continue:;
|
||||
@@ -6952,11 +7024,9 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
v_bits >>= v_table_entry_n_bits;
|
||||
v_n_bits -= v_table_entry_n_bits;
|
||||
}
|
||||
v_n_copied = 0;
|
||||
while (true) {
|
||||
if (((uint64_t)((v_dist_minus_1 + 1))) >
|
||||
((uint64_t)(iop_a_dst - a_dst.private_impl.mark))) {
|
||||
v_hlen = 0;
|
||||
v_hdist =
|
||||
((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) -
|
||||
((uint64_t)(iop_a_dst - a_dst.private_impl.mark)))));
|
||||
|
||||
@@ -122,16 +122,21 @@ pub struct decoder?(
|
||||
)
|
||||
|
||||
pub func decoder.decode!??(dst base.io_writer, src base.io_reader) {
|
||||
var z base.status
|
||||
var written slice base.u8
|
||||
var n_copied base.u64
|
||||
var already_full base.u32[..0x8000]
|
||||
|
||||
while true {
|
||||
args.dst.set_mark!()
|
||||
var z base.status =? this.decode_blocks!??(dst:args.dst, src:args.src)
|
||||
z =? this.decode_blocks!??(dst:args.dst, src:args.src)
|
||||
if not z.is_suspension() {
|
||||
return z
|
||||
}
|
||||
// TODO: should "since_mark" be "since_mark!", as the return value lets
|
||||
// you modify the state of args.dst, so future mutations (via the
|
||||
// slice) can change the veracity of any args.dst assertions?
|
||||
var written slice base.u8 = args.dst.since_mark()
|
||||
written = args.dst.since_mark()
|
||||
// Append written, the decoded output, to the history ringbuffer.
|
||||
if written.length() >= 0x8000 {
|
||||
// If written is longer than the ringbuffer, we can ignore the
|
||||
@@ -143,7 +148,7 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) {
|
||||
} else {
|
||||
// Otherwise, append written to the history ringbuffer starting at
|
||||
// the previous history_index (modulo 0x8000).
|
||||
var n_copied base.u64 = this.history[this.history_index & 0x7FFF:].copy_from_slice!(s:written)
|
||||
n_copied = this.history[this.history_index & 0x7FFF:].copy_from_slice!(s:written)
|
||||
if n_copied < written.length() {
|
||||
// a_slice.copy_from(s:b_slice) returns the minimum of the two
|
||||
// slice lengths. If that value is less than b_slice.length(),
|
||||
@@ -162,7 +167,7 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) {
|
||||
this.history_index = ((n_copied & 0x7FFF) as base.u32) + 0x8000
|
||||
} else {
|
||||
// We didn't need to wrap around.
|
||||
var already_full base.u32[..0x8000]
|
||||
already_full = 0
|
||||
if this.history_index >= 0x8000 {
|
||||
already_full = 0x8000
|
||||
}
|
||||
@@ -175,16 +180,19 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) {
|
||||
|
||||
pri func decoder.decode_blocks!??(dst base.io_writer, src base.io_reader) {
|
||||
var final base.u32
|
||||
var b0 base.u32[..255]
|
||||
var type base.u32
|
||||
|
||||
while final == 0 {
|
||||
while this.n_bits < 3,
|
||||
post this.n_bits >= 3,
|
||||
{
|
||||
var b0 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b0 = args.src.read_u8_as_u32!??()
|
||||
this.bits |= b0 << this.n_bits
|
||||
this.n_bits += 8
|
||||
}
|
||||
final = this.bits & 0x01
|
||||
var type base.u32 = (this.bits >> 1) & 0x03
|
||||
type = (this.bits >> 1) & 0x03
|
||||
this.bits >>= 3
|
||||
this.n_bits -= 3
|
||||
|
||||
@@ -215,6 +223,9 @@ pri func decoder.decode_blocks!??(dst base.io_writer, src base.io_reader) {
|
||||
// decode_uncompressed decodes an uncompresed block as per the RFC section
|
||||
// 3.2.4.
|
||||
pri func decoder.decode_uncompressed!??(dst base.io_writer, src base.io_reader) {
|
||||
var length base.u32
|
||||
var n_copied base.u32
|
||||
|
||||
// TODO: make this "if" into a function invariant?
|
||||
//
|
||||
// Ditto for decode_huffman_slow and decode_huffman_fast.
|
||||
@@ -224,13 +235,13 @@ pri func decoder.decode_uncompressed!??(dst base.io_writer, src base.io_reader)
|
||||
this.n_bits = 0
|
||||
this.bits = 0
|
||||
|
||||
var length base.u32 = args.src.read_u32le!??()
|
||||
length = args.src.read_u32le!??()
|
||||
if (length.low_bits(n:16) + length.high_bits(n:16)) != 0xFFFF {
|
||||
return "?inconsistent stored block length"
|
||||
}
|
||||
length = length.low_bits(n:16)
|
||||
while true {
|
||||
var n_copied base.u32 = args.dst.copy_n_from_reader!(n:length, r:args.src)
|
||||
n_copied = args.dst.copy_n_from_reader!(n:length, r:args.src)
|
||||
if length <= n_copied {
|
||||
return ok
|
||||
}
|
||||
@@ -246,6 +257,7 @@ pri func decoder.decode_uncompressed!??(dst base.io_writer, src base.io_reader)
|
||||
// init_fixed_huffman initializes this.huffs as per the RFC section 3.2.6.
|
||||
pri func decoder.init_fixed_huffman!?() {
|
||||
var i base.u32
|
||||
|
||||
while i < 144 {
|
||||
this.code_lengths[i] = 8
|
||||
i += 1
|
||||
@@ -272,37 +284,54 @@ pri func decoder.init_fixed_huffman!?() {
|
||||
|
||||
// init_dynamic_huffman initializes this.huffs as per the RFC section 3.2.7.
|
||||
pri func decoder.init_dynamic_huffman!??(src base.io_reader) {
|
||||
var bits base.u32 = this.bits
|
||||
var n_bits base.u32 = this.n_bits
|
||||
var bits base.u32
|
||||
var n_bits base.u32
|
||||
var b0 base.u32[..255]
|
||||
var n_lit base.u32[..288]
|
||||
var n_dist base.u32[..32]
|
||||
var n_clen base.u32[..19]
|
||||
var i base.u32
|
||||
var b1 base.u32[..255]
|
||||
var mask base.u32[..511]
|
||||
var table_entry base.u32
|
||||
var table_entry_n_bits base.u32[..15]
|
||||
var b2 base.u32[..255]
|
||||
var n_extra_bits base.u32[..7]
|
||||
var rep_symbol base.u8[..15]
|
||||
var rep_count base.u32
|
||||
var b3 base.u32[..255]
|
||||
|
||||
bits = this.bits
|
||||
n_bits = this.n_bits
|
||||
while n_bits < 14,
|
||||
post n_bits >= 14,
|
||||
{
|
||||
var b0 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b0 = args.src.read_u8_as_u32!??()
|
||||
bits |= b0 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
var n_lit base.u32[..288] = bits.low_bits(n:5) + 257
|
||||
n_lit = bits.low_bits(n:5) + 257
|
||||
if n_lit > 286 {
|
||||
return "?bad literal/length code count"
|
||||
}
|
||||
bits >>= 5
|
||||
var n_dist base.u32[..32] = bits.low_bits(n:5) + 1
|
||||
n_dist = bits.low_bits(n:5) + 1
|
||||
if n_dist > 30 {
|
||||
return "?bad distance code count"
|
||||
}
|
||||
bits >>= 5
|
||||
var n_clen base.u32[..19] = bits.low_bits(n:4) + 4
|
||||
n_clen = bits.low_bits(n:4) + 4
|
||||
bits >>= 4
|
||||
n_bits -= 14
|
||||
|
||||
// Read the clcode Huffman table: H-CL.
|
||||
var i base.u32
|
||||
i = 0
|
||||
while i < n_clen {
|
||||
while n_bits < 3,
|
||||
inv i < n_clen,
|
||||
post n_bits >= 3,
|
||||
{
|
||||
var b1 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b1 = args.src.read_u8_as_u32!??()
|
||||
bits |= b1 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -319,25 +348,24 @@ pri func decoder.init_dynamic_huffman!??(src base.io_reader) {
|
||||
this.init_huff!?(which:0, n_codes0:0, n_codes1:19, base_symbol:0xFFF)
|
||||
|
||||
// Decode the code lengths for the next two Huffman tables.
|
||||
var mask base.u32[..511] = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
mask = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
i = 0
|
||||
while i < (n_lit + n_dist) {
|
||||
assert i < (288 + 32) via "a < (b + c): a < (b0 + c0); b0 <= b; c0 <= c"(b0:n_lit, c0:n_dist)
|
||||
|
||||
// Decode a clcode symbol from H-CL.
|
||||
var table_entry base.u32
|
||||
while true,
|
||||
inv i < 320,
|
||||
{
|
||||
table_entry = this.huffs[0][bits & mask]
|
||||
var table_entry_n_bits base.u32[..15] = table_entry & 15
|
||||
table_entry_n_bits = table_entry & 15
|
||||
if n_bits >= table_entry_n_bits {
|
||||
bits >>= table_entry_n_bits
|
||||
n_bits -= table_entry_n_bits
|
||||
break
|
||||
}
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b2 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b2 = args.src.read_u8_as_u32!??()
|
||||
bits |= b2 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -356,9 +384,9 @@ pri func decoder.init_dynamic_huffman!??(src base.io_reader) {
|
||||
}
|
||||
|
||||
// Write a repeated code length.
|
||||
var n_extra_bits base.u32[..7]
|
||||
var rep_symbol base.u8[..15]
|
||||
var rep_count base.u32
|
||||
n_extra_bits = 0
|
||||
rep_symbol = 0
|
||||
rep_count = 0
|
||||
if table_entry == 16 {
|
||||
n_extra_bits = 2
|
||||
if i <= 0 {
|
||||
@@ -386,7 +414,7 @@ pri func decoder.init_dynamic_huffman!??(src base.io_reader) {
|
||||
post n_bits >= n_extra_bits,
|
||||
{
|
||||
assert n_bits < 7 via "a < b: a < c; c <= b"(c:n_extra_bits)
|
||||
var b3 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b3 = args.src.read_u8_as_u32!??()
|
||||
bits |= b3 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -423,6 +451,32 @@ pri func decoder.init_dynamic_huffman!??(src base.io_reader) {
|
||||
// TODO: make named constants for 15, 19, 319, etc.
|
||||
|
||||
pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_codes1 base.u32[..320], base_symbol base.u32) {
|
||||
var counts array[16] base.u16[..320]
|
||||
var i base.u32
|
||||
var remaining base.u32
|
||||
var offsets array[16] base.u16[..320]
|
||||
var n_symbols base.u32[..320]
|
||||
var count base.u32[..320]
|
||||
var symbols array[320] base.u16[..319]
|
||||
var min_cl base.u32[..9]
|
||||
var max_cl base.u32[..15]
|
||||
var initial_high_bits base.u32
|
||||
var prev_cl base.u32[..15]
|
||||
var prev_redirect_key base.u32
|
||||
var top base.u32[..1234]
|
||||
var next_top base.u32[..1234]
|
||||
var code base.u32
|
||||
var key base.u32
|
||||
var value base.u32
|
||||
var cl base.u32[..15]
|
||||
var tmp base.u32[..6]
|
||||
var redirect_key base.u32[..511]
|
||||
var j base.u32
|
||||
var reversed_key base.u32[..511]
|
||||
var symbol base.u32[..319]
|
||||
var high_bits base.u32
|
||||
var delta base.u32
|
||||
|
||||
// For the clcode example in this package's README.md:
|
||||
// - n_codes0 = 0
|
||||
// - n_codes1 = 19
|
||||
@@ -456,8 +510,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// - counts[4] = 1
|
||||
// - counts[5] = 2
|
||||
// - all other counts elements are 0.
|
||||
var counts array[16] base.u16[..320]
|
||||
var i base.u32 = args.n_codes0
|
||||
i = args.n_codes0
|
||||
while i < args.n_codes1 {
|
||||
assert i < 320 via "a < b: a < c; c <= b"(c:args.n_codes1)
|
||||
// TODO: this if should be unnecessary. Have some way to assert that,
|
||||
@@ -473,7 +526,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
}
|
||||
|
||||
// Check that the Huffman code completely covers all possible input bits.
|
||||
var remaining base.u32 = 1 // There is 1 possible 0-bit code.
|
||||
remaining = 1 // There is 1 possible 0-bit code.
|
||||
i = 1
|
||||
while i <= 15 {
|
||||
if remaining > (1 << 30) {
|
||||
@@ -504,12 +557,10 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// - offsets[6] = 10
|
||||
// - all other offsets elements are 10.
|
||||
// - n_symbols = 10
|
||||
var offsets array[16] base.u16[..320]
|
||||
var n_symbols base.u32[..320]
|
||||
i = 1
|
||||
while i <= 15 {
|
||||
offsets[i] = n_symbols as base.u16
|
||||
var count base.u32[..320] = counts[i] as base.u32
|
||||
count = counts[i] as base.u32
|
||||
if n_symbols > (320 - count) {
|
||||
return "?internal error: inconsistent Huffman decoder state"
|
||||
}
|
||||
@@ -541,7 +592,6 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// - offsets[3] = 7, formerly 0
|
||||
// - offsets[4] = 8, formerly 7
|
||||
// - offsets[5] = 10, formerly 8
|
||||
var symbols array[320] base.u16[..319]
|
||||
i = args.n_codes0
|
||||
while i < args.n_codes1,
|
||||
inv n_symbols <= 288,
|
||||
@@ -566,7 +616,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// For the clcode example in this package's README.md:
|
||||
// - min_cl = 3
|
||||
// - max_cl = 5
|
||||
var min_cl base.u32[..9] = 1
|
||||
min_cl = 1
|
||||
while true,
|
||||
inv n_symbols <= 288,
|
||||
{
|
||||
@@ -578,7 +628,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
}
|
||||
min_cl += 1
|
||||
}
|
||||
var max_cl base.u32[..15] = 15
|
||||
max_cl = 15
|
||||
while true,
|
||||
inv n_symbols <= 288,
|
||||
{
|
||||
@@ -618,17 +668,17 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
return "?internal error: inconsistent Huffman decoder state"
|
||||
}
|
||||
|
||||
var initial_high_bits base.u32 = 1 << 9
|
||||
initial_high_bits = 1 << 9
|
||||
if max_cl < 9 {
|
||||
initial_high_bits = (1 as base.u32) << max_cl
|
||||
}
|
||||
var prev_cl base.u32[..15] = this.code_lengths[args.n_codes0 + (symbols[0] as base.u32)] as base.u32
|
||||
var prev_redirect_key base.u32 = 0xFFFFFFFF
|
||||
var top base.u32[..1234]
|
||||
var next_top base.u32[..1234] = 512
|
||||
var code base.u32
|
||||
var key base.u32
|
||||
var value base.u32
|
||||
prev_cl = this.code_lengths[args.n_codes0 + (symbols[0] as base.u32)] as base.u32
|
||||
prev_redirect_key = 0xFFFFFFFF
|
||||
top = 0
|
||||
next_top = 512
|
||||
code = 0
|
||||
key = 0
|
||||
value = 0
|
||||
while true,
|
||||
pre code < (1 << 15),
|
||||
pre i < 288,
|
||||
@@ -637,7 +687,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
if (args.n_codes0 + (symbols[i] as base.u32)) >= 320 {
|
||||
return "?internal error: inconsistent Huffman decoder state"
|
||||
}
|
||||
var cl base.u32[..15] = this.code_lengths[args.n_codes0 + (symbols[i] as base.u32)] as base.u32
|
||||
cl = this.code_lengths[args.n_codes0 + (symbols[i] as base.u32)] as base.u32
|
||||
if cl > prev_cl {
|
||||
code <<= cl - prev_cl
|
||||
if code >= (1 << 15) {
|
||||
@@ -651,11 +701,11 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
key = code
|
||||
if cl > 9 {
|
||||
// TODO: we shouldn't need a temporary variable.
|
||||
var tmp base.u32[..6] = cl - 9
|
||||
tmp = cl - 9
|
||||
cl = tmp
|
||||
assert cl <= 9 via "a <= b: a == c; c <= b"(c:tmp)
|
||||
|
||||
var redirect_key base.u32[..511] = (key >> tmp) & 511
|
||||
redirect_key = (key >> tmp) & 511
|
||||
key = key.low_bits(n:tmp)
|
||||
if prev_redirect_key != redirect_key {
|
||||
prev_redirect_key = redirect_key
|
||||
@@ -664,7 +714,7 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// This computation is similar to "check that the Huffman code
|
||||
// completely covers all possible input bits" above.
|
||||
remaining = (1 as base.u32) << cl
|
||||
var j base.u32 = prev_cl
|
||||
j = prev_cl
|
||||
while j <= 15,
|
||||
inv cl <= 9,
|
||||
inv code < (1 << 15),
|
||||
@@ -702,10 +752,10 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
}
|
||||
counts[prev_cl] -= 1
|
||||
|
||||
var reversed_key base.u32[..511] = (reverse8[key >> 1] as base.u32) | ((key & 1) << 8)
|
||||
reversed_key = (reverse8[key >> 1] as base.u32) | ((key & 1) << 8)
|
||||
reversed_key >>= 9 - cl
|
||||
|
||||
var symbol base.u32[..319] = symbols[i] as base.u32
|
||||
symbol = symbols[i] as base.u32
|
||||
if symbol == 256 {
|
||||
// End-of-block.
|
||||
value = 0x20000000 | cl
|
||||
@@ -727,8 +777,8 @@ pri func decoder.init_huff!?(which base.u32[..1], n_codes0 base.u32[..320], n_co
|
||||
// The table uses log2(initial_high_bits) bits, but reversed_key only
|
||||
// has cl bits. We duplicate the key-value pair across all possible
|
||||
// values of the high (log2(initial_high_bits) - cl) bits.
|
||||
var high_bits base.u32 = initial_high_bits
|
||||
var delta base.u32 = (1 as base.u32) << cl
|
||||
high_bits = initial_high_bits
|
||||
delta = (1 as base.u32) << cl
|
||||
while high_bits >= delta,
|
||||
inv code < (1 << 15),
|
||||
inv i < 288,
|
||||
|
||||
@@ -20,17 +20,29 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
// decode_huffman_*.wuffs files as small as possible, while retaining both
|
||||
// correctness and performance.
|
||||
|
||||
var bits base.u32
|
||||
var n_bits base.u32
|
||||
var table_entry base.u32
|
||||
var table_entry_n_bits base.u32[..15]
|
||||
var lmask base.u32[..511]
|
||||
var dmask base.u32[..511]
|
||||
var redir_top base.u32[..0xFFFF]
|
||||
var redir_mask base.u32[..0x7FFF]
|
||||
var length base.u32[..258]
|
||||
var dist_minus_1 base.u32[..0x7FFF]
|
||||
var n_copied base.u32
|
||||
var hlen base.u32[..0x7FFF]
|
||||
var hdist base.u32
|
||||
|
||||
if (this.n_bits >= 8) or ((this.bits >> this.n_bits) != 0) {
|
||||
return "?internal error: inconsistent n_bits"
|
||||
}
|
||||
|
||||
var bits base.u32 = this.bits
|
||||
var n_bits base.u32 = this.n_bits
|
||||
bits = this.bits
|
||||
n_bits = this.n_bits
|
||||
|
||||
var table_entry base.u32
|
||||
var table_entry_n_bits base.u32[..15]
|
||||
var lmask base.u32[..511] = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
var dmask base.u32[..511] = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
|
||||
lmask = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
dmask = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
|
||||
|
||||
// Check up front, on each iteration, that we have enough buffer space to
|
||||
// both read (12 bytes) and write (258 bytes) as much as we need to. Doing
|
||||
@@ -116,8 +128,8 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
assert args.src.available() >= 8
|
||||
assert n_bits >= 15
|
||||
|
||||
var redir_top base.u32[..0xFFFF] = (table_entry >> 8) & 0xFFFF
|
||||
var redir_mask base.u32[..0x7FFF] = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
|
||||
redir_top = (table_entry >> 8) & 0xFFFF
|
||||
redir_mask = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
|
||||
if (redir_top + (bits & redir_mask)) >= 1234 {
|
||||
return "?internal error: inconsistent Huffman decoder state"
|
||||
}
|
||||
@@ -157,7 +169,7 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
//
|
||||
// The -3 is from the bias in script/print-deflate-magic-numbers.go.
|
||||
// That bias makes the "& 0xFF" 1 and 15-ish lines below correct.
|
||||
var length base.u32[..258] = ((table_entry >> 8) & 0xFF) + 3
|
||||
length = ((table_entry >> 8) & 0xFF) + 3
|
||||
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
||||
if table_entry_n_bits > 0 {
|
||||
// Ensure that we have at least 15 bits of input.
|
||||
@@ -256,7 +268,7 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
// The -1 is from the bias in script/print-deflate-magic-numbers.go.
|
||||
// That bias makes the "& 0x7FFF" 2 and 15-ish lines below correct and
|
||||
// undoing that bias makes proving (dist_minus_1 + 1) > 0 trivial.
|
||||
var dist_minus_1 base.u32[..0x7FFF] = (table_entry >> 8) & 0x7FFF
|
||||
dist_minus_1 = (table_entry >> 8) & 0x7FFF
|
||||
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
||||
// Ensure that we have at least table_entry_n_bits bits of input.
|
||||
if n_bits < table_entry_n_bits {
|
||||
@@ -278,7 +290,7 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
bits >>= table_entry_n_bits
|
||||
n_bits -= table_entry_n_bits
|
||||
|
||||
var n_copied base.u32
|
||||
n_copied = 0
|
||||
// The "while true { etc; break }" is a redundant version of "etc", but
|
||||
// its presence minimizes the diff between decode_huffman_fast and
|
||||
// decode_huffman_slow.
|
||||
@@ -290,9 +302,8 @@ pri func decoder.decode_huffman_fast!?(dst base.io_writer, src base.io_reader) {
|
||||
// Set (hlen, hdist) to be the length-distance pair to copy
|
||||
// from this.history, and (length, distance) to be the
|
||||
// remaining length-distance pair to copy from args.dst.
|
||||
var hlen base.u32[..0x7FFF]
|
||||
var hdist base.u32 =
|
||||
(((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
|
||||
hlen = 0
|
||||
hdist = (((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
|
||||
if length > hdist {
|
||||
assert hdist < length via "a < b: b > a"()
|
||||
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c:length)
|
||||
|
||||
@@ -13,6 +13,26 @@
|
||||
// limitations under the License.
|
||||
|
||||
pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader) {
|
||||
var bits base.u32
|
||||
var n_bits base.u32
|
||||
var table_entry base.u32
|
||||
var table_entry_n_bits base.u32[..15]
|
||||
var lmask base.u32[..511]
|
||||
var dmask base.u32[..511]
|
||||
var b0 base.u32[..255]
|
||||
var redir_top base.u32[..0xFFFF]
|
||||
var redir_mask base.u32[..0x7FFF]
|
||||
var b1 base.u32[..255]
|
||||
var length base.u32[..258]
|
||||
var b2 base.u32[..255]
|
||||
var b3 base.u32[..255]
|
||||
var b4 base.u32[..255]
|
||||
var dist_minus_1 base.u32[..0x7FFF]
|
||||
var b5 base.u32[..255]
|
||||
var n_copied base.u32
|
||||
var hlen base.u32[..0x7FFF]
|
||||
var hdist base.u32
|
||||
|
||||
// When editing this function, consider making the equivalent change to the
|
||||
// decode_huffman_fast function. Keep the diff between the two
|
||||
// decode_huffman_*.wuffs files as small as possible, while retaining both
|
||||
@@ -22,13 +42,11 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
return "?internal error: inconsistent n_bits"
|
||||
}
|
||||
|
||||
var bits base.u32 = this.bits
|
||||
var n_bits base.u32 = this.n_bits
|
||||
bits = this.bits
|
||||
n_bits = this.n_bits
|
||||
|
||||
var table_entry base.u32
|
||||
var table_entry_n_bits base.u32[..15]
|
||||
var lmask base.u32[..511] = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
var dmask base.u32[..511] = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
|
||||
lmask = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
dmask = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
|
||||
|
||||
while:loop true {
|
||||
// Decode an lcode symbol from H-L.
|
||||
@@ -41,7 +59,7 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
break
|
||||
}
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b0 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b0 = args.src.read_u8_as_u32!??()
|
||||
bits |= b0 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -58,8 +76,8 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
break:loop
|
||||
} else if (table_entry >> 28) != 0 {
|
||||
// Redirect.
|
||||
var redir_top base.u32[..0xFFFF] = (table_entry >> 8) & 0xFFFF
|
||||
var redir_mask base.u32[..0x7FFF] = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
|
||||
redir_top = (table_entry >> 8) & 0xFFFF
|
||||
redir_mask = ((1 as base.u32) << ((table_entry >> 4) & 0x0F)) - 1
|
||||
while true {
|
||||
if (redir_top + (bits & redir_mask)) >= 1234 {
|
||||
return "?internal error: inconsistent Huffman decoder state"
|
||||
@@ -72,7 +90,7 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
break
|
||||
}
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b1 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b1 = args.src.read_u8_as_u32!??()
|
||||
bits |= b1 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -105,14 +123,14 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
//
|
||||
// The -3 is from the bias in script/print-deflate-magic-numbers.go.
|
||||
// That bias makes the "& 0xFF" 1 and 15-ish lines below correct.
|
||||
var length base.u32[..258] = ((table_entry >> 8) & 0xFF) + 3
|
||||
length = ((table_entry >> 8) & 0xFF) + 3
|
||||
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
||||
if table_entry_n_bits > 0 {
|
||||
while n_bits < table_entry_n_bits,
|
||||
post n_bits >= table_entry_n_bits,
|
||||
{
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b2 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b2 = args.src.read_u8_as_u32!??()
|
||||
bits |= b2 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -133,7 +151,7 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
break
|
||||
}
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b3 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b3 = args.src.read_u8_as_u32!??()
|
||||
bits |= b3 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -153,7 +171,7 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
break
|
||||
}
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b4 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b4 = args.src.read_u8_as_u32!??()
|
||||
bits |= b4 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -173,14 +191,14 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
// The -1 is from the bias in script/print-deflate-magic-numbers.go.
|
||||
// That bias makes the "& 0x7FFF" 2 and 15-ish lines below correct and
|
||||
// undoing that bias makes proving (dist_minus_1 + 1) > 0 trivial.
|
||||
var dist_minus_1 base.u32[..0x7FFF] = (table_entry >> 8) & 0x7FFF
|
||||
dist_minus_1 = (table_entry >> 8) & 0x7FFF
|
||||
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
||||
if table_entry_n_bits > 0 {
|
||||
while n_bits < table_entry_n_bits,
|
||||
post n_bits >= table_entry_n_bits,
|
||||
{
|
||||
assert n_bits < 15 via "a < b: a < c; c <= b"(c:table_entry_n_bits)
|
||||
var b5 base.u32[..255] = args.src.read_u8_as_u32!??()
|
||||
b5 = args.src.read_u8_as_u32!??()
|
||||
bits |= b5 << n_bits
|
||||
n_bits += 8
|
||||
}
|
||||
@@ -189,16 +207,13 @@ pri func decoder.decode_huffman_slow!??(dst base.io_writer, src base.io_reader)
|
||||
n_bits -= table_entry_n_bits
|
||||
}
|
||||
|
||||
var n_copied base.u32
|
||||
while true {
|
||||
// Copy from this.history.
|
||||
if ((dist_minus_1 + 1) as base.u64) > args.dst.since_mark().length() {
|
||||
// Set (hlen, hdist) to be the length-distance pair to copy
|
||||
// from this.history, and (length, distance) to be the
|
||||
// remaining length-distance pair to copy from args.dst.
|
||||
var hlen base.u32[..0x7FFF]
|
||||
var hdist base.u32 =
|
||||
(((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
|
||||
hdist = (((dist_minus_1 + 1) as base.u64) - args.dst.since_mark().length()) as base.u32
|
||||
if length > hdist {
|
||||
assert hdist < length via "a < b: b > a"()
|
||||
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c:length)
|
||||
|
||||
Reference in new issue
Block a user