// AV1 intra frame encoder (one key frame, 8-bit, 4:2:0 or monochrome):
// partition / mode info / residual coding as in the spec's decoding
// process, with the decoder's reconstruction mirrored exactly.
///|
let av1_block_8x8 = 3
///|
let av1_block_64x64 = 12
///|
fn av1_bw4(bs : Int32) -> Int32 {
1 << av1_mi_width_log2[bs]
}
///|
fn av1_bh4(bs : Int32) -> Int32 {
1 << av1_mi_height_log2[bs]
}
///|
/// Partition_Subsize for square sizes (8x8 .. 64x64): NONE, HORZ, VERT,
/// SPLIT.
fn av1_subsize(partition : Int32, bs : Int32) -> Int32 {
match (partition, bs) {
(0, _) => bs
(1, 3) => 2
(1, 6) => 5
(1, 9) => 8
(1, _) => 11
(2, 3) => 1
(2, 6) => 4
(2, 9) => 7
(2, _) => 10
(_, 3) => 0
(_, 6) => 3
(_, 9) => 6
_ => 9
}
}
///|
fn av1_scan_for(tx_size : Int32) -> FixedArray[Int32] {
match tx_size {
0 => av1_scan_4x4
1 => av1_scan_8x8
2 => av1_scan_16x16
3 | 4 | 11 | 12 => av1_scan_32x32
5 => av1_scan_4x8
6 => av1_scan_8x4
7 => av1_scan_8x16
8 => av1_scan_16x8
9 | 17 => av1_scan_16x32
10 | 18 => av1_scan_32x16
13 => av1_scan_4x16
14 => av1_scan_16x4
15 => av1_scan_8x32
_ => av1_scan_32x8
}
}
///|
/// Intra transform set with reduced_tx_set = 1: 0 DCT only, 2 INTRA_2.
fn av1_tx_set(tx_size : Int32) -> Int32 {
if av1_tx_size_sqr_up[tx_size] >= 3 {
0
} else {
2
}
}
///|
/// Index of a transform type in Tx_Type_Intra_Inv_Set2 (IDTX, DCT_DCT,
/// ADST_ADST, ADST_DCT, DCT_ADST).
fn av1_itx2_index(tx_type : Int32) -> Int32 {
match tx_type {
9 => 0
0 => 1
3 => 2
1 => 3
_ => 4
}
}
///|
/// Mode decisions of one block.
priv struct Av1BlockMode {
mut ymode : Int32
mut uvmode : Int32
mut angle_y : Int32
mut angle_uv : Int32
mut skip : Bool
// Luma transform type of each transform block, raster order.
tx_types : Array[Int32]
}
///|
fn Av1BlockMode::new() -> Av1BlockMode {
{ ymode: 0, uvmode: 0, angle_y: 0, angle_uv: 0, skip: false, tx_types: [], }
}
///|
priv struct Av1Enc {
width : Int32
height : Int32
mi_cols : Int32
mi_rows : Int32
num_planes : Int32
ss : Int32
stride : FixedArray[Int32]
src : Array[FixedArray[Int32]]
rec : Array[FixedArray[Int32]]
qidx : Int32
dcq : Int32
acq : Int32
// Mode info grid (mi units, frame).
mi_size : FixedArray[Int32]
mi_ymode : FixedArray[Int32]
mi_uvmode : FixedArray[Int32]
mi_skip : FixedArray[Int32]
// Luma transform type per 4x4.
tx_types : FixedArray[Int32]
above_level : Array[FixedArray[Int32]]
above_dc : Array[FixedArray[Int32]]
left_level : Array[FixedArray[Int32]]
left_dc : Array[FixedArray[Int32]]
// BlockDecoded: 3 planes x 18 x 18, offset 1.
decoded : FixedArray[Bool]
cdf : Av1Cdfs
sw : Av1SymWriter
edges : Av1Edges
mut dry : Bool
mut search_tx : Bool
mut ready_eob : Int32
lambda : Double
mut cost : Int32
mut any_nonzero : Bool
// Current block.
mut mi_row : Int32
mut mi_col : Int32
mut bsize : Int32
mut avail_u : Bool
mut avail_l : Bool
mut avail_uc : Bool
mut avail_lc : Bool
mut has_chroma : Bool
mut tx_size : Int32
mut mode : Av1BlockMode
mut tx_index : Int32
// Scratch.
res : FixedArray[Int32]
coef : FixedArray[Double]
levels : FixedArray[Int32]
dq : FixedArray[Int32]
quant_ctx : FixedArray[Int32]
tx_ctx_save : FixedArray[Int32]
best_levels : FixedArray[Int32]
}
///|
fn Av1Enc::new(
planes : Array[FixedArray[Int32]],
width : Int32,
height : Int32,
qidx : Int32,
) -> Av1Enc {
let num_planes = planes.length()
let mi_cols = 2 * ((width + 7) >> 3)
let mi_rows = 2 * ((height + 7) >> 3)
// Planes are allocated in whole superblocks (blocks may extend past the
// mode info area) and padded by edge replication.
let aw = (mi_cols * 4 + 63) / 64 * 64
let ah = (mi_rows * 4 + 63) / 64 * 64
let ss = if num_planes > 1 { 1 } else { 0 }
let stride = FixedArray::makei(num_planes, fn(p) {
if p == 0 {
aw
} else {
aw >> ss
}
})
let src : Array[FixedArray[Int32]] = []
let rec : Array[FixedArray[Int32]] = []
for p in 0..> ss }
let ph = if p == 0 { height } else { (height + ss) >> ss }
let sw = stride[p]
let sh = if p == 0 { ah } else { ah >> ss }
let s = FixedArray::make(sw * sh, 0)
for y in 0.. Unit {
if self.dry {
self.cost += av1_symbol_cost(self.cdf.data, off, s)
} else {
self.sw.symbol(self.cdf.data, off, n, s)
}
}
///|
fn Av1Enc::literal(self : Av1Enc, v : Int32, n : Int32) -> Unit {
if self.dry {
self.cost += 256 * n
} else {
self.sw.literal(v, n)
}
}
///|
fn Av1Enc::inside(self : Av1Enc, r : Int32, c : Int32) -> Bool {
r >= 0 && c >= 0 && r < self.mi_rows && c < self.mi_cols
}
///|
fn Av1Enc::dec_idx(plane : Int32, y : Int32, x : Int32) -> Int32 {
plane * 324 + (y + 1) * 18 + (x + 1)
}
///|
/// clear_block_decoded_flags for the superblock at (r, c).
fn Av1Enc::clear_decoded(self : Av1Enc, r : Int32, c : Int32) -> Unit {
let sb4 = 16
for plane in 0.. 0 { self.ss } else { 0 }
let sbw4 = (self.mi_cols - c) >> sub
let sbh4 = (self.mi_rows - r) >> sub
for y = -1; y <= sb4 >> sub; y = y + 1 {
for x = -1; x <= sb4 >> sub; x = x + 1 {
self.decoded[Av1Enc::dec_idx(plane, y, x)] = if y < 0 && x < sbw4 {
true
} else if x < 0 && y < sbh4 {
true
} else {
false
}
}
}
self.decoded[Av1Enc::dec_idx(plane, sb4 >> sub, -1)] = false
}
}
///|
/// Partition symbol context for a square block at (r, c).
fn Av1Enc::partition_ctx(
self : Av1Enc,
r : Int32,
c : Int32,
bs : Int32,
) -> Int32 {
let bsl = av1_mi_width_log2[bs]
let above = self.inside(r - 1, c) &&
av1_mi_width_log2[self.mi_size[(r - 1) * self.mi_cols + c]] < bsl
let left = self.inside(r, c - 1) &&
av1_mi_height_log2[self.mi_size[r * self.mi_cols + c - 1]] < bsl
(if left { 2 } else { 0 }) + (if above { 1 } else { 0 })
}
///|
/// (offset, symbols) of the partition CDF for a square block size.
fn Av1Enc::partition_cdf(
self : Av1Enc,
bs : Int32,
ctx : Int32,
) -> (Int32, Int32) {
match av1_mi_width_log2[bs] {
1 => (self.cdf.part8 + ctx * 5, 4)
2 => (self.cdf.part16 + ctx * 11, 10)
3 => (self.cdf.part32 + ctx * 11, 10)
4 => (self.cdf.part64 + ctx * 11, 10)
_ => (self.cdf.part128 + ctx * 9, 8)
}
}
///|
/// Write the partition of a square block (or its split_or_horz /
/// split_or_vert form at the frame edges).
fn Av1Enc::write_partition(
self : Av1Enc,
r : Int32,
c : Int32,
bs : Int32,
partition : Int32,
has_rows : Bool,
has_cols : Bool,
) -> Unit {
let ctx = self.partition_ctx(r, c, bs)
let (off, n) = self.partition_cdf(bs, ctx)
let cdf = self.cdf.data
if has_rows && has_cols {
self.sym(off, n, partition)
} else if has_cols || has_rows {
// The probability of "split" gathers the partitions that also split
// in the missing direction.
let p = fn(k : Int32) { cdf[off + k] - cdf[off + k - 1] }
let mut psum = if has_cols {
// split_or_horz: VERT, SPLIT, HORZ_A, VERT_A, VERT_B, VERT_4
p(2) + p(3) + p(4) + p(6) + p(7)
} else {
// split_or_vert: HORZ, SPLIT, HORZ_A, HORZ_B, VERT_A, HORZ_4
p(1) + p(3) + p(4) + p(5) + p(6)
}
if bs != 15 {
psum += if has_cols { p(9) } else { p(8) }
}
let bit = if partition == 3 { 1 } else { 0 }
let f0 = 32768 - psum
if self.dry {
self.cost += av1_cost_q15(if bit == 1 { psum } else { f0 })
} else if bit == 0 {
self.sw.store(32768, 32768 - f0, 2)
} else {
self.sw.store(32768 - f0, 0, 1)
}
}
}
///|
/// Set up the current block's position variables.
fn Av1Enc::begin_block(self : Av1Enc, r : Int32, c : Int32, bs : Int32) -> Unit {
self.mi_row = r
self.mi_col = c
self.bsize = bs
let bw4 = av1_bw4(bs)
let bh4 = av1_bh4(bs)
let ss = self.ss
self.has_chroma = if self.num_planes == 1 {
false
} else if bh4 == 1 && ss == 1 && (r & 1) == 0 {
false
} else if bw4 == 1 && ss == 1 && (c & 1) == 0 {
false
} else {
true
}
self.avail_u = self.inside(r - 1, c)
self.avail_l = self.inside(r, c - 1)
self.avail_uc = self.avail_u
self.avail_lc = self.avail_l
if self.has_chroma {
if ss == 1 && bh4 == 1 {
self.avail_uc = self.inside(r - 2, c)
}
if ss == 1 && bw4 == 1 {
self.avail_lc = self.inside(r, c - 2)
}
} else {
self.avail_uc = false
self.avail_lc = false
}
self.tx_size = av1_max_tx_size_rect[bs]
}
///|
/// Plane residual size of the current block.
fn Av1Enc::plane_size(self : Av1Enc, plane : Int32) -> Int32 {
let sub = if plane > 0 { self.ss } else { 0 }
av1_subsampled_size[self.bsize * 4 + sub * 2 + sub]
}
///|
fn Av1Enc::plane_tx_size(self : Av1Enc, plane : Int32) -> Int32 {
if plane == 0 {
return self.tx_size
}
let uv = av1_max_tx_size_rect[self.plane_size(plane)]
let w = 1 << av1_tx_width_log2[uv]
let h = 1 << av1_tx_height_log2[uv]
if w == 64 || h == 64 {
if w == 16 {
9 // TX_16X32
} else if h == 16 {
10 // TX_32X16
} else {
3 // TX_32X32
}
} else {
uv
}
}
///|
/// Encode the mode info and residual of the current block (set up by
/// begin_block) with the decisions in self.mode.
fn Av1Enc::code_block(self : Av1Enc) -> Unit {
let r = self.mi_row
let c = self.mi_col
let bs = self.bsize
let cols = self.mi_cols
let m = self.mode
let bw4 = av1_bw4(bs)
let bh4 = av1_bh4(bs)
// skip
let sctx = (if self.avail_u { self.mi_skip[(r - 1) * cols + c] } else { 0 }) +
(if self.avail_l { self.mi_skip[r * cols + c - 1] } else { 0 })
self.sym(self.cdf.skip + sctx * 3, 2, if m.skip { 1 } else { 0 })
// intra_frame_y_mode
let am = av1_intra_mode_context[if self.avail_u {
self.mi_ymode[(r - 1) * cols + c]
} else {
0
}]
let lm = av1_intra_mode_context[if self.avail_l {
self.mi_ymode[r * cols + c - 1]
} else {
0
}]
self.sym(self.cdf.kf_y + (am * 5 + lm) * 14, 13, m.ymode)
if bs >= av1_block_8x8 && m.ymode >= 1 && m.ymode <= 8 {
self.sym(self.cdf.angle + (m.ymode - 1) * 8, 7, m.angle_y + 3)
}
if self.has_chroma {
let bw = bw4 * 4
let bh = bh4 * 4
if (if bw > bh { bw } else { bh }) <= 32 {
self.sym(self.cdf.uv_cfl + m.ymode * 15, 14, m.uvmode)
} else {
self.sym(self.cdf.uv_no_cfl + m.ymode * 14, 13, m.uvmode)
}
if bs >= av1_block_8x8 && m.uvmode >= 1 && m.uvmode <= 8 {
self.sym(self.cdf.angle + (m.uvmode - 1) * 8, 7, m.angle_uv + 3)
}
}
if m.skip {
// reset_block_context
for plane in 0..<(if self.has_chroma { 3 } else { 1 }) {
let sub = if plane > 0 { self.ss } else { 0 }
for i = c >> sub; i < (c + bw4) >> sub; i = i + 1 {
self.above_level[plane][i] = 0
self.above_dc[plane][i] = 0
}
for i = r >> sub; i < (r + bh4) >> sub; i = i + 1 {
self.left_level[plane][i] = 0
self.left_dc[plane][i] = 0
}
}
}
for y in 0..> 2
let step_y = 1 << av1_tx_height_log2[tx] >> 2
let psz = self.plane_size(plane)
let n4w = av1_bw4(psz)
let n4h = av1_bh4(psz)
let sub = if plane > 0 { self.ss } else { 0 }
let base_x = (c >> sub) * 4
let base_y = (r >> sub) * 4
for y = 0; y < n4h; y = y + step_y {
for x = 0; x < n4w; x = x + step_x {
self.transform_block(plane, base_x, base_y, tx, x, y)
}
}
}
for y in 0.. Unit {
let start_x = base_x + 4 * x
let start_y = base_y + 4 * y
let sub = if plane > 0 { self.ss } else { 0 }
let row = start_y << sub >> 2
let col = start_x << sub >> 2
let sb_row = row & 15
let sb_col = col & 15
let log2w = av1_tx_width_log2[tx]
let log2h = av1_tx_height_log2[tx]
let step_x = 1 << log2w >> 2
let step_y = 1 << log2h >> 2
let max_x = (self.mi_cols * 4) >> sub
let max_y = (self.mi_rows * 4) >> sub
if start_x >= max_x || start_y >= max_y {
return
}
let m = self.mode
let mode = if plane == 0 { m.ymode } else { m.uvmode }
let angle = if plane == 0 { m.angle_y } else { m.angle_uv }
self.predict_tx(plane, start_x, start_y, tx, x, y, mode, angle)
// Transform type.
let tx_type = if plane == 0 {
if self.search_tx {
let t = if av1_tx_set(tx) == 0 || m.skip {
0
} else {
self.choose_tx_type(start_x, start_y, tx)
}
m.tx_types.push(t)
t
} else {
let t = if self.tx_index < m.tx_types.length() {
m.tx_types[self.tx_index]
} else {
0
}
self.tx_index += 1
if av1_tx_set(tx) == 0 {
0
} else {
t
}
}
} else {
let t = av1_mode_to_txfm[m.uvmode]
if av1_tx_set(tx) == 0 {
0
} else {
t
}
}
self.code_residual(plane, start_x, start_y, tx, tx_type)
for i in 0..> sub) + i,
(sb_col >> sub) + j,
)] = true
}
}
}
///|
/// Intra prediction of one transform block (spec transform_block
/// availability rules) into the reconstruction.
fn Av1Enc::predict_tx(
self : Av1Enc,
plane : Int32,
start_x : Int32,
start_y : Int32,
tx : Int32,
x : Int32,
y : Int32,
mode : Int32,
angle : Int32,
) -> Unit {
let sub = if plane > 0 { self.ss } else { 0 }
let row = start_y << sub >> 2
let col = start_x << sub >> 2
let sb_row = row & 15
let sb_col = col & 15
let log2w = av1_tx_width_log2[tx]
let log2h = av1_tx_height_log2[tx]
let step_x = 1 << log2w >> 2
let step_y = 1 << log2h >> 2
let max_x = (self.mi_cols * 4) >> sub
let max_y = (self.mi_rows * 4) >> sub
let have_left = (if plane == 0 { self.avail_l } else { self.avail_lc }) ||
x > 0
let have_above = (if plane == 0 { self.avail_u } else { self.avail_uc }) ||
y > 0
let have_ar = self.decoded[Av1Enc::dec_idx(
plane,
(sb_row >> sub) - 1,
(sb_col >> sub) + step_x,
)]
let have_bl = self.decoded[Av1Enc::dec_idx(
plane,
(sb_row >> sub) + step_y,
(sb_col >> sub) - 1,
)]
av1_predict_intra(
self.rec[plane],
self.stride[plane],
start_x,
start_y,
have_left,
have_above,
have_ar,
have_bl,
mode,
angle,
log2w,
log2h,
max_x - 1,
max_y - 1,
self.edges,
)
}
///|
/// Quantize, code and reconstruct the residual of a predicted transform
/// block.
fn Av1Enc::code_residual(
self : Av1Enc,
plane : Int32,
start_x : Int32,
start_y : Int32,
tx : Int32,
tx_type : Int32,
) -> Unit {
if !self.mode.skip {
// The transform type search leaves the chosen levels ready.
let eob = if self.ready_eob >= 0 {
let e = self.ready_eob
self.ready_eob = -1
e
} else {
self.quantize(plane, start_x, start_y, tx, tx_type)
}
if eob > 0 {
self.any_nonzero = true
}
self.coeffs(plane, start_x, start_y, tx, tx_type, eob)
if eob > 0 {
self.reconstruct(plane, start_x, start_y, tx, tx_type)
}
} else if plane == 0 {
self.set_tx_types(start_x >> 2, start_y >> 2, tx, 0)
}
}
///|
/// Sum of squared differences between source and reconstruction over the
/// visible part of a plane rectangle.
fn Av1Enc::sse(
self : Av1Enc,
plane : Int32,
x0 : Int32,
y0 : Int32,
w : Int32,
h : Int32,
) -> Int32 {
let sub = if plane > 0 { self.ss } else { 0 }
let pw = (self.width + sub) >> sub
let ph = (self.height + sub) >> sub
let x1 = if x0 + w < pw { x0 + w } else { pw }
let y1 = if y0 + h < ph { y0 + h } else { ph }
let st = self.stride[plane]
let src = self.src[plane]
let rec = self.rec[plane]
let mut s = 0
for y in y0.. Int32 {
let w = 1 << av1_tx_width_log2[tx]
let h = 1 << av1_tx_height_log2[tx]
let w4 = w >> 2
let h4 = h >> 2
let x4 = start_x >> 2
let y4 = start_y >> 2
let tw = if w > 32 { 32 } else { w }
let th = if h > 32 { 32 } else { h }
// Saved contexts and the best levels (scratch buffers).
let al = self.tx_ctx_save
for i in 0.. Double {
let w = 1 << av1_tx_width_log2[tx]
let h = 1 << av1_tx_height_log2[tx]
let tw = if w > 32 { 32 } else { w }
let th = if h > 32 { 32 } else { h }
let denom = av1_dq_denom(tx)
let mut s = 0.0
for i in 0.. Double {
let k = tx * 16 + tx_type
if av1_coef_gains[k] >= 0.0 {
return av1_coef_gains[k]
}
let w = 1 << av1_tx_width_log2[tx]
let h = 1 << av1_tx_height_log2[tx]
let res = FixedArray::make(w * h, 0)
let mut seed = 1U
let mut pe = 0.0
for i in 0..<(w * h) {
seed = seed * 1103515245U + 12345U
res[i] = ((seed >> 16) % 201U).reinterpret_as_int() - 100
pe = pe + (res[i] * res[i]).to_double()
}
let coef = FixedArray::make(w * h, 0.0)
// Measured outside any row cache (the cache holds the block's residual).
let cached = av1_row_cache.enabled
av1_row_cache.enabled = false
av1_forward_2d(res, tx, tx_type, coef)
av1_row_cache.enabled = cached
let mut ce = 0.0
for i in 0..<(w * h) {
ce = ce + coef[i] * coef[i]
}
let g = pe / ce
av1_coef_gains[k] = g
g
}
///|
/// Rate-distortion multiplier (per bit, in squared-error units).
fn av1_lambda(qidx : Int32) -> Double {
let q = av1_ac_qlookup[qidx].to_double() / 8.0
av1_lambda_scale * q * q
}
///|
let av1_lambda_scale : Double = 0.14
///|
fn Av1Enc::set_tx_types(
self : Av1Enc,
x4 : Int32,
y4 : Int32,
tx : Int32,
t : Int32,
) -> Unit {
let w4 = 1 << av1_tx_width_log2[tx] >> 2
let h4 = 1 << av1_tx_height_log2[tx] >> 2
for j in 0.. Int32 {
let w = 1 << av1_tx_width_log2[tx]
let h = 1 << av1_tx_height_log2[tx]
let stride = self.stride[plane]
let src = self.src[plane]
let rec = self.rec[plane]
for i in 0.. 32 { 32 } else { w }
let th = if h > 32 { 32 } else { h }
let denom = av1_dq_denom(tx).to_double()
let inv_dc = denom / self.dcq.to_double()
let inv_ac = denom / self.acq.to_double()
// |coefficient| * inv_ac below this quantizes to zero.
let zero_ac = 1.0 - av1_round_ac
let iscan = av1_iscan_for(tx)
let mut eob = 0
for i in 0.. 0xFFFF { 0xFFFF } else { l }
self.levels[pos] = if v < 0.0 { -l } else { l }
if l != 0 && iscan[pos] >= eob {
eob = iscan[pos] + 1
}
}
}
eob
}
///|
/// Rounding offset of the AC quantizer (0.5 is plain rounding).
let av1_round_ac : Double = 0.4
///|
/// Inverse scans (position -> scan index), per transform size.
let av1_iscans : FixedArray[FixedArray[Int32]] = FixedArray::makei(19, fn(tx) {
let scan = av1_scan_for(tx)
let inv = FixedArray::make(scan.length(), 0)
for c in 0.. FixedArray[Int32] {
av1_iscans[tx]
}
///|
fn av1_dq_denom(tx : Int32) -> Int32 {
match tx {
3 | 9 | 10 | 17 | 18 => 2
4 | 11 | 12 => 4
_ => 1
}
}
///|
/// Dequantize self.levels and add the inverse transform to the
/// reconstruction (the spec's reconstruct process).
fn Av1Enc::reconstruct(
self : Av1Enc,
plane : Int32,
x0 : Int32,
y0 : Int32,
tx : Int32,
tx_type : Int32,
) -> Unit {
let w = 1 << av1_tx_width_log2[tx]
let h = 1 << av1_tx_height_log2[tx]
let tw = if w > 32 { 32 } else { w }
let th = if h > 32 { 32 } else { h }
let denom = av1_dq_denom(tx)
for i in 0..| lim - 1 {
lim - 1
} else {
v
}
}
}
}
let mut rows = 0
for i in 0.. | Unit {
let x4 = start_x >> 2
let y4 = start_y >> 2
let log2w = av1_tx_width_log2[tx]
let log2h = av1_tx_height_log2[tx]
let w4 = 1 << log2w >> 2
let h4 = 1 << log2h >> 2
let tx_sz_ctx = (av1_tx_size_sqr[tx] + av1_tx_size_sqr_up[tx] + 1) >> 1
let ptype = if plane > 0 { 1 } else { 0 }
let sub = if plane > 0 { self.ss } else { 0 }
let max_x4 = self.mi_cols >> sub
let max_y4 = self.mi_rows >> sub
let cdf = self.cdf
// all_zero context.
let w = 1 << log2w
let h = 1 << log2h
let psz = self.plane_size(plane)
let bw = av1_bw4(psz) * 4
let bh = av1_bh4(psz) * 4
let az_ctx = if plane == 0 {
let mut top = 0
let mut left = 0
for k in 0.. top {
top = self.above_level[0][x4 + k]
}
}
for k in 0.. left {
left = self.left_level[0][y4 + k]
}
}
let mx = if top > left { top } else { left }
let mn = if top < left { top } else { left }
if bw == w && bh == h {
0
} else if top == 0 && left == 0 {
1
} else if top == 0 || left == 0 {
2 + (if mx > 3 { 1 } else { 0 })
} else if mx <= 3 {
4
} else if mn <= 3 {
5
} else {
6
}
} else {
let mut above = 0
let mut left = 0
for i in 0.. w * h {
base + 3
} else {
base
}
}
self.sym(
cdf.txb_skip + (tx_sz_ctx * 13 + az_ctx) * 3,
2,
if eob == 0 {
1
} else {
0
},
)
let mut cul_level = 0
let mut dc_category = 0
if eob == 0 {
if plane == 0 {
self.set_tx_types(x4, y4, tx, 0)
}
} else {
if plane == 0 {
// transform_type
if av1_tx_set(tx) > 0 && self.qidx > 0 {
let sqr = av1_tx_size_sqr[tx]
self.sym(
cdf.itx2 + (sqr * 13 + self.mode.ymode) * 6,
5,
av1_itx2_index(tx_type),
)
}
self.set_tx_types(x4, y4, tx, tx_type)
}
let scan = av1_scan_for(tx)
// eob_pt
let multisize = (if log2w < 5 { log2w } else { 5 }) +
(if log2h < 5 { log2h } else { 5 }) -
4
let eob_pt = if eob <= 2 { eob } else { av1_floor_log2(eob - 1) + 2 }
// Every transform type we use is in the 2-D class.
let ectx = 0
match multisize {
0 => self.sym(cdf.eob16 + (ptype * 2 + ectx) * 6, 5, eob_pt - 1)
1 => self.sym(cdf.eob32 + (ptype * 2 + ectx) * 7, 6, eob_pt - 1)
2 => self.sym(cdf.eob64 + (ptype * 2 + ectx) * 8, 7, eob_pt - 1)
3 => self.sym(cdf.eob128 + (ptype * 2 + ectx) * 9, 8, eob_pt - 1)
4 => self.sym(cdf.eob256 + (ptype * 2 + ectx) * 10, 9, eob_pt - 1)
5 => self.sym(cdf.eob512 + ptype * 11, 10, eob_pt - 1)
_ => self.sym(cdf.eob1024 + ptype * 12, 11, eob_pt - 1)
}
if eob_pt >= 3 {
let extra = eob - ((1 << (eob_pt - 2)) + 1)
let shift = eob_pt - 3
self.sym(
cdf.eob_extra + ((tx_sz_ctx * 2 + ptype) * 9 + eob_pt - 3) * 3,
2,
(extra >> shift) & 1,
)
for i = 1; i < eob_pt - 2; i = i + 1 {
let sh = eob_pt - 2 - 1 - i
self.literal((extra >> sh) & 1, 1)
}
}
// Base levels and ranges, in reverse scan order. `quant` holds the
// levels decoded so far (capped at 15) for the contexts.
let adj = av1_adjusted_tx_size[tx]
let bwl = av1_tx_width_log2[adj]
let width = 1 << bwl
let height = 1 << av1_tx_height_log2[adj]
let quant = self.quant_ctx
for i in 0..<(width * height) {
quant[i] = 0
}
for c = eob - 1; c >= 0; c = c - 1 {
let pos = scan[c]
let level = self.levels[pos].abs()
if c == eob - 1 {
let ctx = if c == 0 {
0
} else if c <= (height << bwl) / 8 {
1
} else if c <= (height << bwl) / 4 {
2
} else {
3
}
let b = if level > 3 { 3 } else { level }
self.sym(
cdf.base_eob + ((tx_sz_ctx * 2 + ptype) * 4 + ctx) * 4,
3,
b - 1,
)
} else {
let ctx = av1_coeff_base_ctx(quant, tx, bwl, width, height, pos)
let b = if level > 3 { 3 } else { level }
self.sym(cdf.base + ((tx_sz_ctx * 2 + ptype) * 42 + ctx) * 5, 4, b)
}
if level > 2 {
let ctx = av1_coeff_br_ctx(quant, bwl, width, height, pos)
let bsz = if tx_sz_ctx < 3 { tx_sz_ctx } else { 3 }
let off = cdf.br + ((bsz * 2 + ptype) * 21 + ctx) * 5
let mut rem = level - 3
for _ in 0..<4 {
let k = if rem > 3 { 3 } else { rem }
self.sym(off, 4, k)
rem -= k
if k < 3 {
break
}
}
}
quant[pos] = if level > 15 { 15 } else { level }
}
// Signs and Golomb remainders.
for c in 0.. 14 {
let x = level - 14
let len = av1_floor_log2(x) + 1
self.literal(0, len - 1)
self.literal(x, len)
}
if pos == 0 {
dc_category = if sign == 1 { 1 } else { 2 }
}
cul_level += level
}
}
if cul_level > 63 {
cul_level = 63
}
}
for i in 0.. Int32 {
let sub = if plane > 0 { self.ss } else { 0 }
let max_x4 = self.mi_cols >> sub
let max_y4 = self.mi_rows >> sub
let mut s = 0
for k in 0.. 0 {
2
} else {
0
}
}
///|
fn av1_floor_log2(x : Int32) -> Int32 {
let mut n = 0
while x >> (n + 1) != 0 {
n += 1
}
n
}
///|
/// get_coeff_base_ctx (2-D transform class, not the eob position).
fn av1_coeff_base_ctx(
quant : FixedArray[Int32],
tx : Int32,
bwl : Int32,
width : Int32,
height : Int32,
pos : Int32,
) -> Int32 {
let row = pos >> bwl
let col = pos - (row << bwl)
let mut mag = 0
for idx in 0..<5 {
let rr = row + av1_sig_ref_diff_offset[idx * 2]
let cc = col + av1_sig_ref_diff_offset[idx * 2 + 1]
if rr >= 0 && cc >= 0 && rr < height && cc < width {
let q = quant[(rr << bwl) + cc]
mag += if q > 3 { 3 } else { q }
}
}
let ctx = {
let v = (mag + 1) >> 1
if v > 4 {
4
} else {
v
}
}
if row == 0 && col == 0 {
return 0
}
let r4 = if row < 4 { row } else { 4 }
let c4 = if col < 4 { col } else { 4 }
ctx + av1_coeff_base_ctx_offset[tx * 25 + r4 * 5 + c4]
}
///|
/// coeff_br context (2-D transform class).
fn av1_coeff_br_ctx(
quant : FixedArray[Int32],
bwl : Int32,
width : Int32,
height : Int32,
pos : Int32,
) -> Int32 {
let row = pos >> bwl
let col = pos - (row << bwl)
let mut mag = 0
for idx in 0..<3 {
let rr = row + av1_mag_ref_offset[idx * 2]
let cc = col + av1_mag_ref_offset[idx * 2 + 1]
if rr >= 0 && cc >= 0 && rr < height && cc < width {
let q = quant[rr * width + cc]
mag += if q > 15 { 15 } else { q }
}
}
let m = {
let v = (mag + 1) >> 1
if v > 6 {
6
} else {
v
}
}
if pos == 0 {
m
} else if row < 2 && col < 2 {
m + 7
} else {
m + 14
}
}
| | |