mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
309 lines
12 KiB
Plaintext
309 lines
12 KiB
Plaintext
// Copyright 2024 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
|
|
|
|
pri func decoder.decode_pixels_slow?(dst: slice base.u8, src: base.io_reader, width: base.u32[..= 0x4000], height: base.u32[..= 0x4000], tile_data: roslice base.u8, tile_size_log2: base.u32[..= 9]) {
|
|
var c8 : base.u8
|
|
|
|
var p : base.u64
|
|
var p_max : base.u64[..= 0x4000_0000]
|
|
|
|
var tile_size_log2 : base.u32[..= 31]
|
|
var width_in_tiles : base.u32[..= 0x20FF]
|
|
|
|
var x : base.u32
|
|
var y : base.u32
|
|
var i : base.u32
|
|
|
|
var hg : base.u32[..= 0xFF]
|
|
var h : base.u32[..= 0x187A]
|
|
var node : base.u16
|
|
|
|
var pixel_g : base.u32[..= 0x7FFF]
|
|
var color : base.u32 // u32 0xAARR_GGBB, non-premultiplied alpha.
|
|
var dst_pixel : slice base.u8
|
|
|
|
var back_ref_len_n_bits : base.u32[..= 11]
|
|
var back_ref_len_minus_1 : base.u32[..= 0x1FFF] // 0x1FFF = 8191.
|
|
var back_ref_dist_n_bits : base.u32[..= 18]
|
|
var back_ref_dist_sym : base.u32[..= 0x7FFF]
|
|
var back_ref_dist_premap_minus_1 : base.u32[..= 0xF_FFFF] // 0xF_FFFF = 1048575.
|
|
var back_ref_dist_minus_1 : base.u32
|
|
|
|
var dm : base.u32[..= 0xFF]
|
|
var dx : base.u32
|
|
var dy : base.u32
|
|
|
|
var p_end : base.u64[..= 0x4000_8000]
|
|
var dist4 : base.u64
|
|
var q : base.u64
|
|
|
|
var color_cache_pixels : slice base.u8
|
|
var color_cache_p : base.u64
|
|
var color_cache_shift : base.u32[..= 31]
|
|
|
|
p_max = (4 * args.width * args.height) as base.u64
|
|
if args.dst.length() < p_max {
|
|
return "#internal error: inconsistent dst buffer"
|
|
}
|
|
|
|
if args.tile_size_log2 <> 0 {
|
|
tile_size_log2 = args.tile_size_log2
|
|
width_in_tiles = (args.width + (((1 as base.u32) << tile_size_log2) - 1)) >> tile_size_log2
|
|
} else {
|
|
tile_size_log2 = 31
|
|
width_in_tiles = 1
|
|
}
|
|
|
|
while p < p_max {
|
|
// The "~mod+ 1" selects the green pixel of the BGRA 4-byte group.
|
|
i = ((((y >> tile_size_log2) ~mod* width_in_tiles) ~mod+ (x >> tile_size_log2)) ~mod* 4) ~mod+ 1
|
|
if (i as base.u64) < args.tile_data.length() {
|
|
hg = args.tile_data[i as base.u64] as base.u32
|
|
}
|
|
|
|
// Decode the Green+etc symbol.
|
|
h = HUFFMAN_TABLE_BASE_OFFSETS[0] as base.u32
|
|
while true,
|
|
inv p < p_max,
|
|
{
|
|
node = this.huffman_nodes[hg][h]
|
|
if node >= 0x8000 {
|
|
break
|
|
} else if node > 0x1879 {
|
|
return "#internal error: inconsistent Huffman code"
|
|
}
|
|
if this.n_bits < 1 {
|
|
c8 = args.src.read_u8?()
|
|
this.bits = (c8 as base.u32)
|
|
this.n_bits = 8
|
|
assert this.n_bits >= 1
|
|
}
|
|
h = (node as base.u32) + (this.bits & 1)
|
|
this.bits >>= 1
|
|
this.n_bits -= 1
|
|
}
|
|
pixel_g = (node & 0x7FFF) as base.u32
|
|
|
|
if pixel_g < 0x100 { // Literal pixel.
|
|
color = pixel_g << 8
|
|
|
|
// Decode the Red symbol.
|
|
h = HUFFMAN_TABLE_BASE_OFFSETS[1] as base.u32
|
|
while true,
|
|
inv p < p_max,
|
|
{
|
|
node = this.huffman_nodes[hg][h]
|
|
if node >= 0x8000 {
|
|
break
|
|
}
|
|
if this.n_bits < 1 {
|
|
c8 = args.src.read_u8?()
|
|
this.bits = (c8 as base.u32)
|
|
this.n_bits = 8
|
|
assert this.n_bits >= 1
|
|
}
|
|
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
|
|
this.bits >>= 1
|
|
this.n_bits -= 1
|
|
}
|
|
color |= ((node & 0xFF) as base.u32) << 16
|
|
|
|
// Decode the Blue symbol.
|
|
h = HUFFMAN_TABLE_BASE_OFFSETS[2] as base.u32
|
|
while true,
|
|
inv p < p_max,
|
|
{
|
|
node = this.huffman_nodes[hg][h]
|
|
if node >= 0x8000 {
|
|
break
|
|
}
|
|
if this.n_bits < 1 {
|
|
c8 = args.src.read_u8?()
|
|
this.bits = (c8 as base.u32)
|
|
this.n_bits = 8
|
|
assert this.n_bits >= 1
|
|
}
|
|
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
|
|
this.bits >>= 1
|
|
this.n_bits -= 1
|
|
}
|
|
color |= ((node & 0xFF) as base.u32) << 0
|
|
|
|
// Decode the Alpha symbol.
|
|
h = HUFFMAN_TABLE_BASE_OFFSETS[3] as base.u32
|
|
while true,
|
|
inv p < p_max,
|
|
{
|
|
node = this.huffman_nodes[hg][h]
|
|
if node >= 0x8000 {
|
|
break
|
|
}
|
|
if this.n_bits < 1 {
|
|
c8 = args.src.read_u8?()
|
|
this.bits = (c8 as base.u32)
|
|
this.n_bits = 8
|
|
assert this.n_bits >= 1
|
|
}
|
|
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
|
|
this.bits >>= 1
|
|
this.n_bits -= 1
|
|
}
|
|
color |= ((node & 0xFF) as base.u32) << 24
|
|
|
|
} else if pixel_g < 0x118 { // Back-ref pixel.
|
|
// Decode the back-ref length.
|
|
if pixel_g < 0x104 {
|
|
back_ref_len_minus_1 = pixel_g - 0x100
|
|
} else {
|
|
back_ref_len_n_bits = (pixel_g - 0x102) >> 1
|
|
back_ref_len_minus_1 = ((2 as base.u32) + (pixel_g & 1)) << back_ref_len_n_bits
|
|
assert back_ref_len_minus_1 <= 6144
|
|
while this.n_bits < back_ref_len_n_bits,
|
|
inv p < p_max,
|
|
inv back_ref_len_minus_1 <= 6144,
|
|
post this.n_bits >= back_ref_len_n_bits,
|
|
{
|
|
c8 = args.src.read_u8?()
|
|
if this.n_bits >= back_ref_len_n_bits {
|
|
return "#internal error: inconsistent n_bits"
|
|
}
|
|
assert this.n_bits < 12 via "a < b: a < c; c <= b"(c: back_ref_len_n_bits)
|
|
this.bits |= (c8 as base.u32) << this.n_bits
|
|
this.n_bits += 8
|
|
}
|
|
back_ref_len_minus_1 += this.bits & (((1 as base.u32) << back_ref_len_n_bits) - 1)
|
|
this.bits >>= back_ref_len_n_bits
|
|
this.n_bits -= back_ref_len_n_bits
|
|
}
|
|
|
|
// Decode the back-ref distance.
|
|
|
|
h = HUFFMAN_TABLE_BASE_OFFSETS[4] as base.u32
|
|
while true,
|
|
inv p < p_max,
|
|
{
|
|
node = this.huffman_nodes[hg][h]
|
|
if node >= 0x8000 {
|
|
break
|
|
}
|
|
if this.n_bits < 1 {
|
|
c8 = args.src.read_u8?()
|
|
this.bits = (c8 as base.u32)
|
|
this.n_bits = 8
|
|
assert this.n_bits >= 1
|
|
}
|
|
h = ((node as base.u32) & 0xFFF) + (this.bits & 1)
|
|
this.bits >>= 1
|
|
this.n_bits -= 1
|
|
}
|
|
back_ref_dist_sym = (node & 0x7FFF) as base.u32
|
|
|
|
if back_ref_dist_sym < 4 {
|
|
back_ref_dist_premap_minus_1 = back_ref_dist_sym
|
|
} else if back_ref_dist_sym < 40 {
|
|
back_ref_dist_n_bits = (back_ref_dist_sym - 2) >> 1
|
|
back_ref_dist_premap_minus_1 = ((2 as base.u32) + (back_ref_dist_sym & 1)) << back_ref_dist_n_bits
|
|
assert back_ref_dist_premap_minus_1 <= 786432
|
|
while this.n_bits < back_ref_dist_n_bits,
|
|
inv p < p_max,
|
|
inv back_ref_dist_premap_minus_1 <= 786432,
|
|
post this.n_bits >= back_ref_dist_n_bits,
|
|
{
|
|
c8 = args.src.read_u8?()
|
|
if this.n_bits >= back_ref_dist_n_bits {
|
|
return "#internal error: inconsistent n_bits"
|
|
}
|
|
assert this.n_bits < 24 via "a < b: a < c; c <= b"(c: back_ref_dist_n_bits)
|
|
this.bits |= (c8 as base.u32) << this.n_bits
|
|
this.n_bits += 8
|
|
}
|
|
back_ref_dist_premap_minus_1 += this.bits & (((1 as base.u32) << back_ref_dist_n_bits) - 1)
|
|
this.bits >>= back_ref_dist_n_bits
|
|
this.n_bits -= back_ref_dist_n_bits
|
|
}
|
|
|
|
if back_ref_dist_premap_minus_1 >= 120 {
|
|
back_ref_dist_minus_1 = back_ref_dist_premap_minus_1 - 120
|
|
} else {
|
|
dm = DISTANCE_MAP[back_ref_dist_premap_minus_1] as base.u32
|
|
dy = dm >> 4
|
|
dx = 7 ~mod- (dm & 15)
|
|
back_ref_dist_minus_1 = (args.width * dy) ~mod+ dx
|
|
}
|
|
|
|
// Apply the (back_ref_len_minus_1, back_ref_dist_minus_1) pair.
|
|
assert p < 0x4000_0000 via "a < b: a < c; c <= b"(c: p_max)
|
|
p_end = p + (((back_ref_len_minus_1 + 1) * 4) as base.u64)
|
|
dist4 = ((back_ref_dist_minus_1 as base.u64) * 4) + 4
|
|
if (p_end > p_max) or (p_end > args.dst.length()) or (p < dist4) {
|
|
return "#bad back-reference"
|
|
}
|
|
q = p - dist4
|
|
while (q < p) and (p < p_end),
|
|
inv p_end <= args.dst.length(),
|
|
{
|
|
assert q < p_end via "a < b: a < c; c < b"(c: p)
|
|
assert p < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end)
|
|
assert q < 0x4000_8000 via "a < b: a < c; c <= b"(c: p_end)
|
|
assert p < args.dst.length() via "a < b: a < c; c <= b"(c: p_end)
|
|
assert q < args.dst.length() via "a < b: a < c; c <= b"(c: p_end)
|
|
args.dst[p] = args.dst[q]
|
|
p += 1
|
|
q += 1
|
|
}
|
|
|
|
// Update (x, y).
|
|
x ~mod+= back_ref_len_minus_1 + 1
|
|
while x >= args.width {
|
|
x -= args.width
|
|
y ~mod+= 1
|
|
}
|
|
continue
|
|
|
|
} else { // Color cache pixel.
|
|
// Insert previous pixels into this.color_cache.
|
|
if (color_cache_p > p) or (p > args.dst.length()) {
|
|
return "#internal error: inconsistent dst buffer"
|
|
}
|
|
color_cache_pixels = args.dst[color_cache_p .. p]
|
|
color_cache_p = p
|
|
color_cache_shift = (32 - this.color_cache_bits) & 31
|
|
while color_cache_pixels.length() >= 4,
|
|
inv pixel_g >= 0x118,
|
|
{
|
|
color = color_cache_pixels.peek_u32le()
|
|
this.color_cache[((color ~mod* 0x1E35_A7BD) >> color_cache_shift) & 2047] = color
|
|
color_cache_pixels = color_cache_pixels[4 ..]
|
|
}
|
|
|
|
// Look up this.color_cache.
|
|
color = this.color_cache[(pixel_g - 0x118) & 2047]
|
|
}
|
|
|
|
// Set the dst pixel to the color.
|
|
if p > args.dst.length() {
|
|
return "#internal error: inconsistent dst buffer"
|
|
}
|
|
dst_pixel = args.dst[p ..]
|
|
if dst_pixel.length() < 4 {
|
|
return "#internal error: inconsistent dst buffer"
|
|
}
|
|
dst_pixel.poke_u32le!(a: color)
|
|
p ~mod+= 4
|
|
|
|
// Update (x, y).
|
|
x ~mod+= 1
|
|
if x == args.width {
|
|
x = 0
|
|
y ~mod+= 1
|
|
}
|
|
}
|
|
}
|