mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
330 lines
9.4 KiB
Plaintext
330 lines
9.4 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
|
|
|
|
// --------
|
|
|
|
// RFC 6386 Section 13. DCT Coefficient Decoding.
|
|
//
|
|
// and
|
|
//
|
|
// RFC 6386 Section 13.2. Coding of Individual Coefficient Values.
|
|
|
|
pri func decoder.decode_coefficients!(
|
|
workbuf: slice base.u8,
|
|
mbx: base.u32[..= 0x3FF],
|
|
mby: base.u32[..= 0x3FF],
|
|
seg: base.u32[..= 3],
|
|
luma_mode: base.u32[..= 4]) base.u32[..= 1] {
|
|
var bc : base.u32
|
|
var by : base.u32
|
|
var bx : base.u32
|
|
var b : base.u32[..= 23]
|
|
var plane : base.u32[..= 3]
|
|
var lnz : base.u32[..= 1]
|
|
var tnz : base.u32[..= 1]
|
|
var bit : base.u32[..= 1]
|
|
|
|
this.mb_dc_nz = 0
|
|
this.mb_ac_nz = 0
|
|
this.initialize_mb_coeffs!()
|
|
|
|
// Handle "intra16x16 prediction".
|
|
plane = 3 // Plane 3: Y beginning at coefficient 0.
|
|
if args.luma_mode < 4 {
|
|
lnz = 1 & (this.mb_states_left >> 23)
|
|
this.mb_states_left &= 0xFF7F_FFFF
|
|
|
|
tnz = 1 & (this.mb_states_top[args.mbx] >> 23)
|
|
this.mb_states_top[args.mbx] &= 0xFF7F_FFFF
|
|
|
|
lnz = this.decode_subblock_coefficients!(
|
|
workbuf: args.workbuf,
|
|
mby: args.mby,
|
|
seg: args.seg,
|
|
b: 24,
|
|
plane: 1, // Plane 1: Y2.
|
|
context: lnz + tnz)
|
|
|
|
this.mb_states_top[args.mbx] |= lnz << 23
|
|
this.mb_states_left |= lnz << 23
|
|
|
|
this.inverse_wht!()
|
|
plane = 0 // Plane 0: Y beginning at coefficient 1.
|
|
}
|
|
|
|
// Parse Luma coefficients.
|
|
|
|
by = 0
|
|
while by < 4 {
|
|
lnz = 1 & (this.mb_states_left >> (24 + by))
|
|
this.mb_states_left &= 0xFFFF_FFFF ^ ((1 as base.u32) << (24 + by))
|
|
|
|
bx = 0
|
|
while bx < 4,
|
|
inv by < 4,
|
|
{
|
|
tnz = 1 & (this.mb_states_top[args.mbx] >> (24 + bx))
|
|
this.mb_states_top[args.mbx] &= 0xFFFF_FFFF ^ ((1 as base.u32) << (24 + bx))
|
|
|
|
b = (4 * by) + bx
|
|
|
|
lnz = this.decode_subblock_coefficients!(
|
|
workbuf: args.workbuf,
|
|
mby: args.mby,
|
|
seg: args.seg,
|
|
b: b,
|
|
plane: plane,
|
|
context: lnz + tnz)
|
|
|
|
bit = 0
|
|
if this.mb_coeffs[b][0] <> 0 {
|
|
bit = 1
|
|
}
|
|
this.mb_dc_nz |= bit << b
|
|
this.mb_ac_nz |= lnz << b
|
|
this.mb_states_top[args.mbx] |= lnz << (24 + bx)
|
|
|
|
bx += 1
|
|
}
|
|
this.mb_states_left |= lnz << (24 + by)
|
|
|
|
by += 1
|
|
}
|
|
|
|
// Parse Chroma coefficients.
|
|
|
|
bc = 0
|
|
while bc <= 2 {
|
|
by = 0
|
|
while by < 2,
|
|
inv bc <= 2,
|
|
{
|
|
lnz = 1 & (this.mb_states_left >> (28 + bc + by))
|
|
this.mb_states_left &= 0xFFFF_FFFF ^ ((1 as base.u32) << (28 + bc + by))
|
|
|
|
bx = 0
|
|
while bx < 2,
|
|
inv bc <= 2,
|
|
inv by < 2,
|
|
{
|
|
tnz = 1 & (this.mb_states_top[args.mbx] >> (28 + bc + bx))
|
|
this.mb_states_top[args.mbx] &= 0xFFFF_FFFF ^ ((1 as base.u32) << (28 + bc + bx))
|
|
|
|
b = (2 * bc) + (2 * by) + bx + 16
|
|
lnz = this.decode_subblock_coefficients!(
|
|
workbuf: args.workbuf,
|
|
mby: args.mby,
|
|
seg: args.seg,
|
|
b: b,
|
|
plane: 2, // Plane 2: U or V.
|
|
context: lnz + tnz)
|
|
|
|
this.mb_states_top[args.mbx] |= lnz << (28 + bc + bx)
|
|
bit = 0
|
|
if this.mb_coeffs[b][0] <> 0 {
|
|
bit = 1
|
|
}
|
|
this.mb_dc_nz |= bit << b
|
|
this.mb_ac_nz |= lnz << b
|
|
|
|
bx += 1
|
|
}
|
|
this.mb_states_left |= lnz << (28 + bc + by)
|
|
|
|
by += 1
|
|
}
|
|
bc += 2
|
|
}
|
|
|
|
if (this.mb_dc_nz == 0) and (this.mb_ac_nz == 0) {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
pri func decoder.initialize_mb_coeffs!() {
|
|
var i : base.u32
|
|
var j : base.u32
|
|
|
|
i = 0
|
|
while i < 25 {
|
|
j = 0
|
|
while j < 16,
|
|
inv i < 25,
|
|
{
|
|
this.mb_coeffs[i][j] = 0
|
|
j += 1
|
|
}
|
|
i += 1
|
|
}
|
|
}
|
|
|
|
pri func decoder.decode_subblock_coefficients!(
|
|
workbuf: slice base.u8,
|
|
mby: base.u32[..= 0x3FF],
|
|
seg: base.u32[..= 3],
|
|
b: base.u32[..= 24],
|
|
plane: base.u32[..= 3],
|
|
context: base.u32[..= 2]) base.u32[..= 1] {
|
|
var q1 : base.u32[..= 2]
|
|
var q2 : base.u32[..= 1]
|
|
var quant : base.u32
|
|
var i : base.u32
|
|
var part : base.u32[..= 8]
|
|
var prob_base : base.u32[..= 1045]
|
|
var v1 : base.u32[..= 1]
|
|
var value : base.u32
|
|
|
|
q1 = 0
|
|
if args.b == 24 {
|
|
q1 = 1
|
|
} else if args.b >= 16 {
|
|
q1 = 2
|
|
}
|
|
|
|
i = 0
|
|
assert i <= 1
|
|
if args.plane == 0 {
|
|
i = 1
|
|
assert i <= 1
|
|
}
|
|
|
|
part = 1 + (args.mby & this.num_other_partitions_m1)
|
|
prob_base = (args.plane * (8 * 3 * 11)) + COEFF_BANDS_33[i] + (args.context * 11)
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: part,
|
|
prob: this.coeff_probs[prob_base + 0] as base.u32)
|
|
if v1 == 0 {
|
|
return 0
|
|
}
|
|
|
|
while true,
|
|
pre i < 16,
|
|
{
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: part,
|
|
prob: this.coeff_probs[prob_base + 1] as base.u32)
|
|
if v1 == 0 {
|
|
i += 1
|
|
if i >= 16 {
|
|
break
|
|
}
|
|
prob_base = (args.plane * (8 * 3 * 11)) + COEFF_BANDS_33[i + 0] + (0 * 11)
|
|
continue
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: part,
|
|
prob: this.coeff_probs[prob_base + 2] as base.u32)
|
|
if v1 == 0 {
|
|
value = 1
|
|
prob_base = (args.plane * (8 * 3 * 11)) + COEFF_BANDS_33[i + 1] + (1 * 11)
|
|
} else {
|
|
value = this.decode_large_value!(
|
|
workbuf: args.workbuf,
|
|
part: part,
|
|
prob_base: prob_base)
|
|
prob_base = (args.plane * (8 * 3 * 11)) + COEFF_BANDS_33[i + 1] + (2 * 11)
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: part, prob: 128)
|
|
if v1 <> 0 {
|
|
value = 0 ~mod- value
|
|
}
|
|
|
|
q2 = 0
|
|
if i <> 0 {
|
|
q2 = 1
|
|
}
|
|
quant = this.dequants[args.seg][q1][q2] as base.u32
|
|
this.mb_coeffs[args.b][ZIGZAG[i]] = ((value ~mod* quant) & 0xFFFF) as base.u16
|
|
|
|
if i >= 15 {
|
|
break
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: part,
|
|
prob: this.coeff_probs[prob_base + 0] as base.u32)
|
|
if v1 == 0 {
|
|
break
|
|
}
|
|
|
|
i += 1
|
|
}
|
|
|
|
return 1
|
|
}
|
|
|
|
pri func decoder.decode_large_value!(
|
|
workbuf: slice base.u8,
|
|
part: base.u32[..= 8],
|
|
prob_base: base.u32[..= 1045]) base.u32[2 ..= 2114] {
|
|
var v1 : base.u32[..= 1]
|
|
var w1 : base.u32[..= 1]
|
|
var category : base.u32[..= 3]
|
|
var value : base.u32
|
|
var i : base.u32[..= 15]
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 3] as base.u32)
|
|
if v1 == 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 4] as base.u32)
|
|
if v1 == 0 {
|
|
return 2
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 5] as base.u32)
|
|
return 3 + v1
|
|
}
|
|
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 6] as base.u32)
|
|
if v1 == 0 {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 7] as base.u32)
|
|
if v1 == 0 {
|
|
// Category 1.
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: 159)
|
|
return 5 + v1
|
|
}
|
|
|
|
// Category 2.
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: 165)
|
|
w1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: 145)
|
|
return 7 + (2 * v1) + w1
|
|
}
|
|
|
|
// Categories 3, 4, 5, 6.
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 8] as base.u32)
|
|
w1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: this.coeff_probs[args.prob_base + 9 + v1] as base.u32)
|
|
category = (2 * v1) + w1
|
|
|
|
// Read 3, 4, 5 or 11 extra bits, depending on the category.
|
|
value = 0
|
|
i = 0
|
|
while true {
|
|
v1 = this.read_bit!(workbuf: args.workbuf, part: args.part,
|
|
prob: CATEGORY_PROBS[category][i] as base.u32)
|
|
value ~mod<<= 1
|
|
value ~mod+= v1
|
|
|
|
i = (i + 1) & 15
|
|
if CATEGORY_PROBS[category][i] == 0 {
|
|
break
|
|
}
|
|
}
|
|
return (value & 0x7FF) + ((8 as base.u32) << category) + 3
|
|
}
|