mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
397 lines
13 KiB
Plaintext
397 lines
13 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.copy_partitions_to_workbuf?(src: base.io_reader, workbuf: slice base.u8) {
|
|
var i : base.u64
|
|
var j : base.u64
|
|
var n : base.u32
|
|
|
|
i = this.workbuf_yuv_v_end
|
|
j = this.workbuf_yuv_v_end + (this.partitioned_data_length as base.u64)
|
|
|
|
while i < j,
|
|
inv j <= 0x20FF_FFF7,
|
|
{
|
|
if j > args.workbuf.length() {
|
|
return base."#bad workbuf length"
|
|
}
|
|
assert j > i via "a > b: b < a"()
|
|
n = args.src.limited_copy_u32_to_slice!(
|
|
up_to: ((j - i) & 0xFFFF_FFFF) as base.u32,
|
|
s: args.workbuf[i .. j])
|
|
i ~mod+= n as base.u64
|
|
if i < j {
|
|
yield? base."$short read"
|
|
}
|
|
}
|
|
|
|
// Write eight 0x00 bytes to the end of the workbuf, past what we copy from
|
|
// args.src. Later on, we can then always peek_u64le from the workbuf.
|
|
|
|
j += 8
|
|
while i < j {
|
|
assert i < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: j)
|
|
if i >= args.workbuf.length() {
|
|
return base."#bad workbuf length"
|
|
}
|
|
args.workbuf[i] = 0x00
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.decode_header_partition!(workbuf: roslice base.u8) base.status {
|
|
var v1 : base.u32[..= 1]
|
|
var v32 : base.u32
|
|
|
|
// RFC 6386 Section 9.2. Color Space and Pixel Type (Key Frames Only).
|
|
if this.is_key_frame {
|
|
this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
}
|
|
|
|
// RFC 6386 Section 9.3. Segment-Based Adjustments.
|
|
this.decode_segment_header!(workbuf: args.workbuf)
|
|
|
|
// RFC 6386 Section 9.4. Loop Filter Type and Levels.
|
|
this.decode_filter_header!(workbuf: args.workbuf)
|
|
this.calculate_loop_filters!()
|
|
|
|
// RFC 6386 Section 9.5. Token Partition and Partition Data Offsets.
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 2)
|
|
this.num_other_partitions_m1 = ((1 as base.u32) << (v32 & 3)) - 1
|
|
|
|
// RFC 6386 Section 9.6. Dequantization Indices.
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 7)
|
|
this.quant_yac_qi = v32 & 127
|
|
this.quant_ydc_delta = this.read_signed!(workbuf: args.workbuf, part: 0, n: 4)
|
|
this.quant_y2dc_delta = this.read_signed!(workbuf: args.workbuf, part: 0, n: 4)
|
|
this.quant_y2ac_delta = this.read_signed!(workbuf: args.workbuf, part: 0, n: 4)
|
|
this.quant_uvdc_delta = this.read_signed!(workbuf: args.workbuf, part: 0, n: 4)
|
|
this.quant_uvac_delta = this.read_signed!(workbuf: args.workbuf, part: 0, n: 4)
|
|
this.calculate_dequants!()
|
|
|
|
// RFC 6386 Section 9.7. Refresh Golden Frame and Altref Frame.
|
|
if not this.is_key_frame {
|
|
return "#unsupported VP8 file"
|
|
}
|
|
|
|
// RFC 6386 Section 9.8. Refresh Last Frame Buffer.
|
|
this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
|
|
// RFC 6386 Section 9.9. DCT Coefficient Probability Update.
|
|
this.decode_coeff_probs!(workbuf: args.workbuf)
|
|
|
|
if not this.is_key_frame {
|
|
// RFC 6386 Section 9.10. Remaining Frame Header Data (Non-Key Frame).
|
|
return "#unsupported VP8 file"
|
|
|
|
} else {
|
|
// RFC 6386 Section 9.11. Remaining Frame Header Data (Key Frame).
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
if v1 <> 0 {
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 8)
|
|
this.prob_skip = (v32 & 0xFF) | 0x100
|
|
}
|
|
}
|
|
|
|
return ok
|
|
}
|
|
|
|
pri func decoder.decode_segment_header!(workbuf: roslice base.u8) {
|
|
var v1 : base.u32[..= 1]
|
|
var v32 : base.u32
|
|
var i : base.u32
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.seg_enabled = v1 <> 0
|
|
if not this.seg_enabled {
|
|
this.seg_update_map = false
|
|
return nothing
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.seg_update_map = v1 <> 0
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
if v1 <> 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.seg_absolute = v1 <> 0
|
|
|
|
i = 0
|
|
while i < 4 {
|
|
v32 = this.read_signed!(workbuf: args.workbuf, part: 0, n: 7)
|
|
this.seg_quants[i] = (v32 & 0xFF) as base.u8
|
|
i += 1
|
|
}
|
|
|
|
i = 0
|
|
while i < 4 {
|
|
v32 = this.read_signed!(workbuf: args.workbuf, part: 0, n: 6)
|
|
this.seg_strengths[i] = (v32 & 0xFF) as base.u8
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
if this.seg_update_map {
|
|
i = 0
|
|
while i < 3 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
if v1 <> 0 {
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 8)
|
|
this.seg_probs[i] = (v32 & 0xFF) as base.u8
|
|
} else {
|
|
this.seg_probs[i] = 0xFF
|
|
}
|
|
i += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
pri func decoder.decode_filter_header!(workbuf: roslice base.u8) {
|
|
var v1 : base.u32[..= 1]
|
|
var v32 : base.u32
|
|
var i : base.u32
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.filt_simple = v1 <> 0
|
|
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 6)
|
|
this.filt_level = (v32 & 0x3F) as base.u8
|
|
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 3)
|
|
this.filt_sharpness = (v32 & 0x07) as base.u8
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
this.filt_deltas_enabled = v1 <> 0
|
|
if not this.filt_deltas_enabled {
|
|
return nothing
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: 128)
|
|
if v1 == 0 {
|
|
return nothing
|
|
}
|
|
|
|
i = 0
|
|
while i < 8 {
|
|
v32 = this.read_signed!(workbuf: args.workbuf, part: 0, n: 6)
|
|
this.filt_deltas[i >> 2][i & 3] = (v32 & 0xFF) as base.u8
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.decode_coeff_probs!(workbuf: roslice base.u8) {
|
|
var v1 : base.u32[..= 1]
|
|
var v32 : base.u32
|
|
var i : base.u32
|
|
|
|
i = 0
|
|
while i < 1056 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: 0, prob: COEFF_UPDATE_PROBS[i] as base.u32)
|
|
if v1 <> 0 {
|
|
v32 = this.read_unsigned!(workbuf: args.workbuf, part: 0, n: 8)
|
|
this.coeff_probs[i] = (v32 & 0xFF) as base.u8
|
|
} else {
|
|
this.coeff_probs[i] = DEFAULT_COEFF_PROBS[i]
|
|
}
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.calculate_loop_filters!() {
|
|
var seg : base.u32
|
|
var inner : base.u32
|
|
var level : base.u32
|
|
var ilevel : base.u32
|
|
var hlevel : base.u32
|
|
|
|
seg = 0
|
|
while seg < 4 {
|
|
inner = 0
|
|
while inner < 2,
|
|
inv seg < 4,
|
|
{
|
|
level = this.filt_level as base.u32
|
|
if not this.seg_enabled {
|
|
// No-op.
|
|
} else if not this.filt_deltas_enabled {
|
|
level = this.util.sign_extend_convert_u8_u32(a: this.seg_strengths[seg])
|
|
} else {
|
|
// The (level as base.u32) is redundant, equivalent to level, but
|
|
// avoids a -Werror=sign-conversion false positive with gcc 12.2.0.
|
|
level = (level as base.u32) ~mod+
|
|
this.util.sign_extend_convert_u8_u32(a: this.seg_strengths[seg])
|
|
}
|
|
|
|
// Yes, filt_deltas[*][0], not filt_deltas[*][seg].
|
|
if this.filt_deltas_enabled {
|
|
level = (level as base.u32) ~mod+
|
|
this.util.sign_extend_convert_u8_u32(a: this.filt_deltas[0][0])
|
|
if inner <> 0 {
|
|
level = (level as base.u32) ~mod+
|
|
this.util.sign_extend_convert_u8_u32(a: this.filt_deltas[1][0])
|
|
}
|
|
}
|
|
|
|
if level >= 0x8000_0000 {
|
|
this.loop_filters[(2 * seg) + inner] = 0
|
|
inner += 1
|
|
continue
|
|
|
|
} else if level > 63 {
|
|
level = 63
|
|
}
|
|
|
|
ilevel = level
|
|
if this.filt_sharpness > 0 {
|
|
if this.filt_sharpness <= 4 {
|
|
ilevel >>= 1
|
|
} else {
|
|
ilevel >>= 2
|
|
}
|
|
ilevel = ilevel.max(no_less_than: (9 - this.filt_sharpness) as base.u32)
|
|
}
|
|
if (ilevel < 1) or (0x8000_0000 <= ilevel) {
|
|
ilevel = 1
|
|
}
|
|
|
|
// If we ever want to support (this.is_key_frame == false), note
|
|
// that the hlevel thresholds are a little different then.
|
|
if level < 15 {
|
|
hlevel = 0
|
|
} else if level < 40 {
|
|
hlevel = 1
|
|
} else {
|
|
hlevel = 2
|
|
}
|
|
|
|
level = (2 ~mod* level) ~mod+ ilevel
|
|
|
|
this.loop_filters[(2 * seg) + inner] =
|
|
level | (ilevel ~mod<< 8) | (hlevel ~mod<< 16) | (inner << 31)
|
|
|
|
inner += 1
|
|
}
|
|
seg += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.calculate_dequants!() {
|
|
var seg : base.u32
|
|
var q : base.u32
|
|
|
|
seg = 0
|
|
while seg < 4 {
|
|
q = this.quant_yac_qi
|
|
if not this.seg_enabled {
|
|
// No-op.
|
|
} else if this.seg_absolute {
|
|
q = this.util.sign_extend_convert_u8_u32(a: this.seg_quants[seg])
|
|
} else {
|
|
// The (q as base.u32) is redundant, equivalent to q, but avoids a
|
|
// -Werror=sign-conversion false positive with gcc 12.2.0.
|
|
q = (q as base.u32) ~mod+
|
|
this.util.sign_extend_convert_u8_u32(a: this.seg_quants[seg])
|
|
}
|
|
|
|
this.dequants[seg][0][0] = DEQUANTS[0][this.clip_127(a: q ~mod+ this.quant_ydc_delta)]
|
|
this.dequants[seg][0][1] = DEQUANTS[1][this.clip_127(a: q)]
|
|
this.dequants[seg][1][0] = DEQUANTS[0][this.clip_127(a: q ~mod+ this.quant_y2dc_delta)] * 2
|
|
this.dequants[seg][1][1] = (DEQUANTS[1][this.clip_127(a: q ~mod+ this.quant_y2ac_delta)] * 155) / 100
|
|
if this.dequants[seg][1][1] < 8 {
|
|
this.dequants[seg][1][1] = 8
|
|
}
|
|
this.dequants[seg][2][0] = DEQUANTS[0][this.clip_127(a: q ~mod+ this.quant_uvdc_delta)]
|
|
if this.dequants[seg][2][0] > 132 {
|
|
this.dequants[seg][2][0] = 132
|
|
}
|
|
this.dequants[seg][2][1] = DEQUANTS[1][this.clip_127(a: q ~mod+ this.quant_uvac_delta)]
|
|
|
|
seg += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.clip_127(a: base.u32) base.u32[..= 127] {
|
|
if args.a <= 127 {
|
|
return args.a
|
|
} else if args.a < 0x8000_0000 {
|
|
return 127
|
|
}
|
|
return 0
|
|
}
|
|
|
|
pri func decoder.decode_other_partition_lengths!(workbuf: roslice base.u8) base.status {
|
|
var v32 : base.u32
|
|
var remainder : base.u32
|
|
var i : base.u32
|
|
var o : base.u64
|
|
|
|
remainder = this.partitioned_data_length ~sat- this.part_lens[0]
|
|
remainder ~sat-= 3 * this.num_other_partitions_m1
|
|
|
|
o = this.workbuf_yuv_v_end + (this.part_lens[0] as base.u64)
|
|
i = 0
|
|
while i < this.num_other_partitions_m1 {
|
|
assert i < 7 via "a < b: a < c; c <= b"(c: this.num_other_partitions_m1)
|
|
|
|
v32 = 0
|
|
|
|
if o >= args.workbuf.length() {
|
|
return "#bad header"
|
|
}
|
|
assert o < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: args.workbuf.length())
|
|
v32 |= (args.workbuf[o] as base.u32) << 0
|
|
o += 1
|
|
|
|
if o >= args.workbuf.length() {
|
|
return "#bad header"
|
|
}
|
|
assert o < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: args.workbuf.length())
|
|
v32 |= (args.workbuf[o] as base.u32) << 8
|
|
o += 1
|
|
|
|
if o >= args.workbuf.length() {
|
|
return "#bad header"
|
|
}
|
|
assert o < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: args.workbuf.length())
|
|
v32 |= (args.workbuf[o] as base.u32) << 16
|
|
o += 1
|
|
|
|
if remainder < v32 {
|
|
return "#bad header"
|
|
}
|
|
remainder -= v32
|
|
|
|
this.part_lens[1 + i] = v32
|
|
|
|
i += 1
|
|
}
|
|
|
|
if remainder > 0xFF_FFFF {
|
|
return "#unsupported VP8 file"
|
|
}
|
|
this.part_lens[1 + this.num_other_partitions_m1] = remainder
|
|
|
|
i = 0
|
|
while i < (1 + this.num_other_partitions_m1) {
|
|
assert i < 8 via "a < b: a < c; c <= b"(c: (1 + this.num_other_partitions_m1))
|
|
|
|
this.part_workbuf_ris[1 + i] = o
|
|
o ~mod+= this.part_lens[1 + i] as base.u64
|
|
if o > args.workbuf.length() {
|
|
return "#bad header"
|
|
}
|
|
|
|
i += 1
|
|
}
|
|
|
|
return ok
|
|
}
|