mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-21 08:47:28 +01:00
Also remove explicit PATENTS file. The new LICENSE file already discusses patents. Note that the Puffs project has not yet been publicly released.
131 lines
3.5 KiB
Plaintext
131 lines
3.5 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: some mechanism for fixing the error code's value, such as a trailing
|
|
// "= 100", to maintain API stability.
|
|
pub error "LZW code is out of range"
|
|
pub error "LZW prefix chain is cyclical"
|
|
|
|
pub struct lzw_decoder?(
|
|
literal_width u32[2..8] = 8,
|
|
stack[4096] u8,
|
|
suffixes[4096] u8,
|
|
prefixes[4096] u16[..4095],
|
|
)
|
|
|
|
pub func lzw_decoder.set_literal_width(lw u32[2..8] = 8)() {
|
|
this.literal_width = in.lw
|
|
}
|
|
|
|
pub func lzw_decoder.decode?(dst writer1, src reader1)() {
|
|
// These variables don't change over the lifetime of this func.
|
|
var clear_code u32[4..256] = (1 as u32) << this.literal_width
|
|
var end_code u32[5..257] = clear_code + 1
|
|
|
|
// These variables do change.
|
|
//
|
|
// save_code is the code for which, after decoding a code, we save what the
|
|
// next back-reference expands to. The README.md file also calls this value
|
|
// `max`. 4096 means do not save.
|
|
var save_code u32[..4096] = end_code
|
|
var prev_code u32[..4095]
|
|
var width u32[..12] = this.literal_width + 1
|
|
|
|
// These variables yield src's bits in Least Significant Bits order.
|
|
var bits u32
|
|
var n_bits u32
|
|
|
|
while true,
|
|
pre n_bits < 8,
|
|
{
|
|
assert n_bits < (width + 8) via "a < (b + c): a < c; 0 <= b"()
|
|
while n_bits < width,
|
|
inv n_bits < (width + 8),
|
|
post n_bits >= width,
|
|
{
|
|
assert n_bits < 12 via "a < b: a < c; c <= b"(c:width)
|
|
bits |= (in.src.read_u8?() as u32) << n_bits
|
|
n_bits += 8
|
|
}
|
|
var code u32[..4095] = bits.low_bits(n:width)
|
|
bits >>= width
|
|
n_bits -= width
|
|
|
|
if code < clear_code {
|
|
assert code < 256 via "a < b: a < c; c <= b"(c:clear_code)
|
|
in.dst.write_u8?(x:code as u8)
|
|
if save_code <= 4095 {
|
|
this.suffixes[save_code] = code as u8
|
|
this.prefixes[save_code] = prev_code as u16
|
|
}
|
|
|
|
} else if code == clear_code {
|
|
save_code = end_code
|
|
prev_code = 0
|
|
width = this.literal_width + 1
|
|
continue
|
|
|
|
} else if code == end_code {
|
|
return
|
|
|
|
} else if code <= save_code {
|
|
var s u32[..4095] = 4095
|
|
var c u32[..4095] = code
|
|
|
|
if code == save_code {
|
|
s -= 1
|
|
c = prev_code
|
|
}
|
|
|
|
while c >= clear_code,
|
|
inv n_bits < 8,
|
|
post c < 256 via "a < b: a < c; c <= b"(c:clear_code),
|
|
{
|
|
this.stack[s] = this.suffixes[c]
|
|
if s == 0 {
|
|
return error "LZW prefix chain is cyclical"
|
|
}
|
|
s -= 1
|
|
c = this.prefixes[c] as u32
|
|
}
|
|
this.stack[s] = c as u8
|
|
|
|
if code == save_code {
|
|
this.stack[4095] = c as u8
|
|
}
|
|
|
|
// TODO: the "x:s" arg is a placeholder, and should be something
|
|
// like (this.stack[s:]), which means defining a slice type (and
|
|
// type checking, bounds checking and code generation for it).
|
|
in.dst.write?(x:s)
|
|
|
|
if save_code <= 4095 {
|
|
this.suffixes[save_code] = c as u8
|
|
this.prefixes[save_code] = prev_code as u16
|
|
}
|
|
|
|
} else {
|
|
return error "LZW code is out of range"
|
|
}
|
|
|
|
if save_code <= 4095 {
|
|
save_code += 1
|
|
if (save_code == ((1 as u32) << width)) and (width < 12) {
|
|
width += 1
|
|
}
|
|
}
|
|
prev_code = code
|
|
}
|
|
}
|