mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
385 lines
13 KiB
Plaintext
385 lines
13 KiB
Plaintext
// Copyright 2017 The Puffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// TODO: describe how the xxx_fast version differs from the xxx_slow one, the
|
|
// assumptions that xxx_fast makes, and how that makes it fast.
|
|
pri func flate_decoder.decode_huffman_fast?(dst writer1, src reader1)() {
|
|
// When editing this function, consider making the equivalent change to the
|
|
// decode_huffman_slow function. Keep the diff between the two
|
|
// decode_huffman_*.puffs files as small as possible, while retaining both
|
|
// correctness and performance.
|
|
|
|
// TODO: make this a func pre-condition.
|
|
if not in.dst.is_marked() {
|
|
return error "bad argument"
|
|
}
|
|
|
|
if (this.n_bits >= 8) or ((this.bits >> this.n_bits) != 0) {
|
|
return error "internal error: inconsistent n_bits"
|
|
}
|
|
|
|
var bits u32 = this.bits
|
|
var n_bits u32 = this.n_bits
|
|
|
|
var table_entry u32
|
|
var table_entry_n_bits u32[..15]
|
|
var lmask u32[..511] = ((1 as u32) << this.n_huffs_bits[0]) - 1
|
|
var dmask u32[..511] = ((1 as 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
|
|
// this check once (per iteration), up front, removes the need to check
|
|
// (and possibly suspend the coroutine) multiple times inside the loop
|
|
// body, so it's faster overall.
|
|
//
|
|
// For writing, a literal code obviously corresponds to writing 1 byte, and
|
|
// 258 is the maximum length in a length-distance pair, as specified in the
|
|
// RFC section 3.2.5. Compressed blocks (length and distance codes).
|
|
//
|
|
// For reading, strictly speaking, we only need 6 bytes (48 bits) of
|
|
// available input, because the H-L length/literal code is up to 15 bits
|
|
// plus up to 5 extra bits, the H-D distance code is up to 15 bits plus up
|
|
// to 13 extra bits and 15 + 5 + 15 + 13 == 48. However, in.src.available()
|
|
// assertions are made in terms of bytes, not bits.
|
|
//
|
|
// In theory, we could write assertions that mixed bytes and bits, such as:
|
|
//
|
|
// assert ((in.src.available() >= 6) and (n_bits >= 5)) or
|
|
// ((in.src.available() >= 4) and (n_bits >= 21))
|
|
//
|
|
// but that looks clumsy and makes the proofs more complicated. Instead, we
|
|
// are conservative and work in terms of bytes only. In bytes, each code
|
|
// requires either one (direct) or two (redirect) lookups, up to 2 bytes
|
|
// for each. There are also up to 13 extra bits, or 2 bytes. Thus, each
|
|
// code requires up to 2 + 2 + 2 == 6 bytes, and there are two codes (one
|
|
// from H-L and one from H-D). Therefore, we check for at least 12 bytes.
|
|
while:loop(in.dst.available() >= 258) and (in.src.available() >= 12),
|
|
inv in.dst.is_marked(),
|
|
{
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
} else {
|
|
assert in.src.available() >= 10
|
|
}
|
|
// These assertions are redundant, but are listed explicitly for
|
|
// clarity. They must hold regardless of which branch was taken for the
|
|
// if statement above.
|
|
assert in.src.available() >= 10
|
|
assert n_bits >= 15
|
|
|
|
// Decode an lcode symbol from H-L.
|
|
table_entry = this.huffs[0][bits & lmask]
|
|
table_entry_n_bits = table_entry & 0x0F
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
|
|
if (table_entry >> 31) != 0 {
|
|
// Literal.
|
|
in.dst.write_u8?(x:(table_entry >> 8) & 0xFF)
|
|
continue:loop
|
|
} else if (table_entry >> 30) != 0 {
|
|
// No-op; code continues past the if-else chain.
|
|
assert in.src.available() >= 8
|
|
} else if (table_entry >> 29) != 0 {
|
|
// End of block.
|
|
this.end_of_block = true
|
|
break:loop
|
|
} else if (table_entry >> 28) != 0 {
|
|
// Redirect.
|
|
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
} else {
|
|
assert in.src.available() >= 8
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert in.src.available() >= 8
|
|
assert n_bits >= 15
|
|
|
|
var redir_top u32[..0xFFFF] = (table_entry >> 8) & 0xFFFF
|
|
var redir_mask u32[..0x7FFF] = ((1 as u32) << ((table_entry >> 4) & 0x0F)) - 1
|
|
if (redir_top + (bits & redir_mask)) >= 1234 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
table_entry = this.huffs[0][redir_top + (bits & redir_mask)]
|
|
table_entry_n_bits = table_entry & 0x0F
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
|
|
if (table_entry >> 31) != 0 {
|
|
// Literal.
|
|
in.dst.write_u8?(x:(table_entry >> 8) & 0xFF)
|
|
continue:loop
|
|
} else if (table_entry >> 30) != 0 {
|
|
// No-op; code continues past the if-else chain.
|
|
} else if (table_entry >> 29) != 0 {
|
|
// End of block.
|
|
this.end_of_block = true
|
|
break:loop
|
|
} else if (table_entry >> 28) != 0 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
} else if (table_entry >> 27) != 0 {
|
|
return error "bad Huffman code"
|
|
} else {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
|
|
// Once again, redundant but explicit assertions.
|
|
assert in.src.available() >= 8
|
|
|
|
} else if (table_entry >> 27) != 0 {
|
|
return error "bad Huffman code"
|
|
} else {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
|
|
// length = base number + extra bits.
|
|
var length u32[..0x7FFF] = (table_entry >> 8) & 0x7FFF
|
|
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
|
if table_entry_n_bits > 0 {
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
} else {
|
|
assert in.src.available() >= 6
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert in.src.available() >= 6
|
|
assert n_bits >= 15
|
|
|
|
length = (length + bits.low_bits(n:table_entry_n_bits)) & 0x7FFF
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
|
|
} else {
|
|
assert in.src.available() >= 6
|
|
}
|
|
if length > 258 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
} else {
|
|
assert in.src.available() >= 4
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert in.src.available() >= 4
|
|
assert n_bits >= 15
|
|
|
|
// Decode a dcode symbol from H-D.
|
|
table_entry = this.huffs[1][bits & dmask]
|
|
table_entry_n_bits = table_entry & 15
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
|
|
// Check for a redirect.
|
|
if (table_entry >> 28) == 1 {
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
} else {
|
|
assert in.src.available() >= 2
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert in.src.available() >= 2
|
|
assert n_bits >= 15
|
|
|
|
redir_top = (table_entry >> 8) & 0xFFFF
|
|
redir_mask = ((1 as u32) << ((table_entry >> 4) & 0x0F)) - 1
|
|
if (redir_top + (bits & redir_mask)) >= 1234 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
table_entry = this.huffs[1][redir_top + (bits & redir_mask)]
|
|
table_entry_n_bits = table_entry & 0x0F
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
} else {
|
|
assert in.src.available() >= 2
|
|
}
|
|
|
|
// For H-D, all symbols should be base number + extra bits.
|
|
if (table_entry >> 24) != 0x40 {
|
|
if (table_entry >> 24) == 0x08 {
|
|
return error "bad Huffman code"
|
|
}
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
|
|
// distance = base number + extra bits.
|
|
var distance u32[..0x7FFF] = (table_entry >> 8) & 0x7FFF
|
|
table_entry_n_bits = (table_entry >> 4) & 0x0F
|
|
if table_entry_n_bits > 0 {
|
|
// Ensure that we have at least 15 bits of input.
|
|
if n_bits < 15 {
|
|
assert n_bits >= 0 // TODO: this shouldn't be necessary.
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
assert n_bits >= 15
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert n_bits >= 15
|
|
|
|
distance = (distance + bits.low_bits(n:table_entry_n_bits)) & 0x7FFF
|
|
bits >>= table_entry_n_bits
|
|
n_bits -= table_entry_n_bits
|
|
}
|
|
if distance <= 0 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
|
|
var n_copied u32
|
|
// 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.
|
|
while true,
|
|
pre length <= 258,
|
|
pre distance > 0,
|
|
pre in.dst.available() >= 258,
|
|
inv in.dst.is_marked(),
|
|
{
|
|
// Copy from this.history.
|
|
if (distance as u64) > in.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 in.dst.
|
|
var hlen u32[..0x7FFF]
|
|
var hdist u32[..0x7FFF] = ((distance as u64) - in.dst.since_mark().length()) as u32
|
|
if length > hdist {
|
|
length -= hdist
|
|
hlen = hdist
|
|
// TODO: this if check should be redundant.
|
|
if length > 258 {
|
|
return error "internal error: inconsistent Huffman decoder state"
|
|
}
|
|
} else {
|
|
hlen = length
|
|
length = 0
|
|
assert length <= 258
|
|
}
|
|
if this.history_index < hdist {
|
|
return error "bad distance"
|
|
}
|
|
// Re-purpose the hdist variable as the this.history index to
|
|
// start copying from.
|
|
hdist = (this.history_index - hdist) & 0x7FFF
|
|
|
|
// Copy from hdist to the end of this.history, and then
|
|
// possibly wrap around the this.history ringbuffer.
|
|
//
|
|
// 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.
|
|
while true,
|
|
inv length <= 258,
|
|
inv distance > 0,
|
|
inv in.dst.available() >= 258,
|
|
inv in.dst.is_marked(),
|
|
{
|
|
// TODO: copy_from_slice32 should probably update the
|
|
// "in.dst.available() >= 258" fact. It should certainly
|
|
// invalidate any fact that was "<=" instead of ">=".
|
|
n_copied = in.dst.copy_from_slice32(s:this.history[hdist:], length:hlen)
|
|
if hlen <= n_copied {
|
|
break
|
|
}
|
|
hlen -= n_copied
|
|
in.dst.copy_from_slice32(s:this.history[:], length:hlen)
|
|
break
|
|
}
|
|
|
|
if length == 0 {
|
|
// No need to copy from in.dst.
|
|
continue:loop
|
|
}
|
|
|
|
if (distance as u64) > in.dst.since_mark().length() {
|
|
return error "internal error: inconsistent distance"
|
|
}
|
|
}
|
|
// Once again, redundant but explicit assertions.
|
|
assert length <= 258
|
|
assert distance > 0
|
|
assert (distance as u64) <= in.dst.since_mark().length()
|
|
assert in.dst.available() >= 258
|
|
assert in.dst.is_marked()
|
|
|
|
// We can therefore prove:
|
|
assert (length as u64) <= 258
|
|
assert (length as u64) <= in.dst.available() via "a <= b: a <= c; c <= b"(c:258)
|
|
|
|
// Copy from in.dst.
|
|
in.dst.copy_from_history32(distance:distance, length:length)
|
|
break
|
|
}
|
|
}
|
|
|
|
// Ensure n_bits < 8 by rewindng in.src, if we loaded too many of its bytes
|
|
// into the bits variable.
|
|
//
|
|
// Note that we can unconditionally call unread_u8 (without resulting in an
|
|
// "invalid I/O operation" error code) only because this whole function can
|
|
// never suspend, as all of its I/O operations were checked beforehand for
|
|
// sufficient buffer space. Otherwise, resuming from the suspension could
|
|
// mean that the (possibly different) in.src is no longer rewindable, even
|
|
// if conceptually, this function was responsible for reading the bytes we
|
|
// want to rewind.
|
|
//
|
|
// TODO: have the compiler enforce (via some explicit syntax) that this
|
|
// function is ProvenNotToSuspend?
|
|
while n_bits >= 8,
|
|
post n_bits < 8,
|
|
{
|
|
n_bits -= 8
|
|
in.src.unread_u8?()
|
|
}
|
|
|
|
this.bits = bits & (((1 as u32) << n_bits) - 1)
|
|
this.n_bits = n_bits
|
|
|
|
if (this.n_bits >= 8) or ((this.bits >> this.n_bits) != 0) {
|
|
return error "internal error: inconsistent n_bits"
|
|
}
|
|
}
|