mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
420 lines
14 KiB
Plaintext
420 lines
14 KiB
Plaintext
// Copyright 2026 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_macroblocks!(workbuf: slice base.u8) base.status {
|
|
var mby : base.u32
|
|
var mbx : base.u32
|
|
|
|
mbx = 0
|
|
while mbx < this.mbw {
|
|
assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw)
|
|
|
|
this.mb_states_top[mbx] = 0
|
|
|
|
mbx += 1
|
|
}
|
|
|
|
mby = 0
|
|
while mby < this.mbh {
|
|
assert mby < 0x400 via "a < b: a < c; c <= b"(c: this.mbh)
|
|
|
|
this.mb_states_left = 0
|
|
|
|
// Decode this row, using this.mb_coeffs and this.yuv_cache before
|
|
// ultimately writing to args.workbuf.
|
|
mbx = 0
|
|
while mbx < this.mbw,
|
|
inv mby < 0x400,
|
|
{
|
|
assert mbx < 0x400 via "a < b: a < c; c <= b"(c: this.mbw)
|
|
|
|
this.decode_one_macroblock!(workbuf: args.workbuf, mbx: mbx, mby: mby)
|
|
|
|
mbx += 1
|
|
}
|
|
|
|
// Filter the previous row, already in args.workbuf.
|
|
if mby > 0 {
|
|
if this.filt_level <= 0 {
|
|
// No-op.
|
|
} else if this.filt_simple {
|
|
this.filter_simple!(workbuf: args.workbuf, mby: mby - 1)
|
|
} else {
|
|
this.filter_normal!(workbuf: args.workbuf, mby: mby - 1)
|
|
}
|
|
}
|
|
|
|
mby += 1
|
|
}
|
|
|
|
// Filter the final row, already in args.workbuf.
|
|
if this.mbh > 0 {
|
|
if this.filt_level <= 0 {
|
|
// No-op.
|
|
} else if this.filt_simple {
|
|
this.filter_simple!(workbuf: args.workbuf, mby: this.mbh - 1)
|
|
} else {
|
|
this.filter_normal!(workbuf: args.workbuf, mby: this.mbh - 1)
|
|
}
|
|
|
|
}
|
|
|
|
return ok
|
|
}
|
|
|
|
pri func decoder.decode_one_macroblock!(workbuf: slice base.u8, mbx: base.u32[..= 0x3FF], mby: base.u32[..= 0x3FF]) {
|
|
var v1 : base.u32[..= 1]
|
|
|
|
var seg : base.u32[..= 3]
|
|
var skip : base.u32[..= 1]
|
|
var mask : base.u32
|
|
var luma_mode : base.u32[..= 4]
|
|
var chroma_mode : base.u32[..= 3]
|
|
|
|
// RFC 6386 Section 10. Segment-Based Feature Adjustments.
|
|
seg = 0
|
|
if this.seg_update_map {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[0] as base.u32)
|
|
if v1 == 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[1] as base.u32)
|
|
seg = v1
|
|
} else {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.seg_probs[2] as base.u32)
|
|
seg = v1 + 2
|
|
}
|
|
}
|
|
|
|
skip = 0
|
|
if (this.prob_skip & 0x100) <> 0 {
|
|
skip = this.read_bit!(workbuf: args.workbuf, part: 0, prob: this.prob_skip & 0xFF)
|
|
}
|
|
|
|
luma_mode = this.decode_luma_mode!(workbuf: args.workbuf)
|
|
this.decode_subblock_modes!(workbuf: args.workbuf, mbx: args.mbx, luma_mode: luma_mode)
|
|
|
|
chroma_mode = this.decode_chroma_mode!(workbuf: args.workbuf)
|
|
|
|
if skip <> 0 {
|
|
// Clear the HNZC bits.
|
|
mask = 0x0000_FFFF
|
|
if luma_mode >= 4 {
|
|
mask = 0x0080_FFFF
|
|
}
|
|
this.mb_states_left &= mask
|
|
this.mb_states_top[args.mbx] &= mask
|
|
this.mb_dc_nz = 0
|
|
this.mb_ac_nz = 0
|
|
|
|
} else {
|
|
skip = this.decode_coefficients!(
|
|
workbuf: args.workbuf, mbx: args.mbx, mby: args.mby,
|
|
seg: seg, luma_mode: luma_mode)
|
|
}
|
|
|
|
this.reconstruct!(
|
|
workbuf: args.workbuf, mbx: args.mbx, mby: args.mby,
|
|
luma_mode: luma_mode, chroma_mode: chroma_mode)
|
|
|
|
this.copy_from_yuv_cache!(
|
|
workbuf: args.workbuf, mbx: args.mbx, mby: args.mby)
|
|
|
|
this.mb_filters[args.mby & 1][args.mbx] =
|
|
(((1 ^ skip) << 3) | (seg << 1) | (luma_mode >> 2)) as base.u8
|
|
}
|
|
|
|
// RFC 6386 Section 11.2. Luma Modes.
|
|
//
|
|
// 0 = B_DC_PRED = predict DC using row above and column to the left.
|
|
// 1 = B_TM_PRED = propagate second differences a la "True Motion".
|
|
// 2 = B_VE_PRED = predict rows using row above.
|
|
// 3 = B_HE_PRED = predict columns using column to the left.
|
|
// 4 = B_PRED = each Y subblock is independently predicted.
|
|
//
|
|
// Returning (as luma_mode) at least 4 (equivalently, returning B_PRED) means
|
|
// that we use "intra4x4 prediction" (as opposed to "intra16x16 prediction").
|
|
// (luma_mode >= 4) here is equivalent to libwebp's "is_i4x4 == true" and
|
|
// golang.org/x/image/vp8's "usePredY16 == false".
|
|
//
|
|
// The RFC gives an enum in (DC_PRED, V_PRED, H_PRED, TM_PRED, B_PRED) order
|
|
// but the libwebp implementation uses a different one, (B_DC_PRED, B_TM_PRED,
|
|
// B_VE_PRED, B_HE_PRED, B_PRED). Modulo the B_ prefixes, it's DC,V,H,TM versus
|
|
// DC,TM,VE,HE. At some point, the internal enum values were re-assigned after
|
|
// the RFC was written.
|
|
//
|
|
// libwebp also uses B_PRED=10 instead of the RFC's B_PRED=4. We use 4.
|
|
pri func decoder.decode_luma_mode!(workbuf: slice base.u8) base.u32[..= 4] {
|
|
var v1 : base.u32[..= 1]
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 145)
|
|
if v1 == 0 {
|
|
return 4 // 4=B_PRED. is_i4x4 == true. usePredY16 == false.
|
|
}
|
|
|
|
// Otherwise, is_i4x4 == false. usePredY16 == true.
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 156)
|
|
if v1 == 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 163)
|
|
return 2 * v1 // 0=B_DC_PRED or 2=B_VE_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
return 3 - (2 * v1) // 3=B_HE_PRED or 1=B_TM_PRED.
|
|
}
|
|
|
|
// RFC 6386 Section 11.4. Chroma Modes.
|
|
//
|
|
// 0 = B_DC_PRED, etc, the same as the Luma Modes, except there's no B_PRED.
|
|
pri func decoder.decode_chroma_mode!(workbuf: slice base.u8) base.u32[..= 3] {
|
|
var v1 : base.u32[..= 1]
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 142)
|
|
if v1 == 0 {
|
|
return 0 // 0=B_DC_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 114)
|
|
if v1 == 0 {
|
|
return 2 // 2=B_VE_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 183)
|
|
return 3 - (2 * v1) // 3=B_HE_PRED or 1=B_TM_PRED.
|
|
}
|
|
|
|
// RFC 6386 Section 11.2. Luma Modes.
|
|
pri func decoder.decode_subblock_modes!(
|
|
workbuf: slice base.u8,
|
|
mbx: base.u32[..= 0x3FF],
|
|
luma_mode: base.u32[..= 4]) {
|
|
var i : base.u32
|
|
var top_mode : base.u8[..= 9]
|
|
var left_mode : base.u8[..= 9]
|
|
var mode : base.u8[..= 9]
|
|
|
|
if args.luma_mode < 4 {
|
|
this.mb_states_top[args.mbx] = (this.mb_states_top[args.mbx] & 0xFFFF_0000) |
|
|
((args.luma_mode as base.u32) * 0x1111)
|
|
this.mb_states_left = (this.mb_states_left & 0xFFFF_0000) |
|
|
((args.luma_mode as base.u32) * 0x1111)
|
|
return nothing
|
|
}
|
|
|
|
i = 0
|
|
while i < 16 {
|
|
if i < 4 {
|
|
top_mode = CLAMP_NO_MORE_THAN_9[15 & (this.mb_states_top[args.mbx] >> (i * 4))]
|
|
} else {
|
|
top_mode = this.mb_subblock_modes[i - 4]
|
|
}
|
|
|
|
if (i & 3) == 0 {
|
|
left_mode = CLAMP_NO_MORE_THAN_9[15 & (this.mb_states_left >> (i & 12))]
|
|
} else {
|
|
left_mode = this.mb_subblock_modes[(i ~mod+ 15) & 15]
|
|
}
|
|
|
|
mode = this.decode_one_subblock_mode!(workbuf: args.workbuf, top_mode: top_mode, left_mode: left_mode)
|
|
this.mb_subblock_modes[i] = mode
|
|
|
|
i += 1
|
|
}
|
|
|
|
this.mb_states_top[args.mbx] = (this.mb_states_top[args.mbx] & 0xFFFF_0000) |
|
|
((this.mb_subblock_modes[0xC] as base.u32) << 0x0) |
|
|
((this.mb_subblock_modes[0xD] as base.u32) << 0x4) |
|
|
((this.mb_subblock_modes[0xE] as base.u32) << 0x8) |
|
|
((this.mb_subblock_modes[0xF] as base.u32) << 0xC)
|
|
this.mb_states_left = (this.mb_states_left & 0xFFFF_0000) |
|
|
((this.mb_subblock_modes[0x3] as base.u32) << 0x0) |
|
|
((this.mb_subblock_modes[0x7] as base.u32) << 0x4) |
|
|
((this.mb_subblock_modes[0xB] as base.u32) << 0x8) |
|
|
((this.mb_subblock_modes[0xF] as base.u32) << 0xC)
|
|
}
|
|
|
|
// RFC 6386 Section 11.3. Subblock Mode Contexts.
|
|
pri func decoder.decode_one_subblock_mode!(
|
|
workbuf: slice base.u8,
|
|
top_mode: base.u8[..= 9],
|
|
left_mode: base.u8[..= 9]) base.u8[..= 9] {
|
|
var v1 : base.u32[..= 1]
|
|
var tm : base.u8[..= 9]
|
|
var lm : base.u8[..= 9]
|
|
|
|
tm = args.top_mode
|
|
lm = args.left_mode
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][0] as base.u32)
|
|
if v1 == 0 {
|
|
return 0 // 0=B_DC_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][1] as base.u32)
|
|
if v1 == 0 {
|
|
return 1 // 1=B_TM_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][2] as base.u32)
|
|
if v1 == 0 {
|
|
return 2 // 2=B_VE_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][3] as base.u32)
|
|
if v1 == 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][4] as base.u32)
|
|
if v1 == 0 {
|
|
return 3 // 3=B_HE_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][5] as base.u32)
|
|
if v1 == 0 {
|
|
return 4 // 4=B_RD_PRED.
|
|
}
|
|
|
|
return 5 // 5=B_VR_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][6] as base.u32)
|
|
if v1 == 0 {
|
|
return 6 // 6=B_LD_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][7] as base.u32)
|
|
if v1 == 0 {
|
|
return 7 // 7=B_VL_PRED.
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: SUBBLOCK_MODE_PROBS[tm][lm][8] as base.u32)
|
|
if v1 == 0 {
|
|
return 8 // 8=B_HD_PRED.
|
|
}
|
|
|
|
return 9 // 9=B_HU_PRED.
|
|
}
|
|
|
|
pri func decoder.copy_from_yuv_cache!(
|
|
workbuf: slice base.u8,
|
|
mbx: base.u32[..= 0x3FF],
|
|
mby: base.u32[..= 0x3FF]) {
|
|
var w : base.u64
|
|
var i : base.u32
|
|
var dst : slice base.u8
|
|
|
|
w = ((((args.mby * this.workbuf_yuv_y_stride) + args.mbx) * 16) as base.u64) + 0
|
|
i = 0
|
|
while i < 16 {
|
|
if w < args.workbuf.length() {
|
|
dst = args.workbuf[w ..]
|
|
dst.copy_from_slice!(s: this.yuv_cache[i + 0x01][0x08 .. 0x18])
|
|
}
|
|
w ~mod+= this.workbuf_yuv_y_stride as base.u64
|
|
i += 1
|
|
}
|
|
|
|
w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_y_end
|
|
i = 0
|
|
while i < 8 {
|
|
if w < args.workbuf.length() {
|
|
dst = args.workbuf[w ..]
|
|
dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x08 .. 0x10])
|
|
}
|
|
w ~mod+= this.workbuf_yuv_uv_stride as base.u64
|
|
i += 1
|
|
}
|
|
|
|
w = ((((args.mby * this.workbuf_yuv_uv_stride) + args.mbx) * 8) as base.u64) + this.workbuf_yuv_u_end
|
|
i = 0
|
|
while i < 8 {
|
|
if w < args.workbuf.length() {
|
|
dst = args.workbuf[w ..]
|
|
dst.copy_from_slice!(s: this.yuv_cache[i + 0x12][0x18 .. 0x20])
|
|
}
|
|
w ~mod+= this.workbuf_yuv_uv_stride as base.u64
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.swizzle!(
|
|
dst: ptr base.pixel_buffer,
|
|
blend: base.pixel_blend,
|
|
workbuf: slice base.u8) base.status {
|
|
var wh : base.u64[..= 0xFFF_8001]
|
|
var prefix : slice base.u8
|
|
var suffix : slice base.u8
|
|
var has_alpha : base.u32[..= 1]
|
|
var ycc_model : base.u32[..= 0xFF]
|
|
var status : base.status
|
|
|
|
if this.quirk_has_alpha_side_channel {
|
|
if this.quirk_width_and_height == 0 {
|
|
return "#inconsistent width and height"
|
|
}
|
|
wh = (this.width * this.height) as base.u64
|
|
if wh > args.workbuf.length() {
|
|
return base."#bad workbuf length"
|
|
}
|
|
prefix = args.workbuf[.. wh]
|
|
suffix = args.workbuf[wh ..]
|
|
has_alpha = 1
|
|
ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC |
|
|
(0x01 & (this.util.demake_pixel_blend(a: args.blend) as base.u32))
|
|
|
|
} else {
|
|
prefix = this.util.empty_slice_u8()
|
|
suffix = args.workbuf
|
|
has_alpha = 0
|
|
ycc_model = base.YCC_MODEL__BT_601_STUDIO_RANGE
|
|
}
|
|
|
|
if (this.workbuf_yuv_y_end > this.workbuf_yuv_u_end) or
|
|
(this.workbuf_yuv_u_end > this.workbuf_yuv_v_end) or
|
|
(this.workbuf_yuv_v_end > suffix.length()) {
|
|
return base."#bad workbuf length"
|
|
}
|
|
assert this.workbuf_yuv_u_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_v_end)
|
|
assert this.workbuf_yuv_y_end <= suffix.length() via "a <= b: a <= c; c <= b"(c: this.workbuf_yuv_u_end)
|
|
|
|
status = this.swizzler.swizzle_ycck!(
|
|
dst: args.dst,
|
|
dst_palette: args.dst.palette(),
|
|
x_min_incl: 0,
|
|
x_max_excl: this.width,
|
|
y_min_incl: 0,
|
|
y_max_excl: this.height,
|
|
src0: suffix[.. this.workbuf_yuv_y_end],
|
|
src1: suffix[this.workbuf_yuv_y_end .. this.workbuf_yuv_u_end],
|
|
src2: suffix[this.workbuf_yuv_u_end .. this.workbuf_yuv_v_end],
|
|
src3: prefix,
|
|
width0: this.mbw * 16,
|
|
width1: this.mbw * 8,
|
|
width2: this.mbw * 8,
|
|
width3: this.width * has_alpha,
|
|
height0: this.mbh * 16,
|
|
height1: this.mbh * 8,
|
|
height2: this.mbh * 8,
|
|
height3: this.height * has_alpha,
|
|
stride0: this.mbw * 16,
|
|
stride1: this.mbw * 8,
|
|
stride2: this.mbw * 8,
|
|
stride3: this.width * has_alpha,
|
|
h0: 2,
|
|
h1: 1,
|
|
h2: 1,
|
|
h3: (2 * has_alpha) as base.u8,
|
|
v0: 2,
|
|
v1: 1,
|
|
v2: 1,
|
|
v3: (2 * has_alpha) as base.u8,
|
|
ycc_model: ycc_model as base.u8,
|
|
ycc_upsampling: base.YCC_UPSAMPLING__FANCY_LIKE_LIBWEBP as base.u8,
|
|
scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..])
|
|
return status
|
|
}
|