use super::*;
use crate::cdf::CdfModeContext;
use crate::env::BlockContext;
use crate::intops::{iclip, imax, imin};
use crate::levels::{
Av2Block, BlockSize, InterPredMode, MotionMode, Mv, MvXY, RefPair, TIP_FRAME, TxPartition,
};
use crate::msac::MsacReader;
use crate::pixel::Pixel;
use crate::tables::{BLOCK_DIMENSIONS, TXFM_DIMENSIONS};
#[allow(clippy::too_many_arguments)]
fn prep_opfl_prefetch_rect_8bpc<BD: BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
p: &mut [BD::Pixel],
p_stride: usize,
ref_pic: &crate::picture::Picture,
bx4: i32,
by4: i32,
dimw: i32,
dimh: i32,
mvx: i32,
mvy: i32,
left: i32,
right: i32,
top: i32,
bottom: i32,
inter_scratch: &mut Vec<i16>,
) {
let ref_stride = ref_pic.stride[0].unsigned_abs() / std::mem::size_of::<BD::Pixel>();
let ref_data: &[BD::Pixel] = match ref_pic.ref_plane_slice::<BD::Pixel>(0) {
Some(s) => s,
None => return,
};
let mx = mvx & 7;
let my = mvy & 7;
let dx = bx4 * 4 + (mvx >> 3);
let dy = by4 * 4 + (mvy >> 3);
let need_emu = dx - (mx != 0) as i32 * 3 < left
|| dy - (my != 0) as i32 * 3 < top
|| dx + dimw + (mx != 0) as i32 * 4 > right
|| dy + dimh + (my != 0) as i32 * 4 > bottom;
let dwu = dimw as usize;
let dhu = dimh as usize;
let mut emu_buf = if need_emu {
Some(vec![BD::Pixel::default(); 192 * 192])
} else {
None
};
let (src, src_off, src_stride) = if let Some(ref mut buf) = emu_buf {
let emu_w = dwu + (mx != 0) as usize * 7;
let emu_h = dhu + (my != 0) as usize * 7;
let emu_stride = 192usize;
let src_base = ((left + top * ref_stride as i32).max(0) as usize).min(ref_data.len());
inter_emu_edge_8bpc::<BD>(
buf,
emu_stride,
&ref_data[src_base..],
ref_stride,
emu_w,
emu_h,
(right - left).max(0) as usize,
(bottom - top).max(0) as usize,
dx - (mx != 0) as i32 * 3 - left,
dy - (my != 0) as i32 * 3 - top,
);
let off = emu_stride * (my != 0) as usize * 3 + (mx != 0) as usize * 3;
(&buf[..], off, emu_stride)
} else {
let off = dy as usize * ref_stride + dx as usize;
(ref_data, off, ref_stride)
};
if BD::BPC == 8 {
let p8: &mut [u8] = BD::Pixel::slice_as_ne_bytes_mut(p);
let src8: &[u8] = BD::Pixel::slice_as_ne_bytes(src);
exec.put_bilin_8bpc_with_scratch(
p8,
p_stride,
&src8[src_off..],
src_stride,
dwu,
dhu,
mx << 1,
my << 1,
inter_scratch,
);
} else {
crate::mc::put_bilin(
bd,
p,
p_stride,
&src[src_off..],
src_stride,
dwu,
dhu,
mx << 1,
my << 1,
);
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn opfl_pred_luma<BD: BitDepth>(
recon: &mut ReconCtx<BD>,
tmp: &mut [Vec<i16>; 2],
seg_mask: &mut [u8],
b: &Av2Block,
bx: i32,
by: i32,
bw4: i32,
bh4: i32,
w4: i32,
h4: i32,
fi: &SbFrameInfo,
) -> bool {
let layout = recon.frame.layout;
let refs = b.ref_pair.refs();
let r0 = refs[0] as usize;
let r1 = refs[1] as usize;
let filter = b.inter_data().filter;
let cwp_idx = b.inter_data().cwp_idx as i32;
let inter_mode = b.inter_data().inter_mode;
let comp_type = b.inter_data().comp_type;
let refine_mv = b.inter_data().refine_mv;
let b_mv = [b.inter_data().mv[0].xy(), b.inter_data().mv[1].xy()];
let r_pair = b.ref_pair;
let refine = comp_type == 1 && refine_mv != 0;
let opfl = inter_mode >= crate::levels::CompInterPredMode::OpflNearMvNearMv as u8;
let refp0 = match recon.refp[r0].clone() {
Some(p) => p,
None => return false,
};
let refp1 = match recon.refp[r1].clone() {
Some(p) => p,
None => return false,
};
let refp = [&refp0, &refp1];
let w = fi.bw * 4;
let h = fi.bh * 4;
let bacp = recon.seq_hdr.imp_msk_bld && cwp_idx == 8;
if bacp {
for m in seg_mask.iter_mut() {
*m = 0x20;
}
}
let mut have_bacp = false;
let d0 = fi.absrefdist[r0] as i32;
let d1 = fi.absrefdist[r1] as i32;
let dw0 = apply_sign_i8(1 + (d0 > d1) as i32, -(fi.refdist[r0] as i32));
let dw1 = apply_sign_i8(1 + (d1 > d0) as i32, fi.refdist[r1] as i32);
let dweights = [dw0, dw1];
let bs = 2 - (b.bs == BlockSize::Bs8x8 as u8 as i8) as i32;
let t_swap = (recon.rf.ref_flip & (1u64 << (r0 * 8 + r1))) != 0;
let yw = (bw4 * 4) as usize;
let p_stride = (((bw4 + refine as i32 * 2) * 4) as usize + 63) & !63;
let psz = p_stride * (((bw4 + refine as i32 * 2) * 4) as usize + 8);
let bd = recon.bd;
let mut p = [
vec![BD::Pixel::default(); psz.max(p_stride * 8)],
vec![BD::Pixel::default(); psz.max(p_stride * 8)],
];
let sh4 = imin(4, bh4);
let sw4 = imin(4, bw4);
let mut top = [by * 4 + (b_mv[0].y >> 3) - 3, by * 4 + (b_mv[1].y >> 3) - 3];
let mut y = 0i32;
while y < h4 {
let mut left = [bx * 4 + (b_mv[0].x >> 3) - 3, bx * 4 + (b_mv[1].x >> 3) - 3];
if refine {
let mut x = 0i32;
while x < w4 {
for n in 0..2 {
prep_opfl_prefetch_rect_8bpc(
bd,
recon.frame.exec,
&mut p[n],
p_stride,
refp[n],
bx + x,
by + y,
(sw4 + 2) * 4,
(sh4 + 2) * 4,
b_mv[n].x - 32,
b_mv[n].y - 32,
iclip(left[n], 0, w - 1),
iclip(left[n] + 4 * sw4 + 7, 1, w),
iclip(top[n], 0, h - 1),
iclip(top[n] + 4 * sh4 + 7, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
let (dx, dy) = crate::mc::sad_refine_mv::<BD::Pixel>(
&p[0],
p_stride,
&p[1],
p_stride,
(sw4 * 4) as usize,
(sh4 * 4) as usize,
refine_mv == 2,
bd.bitdepth_min_8(),
);
if opfl {
let mut res = [crate::mc::OpflRegressionData::default(); 4];
let o0 = ((4 + dy) * p_stride as i32 + (4 + dx)) as usize;
let o1 = ((4 - dy) * p_stride as i32 + (4 - dx)) as usize;
crate::mc::opfl_derive_mv(
bd,
&mut res,
&p[0][o0..],
p_stride,
&p[1][o1..],
p_stride,
(sw4 * 4) as usize,
(sh4 * 4) as usize,
(bs * 4) as usize,
dweights,
);
let mut ri = 0usize;
let mut byi = 0i32;
while byi < sh4 {
let mut bxi = 0i32;
while bxi < sw4 {
let mut dd = crate::recon::OpflMvDeltaBlock::default();
crate::recon::opfl_mv_adj(&res[ri], &mut dd, dweights);
ri += 1;
let rmv_idx = (((by + y) & 31) >> 1) as usize * 16
+ (byi != 0) as usize * 16
+ (((bx + x + bxi) & 31) >> 1) as usize;
let mut mv = [Mv::default(); 2];
mv[0] = Mv {
c: MvXY {
y: b_mv[0].y * 2 + dd.d[0].y as i32 + dy * 16,
x: b_mv[0].x * 2 + dd.d[0].x as i32 + dx * 16,
},
};
mv[1] = Mv {
c: MvXY {
y: b_mv[1].y * 2 + dd.d[1].y as i32 - dy * 16,
x: b_mv[1].x * 2 + dd.d[1].x as i32 - dx * 16,
},
};
for i in 0..2 {
let off = ((y + byi) * 4) as usize * yw + ((x + bxi) * 4) as usize;
mc_opfl_8bpc(
bd,
recon.frame.exec,
&mut tmp[i],
off,
yw,
bs,
bs,
bx + x + bxi,
by + y + byi,
0,
mv[i].x(),
mv[i].y(),
refp[i],
filter,
iclip(left[i], 0, w - 1),
iclip(left[i] + sw4 * 4 + 7, 1, w),
iclip(top[i], 0, h - 1),
iclip(top[i] + sh4 * 4 + 7, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
let dmv = [
Mv {
c: MvXY {
y: (mv[0].y() + (dd.d[0].y > 0) as i32) >> 1,
x: (mv[0].x() + (dd.d[0].x > 0) as i32) >> 1,
},
},
Mv {
c: MvXY {
y: (mv[1].y() + (dd.d[1].y > 0) as i32) >> 1,
x: (mv[1].x() + (dd.d[1].x > 0) as i32) >> 1,
},
},
];
update_temporal_grid(
recon,
by + y + byi,
bx + x + bxi,
1,
1,
r_pair,
&dmv,
t_swap,
);
if bacp {
have_bacp |= crate::recon::get_mask(
seg_mask,
yw,
bx,
x + bxi,
by,
y + byi,
&mv,
4,
4,
2,
2,
w,
h,
);
}
crate::recon::scaledown_16pel_mv_for_chroma(&mut mv, layout);
recon.scratch.rmv[rmv_idx][0] = mv;
bxi += 2;
}
byi += 2;
}
} else {
let rmv_idx =
(((by + y) & 31) >> 1) as usize * 16 + (((bx + x) & 31) >> 1) as usize;
let mut mv = [Mv::default(); 2];
mv[0] = Mv {
c: MvXY {
y: b_mv[0].y + dy * 8,
x: b_mv[0].x + dx * 8,
},
};
mv[1] = Mv {
c: MvXY {
y: b_mv[1].y - dy * 8,
x: b_mv[1].x - dx * 8,
},
};
for i in 0..2 {
let off = (y * 4) as usize * yw + (x * 4) as usize;
mc_prep_bounds_8bpc(
bd,
recon.frame.exec,
&mut tmp[i][off..],
yw,
refp[i],
0,
bx + x,
by + y,
sw4,
sh4,
mv[i].x(),
mv[i].y(),
filter,
recon.frame.ss_hor,
recon.frame.ss_ver,
iclip(left[i], 0, w - 1),
iclip(left[i] + sw4 * 4 + 7, 1, w),
iclip(top[i], 0, h - 1),
iclip(top[i] + sh4 * 4 + 7, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
update_temporal_grid(
recon,
by + y,
bx + x,
(sw4 >> 1) as usize,
(sh4 >> 1) as usize,
r_pair,
&mv,
t_swap,
);
crate::recon::scaleup_8pel_mv_for_chroma(&mut mv, layout);
if bacp {
have_bacp |= crate::recon::get_mask(
seg_mask, yw, bx, x, by, y, &mv, 3, 3, sw4, sh4, w, h,
);
}
recon.scratch.rmv[rmv_idx][0] = mv;
}
for n in 0..2 {
left[n] += 16;
}
x += sw4;
}
} else {
debug_assert!(opfl);
for n in 0..2 {
prep_opfl_prefetch_rect_8bpc(
bd,
recon.frame.exec,
&mut p[n],
p_stride,
refp[n],
bx,
by + y,
bw4 * 4,
sh4 * 4,
b_mv[n].x,
b_mv[n].y,
0,
w,
0,
h,
recon.scratch.inter_mc_tmp_mut(),
);
}
let nres = ((sh4 / bs) * (bw4 / bs)) as usize;
let mut res = vec![crate::mc::OpflRegressionData::default(); nres.max(1)];
crate::mc::opfl_derive_mv(
bd,
&mut res,
&p[0],
p_stride,
&p[1],
p_stride,
(bw4 * 4) as usize,
(sh4 * 4) as usize,
(bs * 4) as usize,
dweights,
);
let mut dd_acc = [crate::recon::OpflMvDeltaBlock::default(); 4];
let mut dd_acc_n = 0usize;
let cols = (bw4 / bs) as usize;
let mut byi = 0i32;
let mut row = 0usize;
while byi < sh4 {
let mut bxi = 0i32;
let mut xx = 0usize;
while bxi < bw4 {
let ri = row * cols + xx;
let mut dd = crate::recon::OpflMvDeltaBlock::default();
crate::recon::opfl_mv_adj(&res[ri], &mut dd, dweights);
let store_rmv = !(bs == 1 && (bxi != 0 || byi != 0));
let rmv_idx = (((by + y) & 31) >> 1) as usize * 16
+ (byi != 0) as usize * 16
+ (((bx + bxi) & 31) >> 1) as usize;
let mut mv = [Mv::default(); 2];
mv[0] = Mv {
c: MvXY {
y: b_mv[0].y * 2 + dd.d[0].y as i32,
x: b_mv[0].x * 2 + dd.d[0].x as i32,
},
};
mv[1] = Mv {
c: MvXY {
y: b_mv[1].y * 2 + dd.d[1].y as i32,
x: b_mv[1].x * 2 + dd.d[1].x as i32,
},
};
for i in 0..2 {
let off = ((y + byi) * 4) as usize * yw + (bxi * 4) as usize;
mc_opfl_8bpc(
bd,
recon.frame.exec,
&mut tmp[i],
off,
yw,
bs,
bs,
bx + bxi,
by + y + byi,
0,
mv[i].x(),
mv[i].y(),
refp[i],
filter,
iclip(left[i] + bxi * 4, 0, w - 1),
iclip(left[i] + bxi * 4 + 7 + 8, 1, w),
iclip(top[i] + byi * 4, 0, h - 1),
iclip(top[i] + byi * 4 + 7 + 8, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
if bs > 1 {
let dmv = [
Mv {
c: MvXY {
y: (mv[0].y() + (dd.d[0].y > 0) as i32) >> 1,
x: (mv[0].x() + (dd.d[0].x > 0) as i32) >> 1,
},
},
Mv {
c: MvXY {
y: (mv[1].y() + (dd.d[1].y > 0) as i32) >> 1,
x: (mv[1].x() + (dd.d[1].x > 0) as i32) >> 1,
},
},
];
update_temporal_grid(
recon,
by + y + byi,
bx + bxi,
(bs >> 1) as usize,
(bs >> 1) as usize,
r_pair,
&dmv,
t_swap,
);
} else {
if dd_acc_n < 4 {
dd_acc[dd_acc_n] = dd;
dd_acc_n += 1;
}
}
if bacp {
have_bacp |= crate::recon::get_mask(
seg_mask,
yw,
bx,
bxi,
by,
y + byi,
&mv,
4,
4,
bs,
bs,
w,
h,
);
}
crate::recon::scaledown_16pel_mv_for_chroma(&mut mv, layout);
if store_rmv {
recon.scratch.rmv[rmv_idx][0] = mv;
}
bxi += bs;
xx += 1;
}
byi += bs;
row += 1;
}
if bs == 1 {
let s0x = dd_acc[0].d[0].x as i32
+ dd_acc[1].d[0].x as i32
+ dd_acc[2].d[0].x as i32
+ dd_acc[3].d[0].x as i32;
let s0y = dd_acc[0].d[0].y as i32
+ dd_acc[1].d[0].y as i32
+ dd_acc[2].d[0].y as i32
+ dd_acc[3].d[0].y as i32;
let s1x = dd_acc[0].d[1].x as i32
+ dd_acc[1].d[1].x as i32
+ dd_acc[2].d[1].x as i32
+ dd_acc[3].d[1].x as i32;
let s1y = dd_acc[0].d[1].y as i32
+ dd_acc[1].d[1].y as i32
+ dd_acc[2].d[1].y as i32
+ dd_acc[3].d[1].y as i32;
let dmv = [
Mv {
c: MvXY {
y: (b_mv[0].y * 8 + s0y + 3 + (s0y > 0) as i32) >> 3,
x: (b_mv[0].x * 8 + s0x + 3 + (s0x > 0) as i32) >> 3,
},
},
Mv {
c: MvXY {
y: (b_mv[1].y * 8 + s1y + 3 + (s1y > 0) as i32) >> 3,
x: (b_mv[1].x * 8 + s1x + 3 + (s1x > 0) as i32) >> 3,
},
},
];
update_temporal_grid(recon, by + y, bx, 1, 1, r_pair, &dmv, t_swap);
}
}
for n in 0..2 {
top[n] += 4 * sh4;
}
y += sh4;
}
bacp && have_bacp
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn tip_frame_recon_sb<
BD: crate::pixel::BitDepth,
const UPDATE_CDF: bool,
M: MsacReader<UPDATE_CDF>,
>(
recon: &mut ReconCtx<BD>,
msac: &mut M,
cdf_m: &mut CdfModeContext,
a: &mut BlockContext,
l: &mut BlockContext,
bx: i32,
by: i32,
bs: BlockSize,
cbs: BlockSize,
fi: &SbFrameInfo,
) -> Result<(), ()>
where
BD::Coef: DecodeCoeff,
{
static TIP_WTS: [i8; 8] = [8, 12, 16, 18, 20, 4, 6, -4];
let tip = &recon.frm_hdr.tip;
let mut b = crate::levels::Av2Block {
bs: bs as i8,
cbs: cbs as i8,
is_intra: 0,
intrabc: 0,
seg_id: 0,
skip_mode: 0,
skip_txfm: 1,
tx_part: TxPartition::None as u8,
fsc: 0,
tx_size_ll: 0,
ref_pair: RefPair {
r: [TIP_FRAME as i8, -1],
},
data: crate::levels::Av2BlockData::default(),
};
{
let inter = b.inter_data_mut();
inter.mv[0] = Mv::from_xy(tip.gmv_y as i32, tip.gmv_x as i32);
inter.inter_mode = InterPredMode::NearMv as u8;
inter.motion_mode = MotionMode::Translation as u8;
inter.filter = tip.subpel_filter;
inter.cwp_idx = TIP_WTS[tip.global_wtd_idx as usize];
}
let has_luma = true;
let has_chroma = cbs != BlockSize::Invalid;
if recon.frm_hdr.tip.apply_filter != 0 {
let layout = recon.frame.layout;
let ss_hor = recon.frame.ss_hor;
let ss_ver = recon.frame.ss_ver;
let bx4 = (bx & 63) as usize;
let by4 = (by & 63) as usize;
{
let m = &mut recon.lf_mask[recon.lf_idx];
crate::lf_mask::create_db_mask(
&mut m.filter_y,
&b,
bs,
bx,
by,
fi.bw,
fi.bh,
layout,
false,
&mut a.tx_lpf_y[bx4..],
&mut l.tx_lpf_y[by4..],
recon.frm_hdr,
recon.seq_hdr,
);
}
if has_chroma {
let m = &mut recon.lf_mask[recon.lf_idx];
crate::lf_mask::create_db_mask(
&mut m.filter_uv,
&b,
cbs,
bx,
by,
fi.bw,
fi.bh,
layout,
true,
&mut a.tx_lpf_uv[bx4 >> ss_hor..],
&mut l.tx_lpf_uv[by4 >> ss_ver..],
recon.frm_hdr,
recon.seq_hdr,
);
}
let qidx = recon.frm_hdr.quant.yac as u16;
let qbase = (bx4 >> 4) + ((by4 & 0x30) >> 2);
let sbsz64 = (fi.sb_step >> 4) as usize;
let m = &mut recon.lf_mask[recon.lf_idx];
let mut qoff = qbase;
for _ in 0..sbsz64 {
for x64 in 0..sbsz64 {
m.qidx[qoff + x64] = qidx;
}
qoff += 4;
}
}
recon_b_inter_tip(
recon,
msac,
cdf_m,
a,
l,
&b,
bx,
by,
bx,
by,
bs,
cbs,
has_luma,
has_chroma,
ChromaPhase::Both,
fi,
)
}
#[allow(clippy::too_many_arguments)]
fn recon_b_inter_tip<
BD: crate::pixel::BitDepth,
const UPDATE_CDF: bool,
M: MsacReader<UPDATE_CDF>,
>(
recon: &mut ReconCtx<BD>,
msac: &mut M,
cdf_m: &mut CdfModeContext,
a: &mut BlockContext,
l: &mut BlockContext,
b: &Av2Block,
bx: i32,
by: i32,
cbx: i32,
cby: i32,
lbs: BlockSize,
cbs: BlockSize,
has_luma: bool,
has_chroma: bool,
chroma_stage: ChromaPhase,
fi: &SbFrameInfo,
) -> Result<(), ()>
where
BD::Coef: DecodeCoeff,
{
let bd = recon.bd;
let ss_hor = recon.frame.ss_hor;
let ss_ver = recon.frame.ss_ver;
let layout = recon.frame.layout;
let filter = b.inter_data().filter;
let cwp_idx = b.inter_data().cwp_idx as i32;
let bs = if lbs == BlockSize::Invalid { cbs } else { lbs };
let b_mv0 = b.inter_data().mv[0].xy();
let tip_refs = fi.tip.refs();
let r0 = tip_refs[0] as usize;
let r1 = tip_refs[1] as usize;
let frame_mode = recon.frm_hdr.tip.frame_mode as i32;
let tip_subpel = recon.frm_hdr.tip.subpel_filter;
let mut opfl = recon.seq_hdr.tip_refine_mv
&& (frame_mode == 1 || tip_subpel == crate::headers::FilterMode::Sharp8Tap as u8);
let refine =
opfl && recon.seq_hdr.refine_mv && frame_mode == 1 && fi.refdist[r0] == -fi.refdist[r1];
let bw4_full = BLOCK_DIMENSIONS[bs as u8 as usize][0] as i32;
let bh4_full = BLOCK_DIMENSIONS[bs as u8 as usize][1] as i32;
let is_256 = bs == BlockSize::Bs256x256;
let step_shift = if frame_mode == 2 {
(!opfl) as i32
} else {
((!opfl && imin(bw4_full, bh4_full) >= 4) || is_256) as i32
};
let step = 2i32 << step_shift;
let refined_tmvp = recon.frm_hdr.has_bothside_refs != 0
&& (recon.frm_hdr.opfl_refine_type != 0 || recon.seq_hdr.refine_mv)
&& recon.seq_hdr.tip_refine_mv
&& cwp_idx == 8
&& if frame_mode == 2 {
tip_subpel == crate::headers::FilterMode::Sharp8Tap as u8 && recon.seq_hdr.opfl_refine
} else {
!is_256 || recon.seq_hdr.refine_mv
};
let do_opfl = recon.seq_hdr.opfl_refine && recon.frm_hdr.opfl_refine_type != 0;
opfl &= recon.frm_hdr.has_bothside_refs != 0 && cwp_idx == 8 && (do_opfl || refine);
let single = cwp_idx == 16;
let bacp = recon.seq_hdr.imp_msk_bld
&& cwp_idx == 8
&& recon.svc[r0][0].scale == 0
&& recon.svc[r1][0].scale == 0;
let d0 = fi.absrefdist[r0] as i32;
let d1 = fi.absrefdist[r1] as i32;
let dw0 = apply_sign_i8(1 + (d0 > d1) as i32, -(fi.refdist[r0] as i32));
let dw1 = apply_sign_i8(1 + (d1 > d0) as i32, fi.refdist[r1] as i32);
let dweights = [dw0, dw1];
let sad8x8_thr: u32 = if frame_mode == 1 { 6 } else { 15 };
let t_stride = recon.rf.rp_stride;
let t_swap = (recon.rf.ref_flip & (1u64 << (r0 * 8 + r1))) != 0;
let r_pair = fi.tip;
let w = fi.bw * 4;
let h = fi.bh * 4;
let refp0 = recon.refp[r0].clone();
let refp1 = recon.refp[r1].clone();
let (refp0, refp1) = match (refp0, refp1) {
(Some(a), Some(b)) => (a, b),
_ => return Ok(()),
};
let refp = [&refp0, &refp1];
let rp_proj_off = recon.rt.rp_proj_off;
let mut seg_mask = recon.scratch.take_compound_seg_mask();
let mut luma_bacp = false;
if has_luma {
let bw4 = bw4_full;
let bh4 = bh4_full;
let w4 = imin(bw4, fi.bw - bx);
let h4 = imin(bh4, fi.bh - by);
let yw = (bw4 * 4) as usize;
let yh = (bh4 * 4) as usize;
let y_stride = recon.frame.y_stride_px;
let dst_off = 4 * (by as usize * y_stride + bx as usize);
let _len = crate::mc_dispatch::compound_tmp_len(yw, yh);
let mut tmp = recon.scratch.take_compound_tmp(_len);
if bacp {
for m in seg_mask.iter_mut() {
*m = 0x20;
}
}
let p_stride = ((step as usize + 2) * 4 + 15) & !15; let p_stride = if p_stride < (step as usize + 2) * 4 {
(step as usize + 2) * 4
} else {
p_stride
};
let psz = p_stride * ((step as usize + 2) * 4);
let mut p = [
vec![BD::Pixel::default(); psz],
vec![BD::Pixel::default(); psz],
];
let mut y = 0i32;
let mut yy = 0i32;
while y < h4 {
let off_y8 = (((by + y) & (fi.sb_step - 1)) >> 1) as isize * t_stride;
let mut x = 0i32;
while x < w4 {
let off_8x8 = (off_y8 + ((bx + x) >> 1) as isize) as usize;
let mut tmv = recon.rf.rp_proj[rp_proj_off + off_8x8].mv;
if tmv.y() == crate::levels::INVALID_MV {
tmv = Mv::from_bits(0);
}
let rmv_idx =
(((by + y) & 31) >> 1) as usize * 16 + (((bx + x) & 31) >> 1) as usize;
let mut cmv = [Mv::default(); 2];
let mut rmv1 = [Mv::default(); 2];
let mut left = [0i32; 2];
let mut top = [0i32; 2];
for i in 0..2 {
let tipmv = crate::refmvs::scale_mv(tmv, recon.rf.tip.sf[i]);
let cy = iclip(tipmv.y() + b_mv0.y, -0xffff, 0xffff);
let cx = iclip(tipmv.x() + b_mv0.x, -0xffff, 0xffff);
cmv[i] = Mv {
c: MvXY { y: cy, x: cx },
};
rmv1[i] = Mv {
c: MvXY { y: cy, x: cx },
};
top[i] = by * 4 + y * 4 + (cy >> 3) - 3;
left[i] = bx * 4 + x * 4 + (cx >> 3) - 3;
}
crate::recon::scaleup_8pel_mv_for_chroma(&mut rmv1, layout);
if opfl {
for i in 0..2 {
let cy = cmv[i].y();
let cx = cmv[i].x();
prep_opfl_prefetch_8bpc(
bd,
recon.frame.exec,
&mut p[i],
p_stride,
refp[i],
bx + x,
by + y,
step,
cx - 32,
cy - 32,
iclip(left[i], 0, w - 1),
iclip(left[i] + 7 + step * 4, 1, w),
iclip(top[i], 0, h - 1),
iclip(top[i] + 7 + step * 4, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
let (mut dy, mut dx) = (0i32, 0i32);
if refine {
let (rdx, rdy) = crate::mc::sad_refine_mv::<BD::Pixel>(
&p[0],
p_stride,
&p[1],
p_stride,
(step * 4) as usize,
(step * 4) as usize,
true,
bd.bitdepth_min_8(),
);
dy = rdy;
dx = rdx;
cmv[0].set_y(cmv[0].y() + 8 * dy);
cmv[1].set_y(cmv[1].y() - 8 * dy);
cmv[0].set_x(cmv[0].x() + 8 * dx);
cmv[1].set_x(cmv[1].x() - 8 * dx);
}
let mut dd = crate::recon::OpflMvDeltaBlock::default();
let sad = if is_256 && frame_mode == 1 {
0
} else {
let o0 = ((4 + dy) * p_stride as i32 + (4 + dx)) as usize;
let o1 = ((4 - dy) * p_stride as i32 + (4 - dx)) as usize;
crate::mc::sad8x8::<BD::Pixel>(
&p[0][o0..],
p_stride,
&p[1][o1..],
p_stride,
bd.bitdepth_min_8(),
)
};
if do_opfl && sad >= sad8x8_thr {
let mut res = [crate::mc::OpflRegressionData::default(); 4];
let o0 = ((4 + dy) * p_stride as i32 + (4 + dx)) as usize;
let o1 = ((4 - dy) * p_stride as i32 + (4 - dx)) as usize;
crate::mc::opfl_derive_mv(
bd,
&mut res,
&p[0][o0..],
p_stride,
&p[1][o1..],
p_stride,
(step * 4) as usize,
(step * 4) as usize,
8,
dweights,
);
crate::recon::opfl_mv_adj(&res[0], &mut dd, dweights);
}
for i in 0..2 {
cmv[i].set_x(cmv[i].x() * 2 + dd.d[i].x as i32);
cmv[i].set_y(cmv[i].y() * 2 + dd.d[i].y as i32);
}
for i in 0..2 {
let cy = cmv[i].y();
let cx = cmv[i].x();
let off = (y * 4) as usize * yw + (x * 4) as usize;
mc_opfl_8bpc(
bd,
recon.frame.exec,
&mut tmp[i],
off,
yw,
step,
step,
bx + x,
by + y,
0,
cx,
cy,
refp[i],
filter,
iclip(left[i], 0, w - 1),
iclip(left[i] + 7 + step * 4, 1, w),
iclip(top[i], 0, h - 1),
iclip(top[i] + 7 + step * 4, 1, h),
recon.scratch.inter_mc_tmp_mut(),
);
}
let dmv = [
Mv {
c: MvXY {
y: (cmv[0].y() + (dd.d[0].y > 0) as i32) >> 1,
x: (cmv[0].x() + (dd.d[0].x > 0) as i32) >> 1,
},
},
Mv {
c: MvXY {
y: (cmv[1].y() + (dd.d[1].y > 0) as i32) >> 1,
x: (cmv[1].x() + (dd.d[1].x > 0) as i32) >> 1,
},
},
];
update_temporal_grid(
recon,
by + y,
bx + x,
(step >> 1) as usize,
(step >> 1) as usize,
r_pair,
&dmv,
t_swap,
);
if bacp {
luma_bacp |= crate::recon::get_mask(
&mut seg_mask,
(bw4 * 4) as usize,
bx,
x,
by,
y,
&cmv,
4,
4,
step,
step,
w,
h,
);
}
crate::recon::scaledown_16pel_mv_for_chroma(&mut cmv, layout);
} else {
for i in 0..2 - single as usize {
let cy = cmv[i].y();
let cx = cmv[i].x();
if single {
let off = dst_off + (y * 4) as usize * y_stride + (x * 4) as usize;
inter_mc_plane_8bpc(
bd,
recon.frame.exec,
&mut recon.dst_y[off..],
y_stride,
refp[0],
0,
bx + x,
by + y,
step,
step,
cx,
cy,
filter,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
continue;
}
let off = (y * 4) as usize * yw + (x * 4) as usize;
inter_mc_plane_prep_at_8bpc(
bd,
recon.frame.exec,
&mut tmp[i],
off,
yw,
refp[i],
0,
bx + x,
by + y,
step,
step,
cx,
cy,
filter,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
let mut tmvp_mv = cmv;
if single {
tmvp_mv[1] = Mv::from_xy(4096, 4096);
}
update_temporal_grid(
recon,
by + y,
bx + x,
(step >> 1) as usize,
(step >> 1) as usize,
r_pair,
&tmvp_mv,
t_swap,
);
if step == 4 && frame_mode == 1 && refined_tmvp {
for p in 1..4i32 {
let mut tmv2 = recon.rf.rp_proj[rp_proj_off
+ off_8x8
+ (p & 1) as usize
+ (((p & 2) >> 1) as isize * t_stride) as usize]
.mv;
if tmv2.y() == crate::levels::INVALID_MV {
tmv2 = Mv::from_bits(0);
}
let mut dmv = [Mv::default(); 2];
for i in 0..2 {
let tipmv = crate::refmvs::scale_mv(tmv2, recon.rf.tip.sf[i]);
dmv[i] = Mv {
c: MvXY {
y: iclip(tipmv.y() + b_mv0.y, -0xffff, 0xffff),
x: iclip(tipmv.x() + b_mv0.x, -0xffff, 0xffff),
},
};
}
update_temporal_grid_sub(
recon,
by + y,
bx + x,
p,
t_stride,
r_pair,
&dmv,
t_swap,
);
}
}
if bacp {
luma_bacp |= crate::recon::get_mask(
&mut seg_mask,
(bw4 * 4) as usize,
bx,
x,
by,
y,
&cmv,
3,
3,
step,
step,
w,
h,
);
}
crate::recon::scaleup_8pel_mv_for_chroma(&mut cmv, layout);
}
recon.scratch.rmv[rmv_idx][0] = cmv;
recon.scratch.rmv[rmv_idx][1] = rmv1;
x += step;
}
y += step;
yy += 1;
}
let _ = yy;
let have_bacp = bacp && luma_bacp;
let (tmp0, tmp1) = tmp.split_at(1);
if single {
} else if have_bacp {
mc_mask(
recon.frame.exec,
bd,
&mut recon.dst_y[dst_off..],
y_stride,
&tmp0[0],
&tmp1[0],
yw,
yh,
&seg_mask,
);
} else if cwp_idx == 8 {
mc_avg(
recon.frame.exec,
bd,
&mut recon.dst_y[dst_off..],
y_stride,
&tmp0[0],
&tmp1[0],
yw,
yh,
);
} else {
crate::decode::recon_intra::mc_w_avg(
recon.frame.exec,
bd,
&mut recon.dst_y[dst_off..],
y_stride,
&tmp0[0],
&tmp1[0],
yw,
yh,
cwp_idx,
);
}
recon.scratch.put_compound_tmp(tmp);
let seg_id = b.seg_id as usize;
let lossless = recon.frame.seg_lossless[seg_id] != 0;
if lossless {
let tx = if b.tx_size_ll != 0 {
crate::tables::MAX_TXFM_SIZE_FOR_BS[bs as usize][3] as usize
} else {
0
};
let t_dim = &TXFM_DIMENSIONS[tx];
let (tw4, th4) = (t_dim.w as i32, t_dim.h as i32);
let mut yr = 0;
while yr < h4 {
let mut xr = 0;
while xr < w4 {
inter_residual_tx_8bpc(
recon,
msac,
cdf_m,
a,
l,
b,
0,
tx,
bx + xr,
by + yr,
false,
0,
fi,
)?;
xr += tw4;
}
yr += th4;
}
} else {
let tp = &crate::tables::TX_PART_TBL[bs as usize];
let tx = tp[b.tx_part as usize] as usize;
inter_luma_tx_walk(recon, msac, cdf_m, a, l, b, tx, bx, by, fi)?;
}
}
if has_chroma && cbs != BlockSize::Invalid {
let cb_dim = &BLOCK_DIMENSIONS[cbs as u8 as usize];
let cbw4 = cb_dim[0] as i32;
let cbh4 = cb_dim[1] as i32;
let cw4 = imin(fi.bw - cbx, cbw4);
let ch4 = imin(fi.bh - cby, cbh4);
let cw4ss = (cw4 + ss_hor) >> ss_hor;
let ch4ss = (ch4 + ss_ver) >> ss_ver;
let uv_stride = recon.frame.uv_stride_px;
let cw = (cbw4 * 4 >> ss_hor) as usize;
let ch = (cbh4 * 4 >> ss_ver) as usize;
let r_step = step;
let o_step = step;
let do_chroma_mc = chroma_stage != ChromaPhase::ReadOnly;
let mut chroma_bacp = false;
for plane in (0..2usize).filter(|_| do_chroma_mc) {
let dst_off = 4 * ((cby >> ss_ver) as usize * uv_stride + (cbx >> ss_hor) as usize);
let _len = crate::mc_dispatch::compound_tmp_len(cw, ch);
let mut tmp = recon.scratch.take_compound_tmp(_len);
let pl_bacp = rmv_uvpred(
recon,
b,
&mut tmp,
plane,
r_step,
o_step,
cbw4,
cbh4,
cbx,
cby,
r_pair,
true,
&mut seg_mask,
fi,
single.then_some(dst_off),
);
let use_bacp = if plane == 0 {
chroma_bacp = pl_bacp;
pl_bacp
} else {
chroma_bacp
};
let dst: &mut [BD::Pixel] = if plane == 0 {
&mut recon.dst_u[dst_off..]
} else {
&mut recon.dst_v[dst_off..]
};
let (tmp0, tmp1) = tmp.split_at(1);
if single {
} else if use_bacp {
mc_mask(
recon.frame.exec,
bd,
dst,
uv_stride,
&tmp0[0],
&tmp1[0],
cw,
ch,
&seg_mask,
);
} else if cwp_idx == 8 {
mc_avg(
recon.frame.exec,
bd,
dst,
uv_stride,
&tmp0[0],
&tmp1[0],
cw,
ch,
);
} else {
crate::decode::recon_intra::mc_w_avg(
recon.frame.exec,
bd,
dst,
uv_stride,
&tmp0[0],
&tmp1[0],
cw,
ch,
cwp_idx,
);
}
recon.scratch.put_compound_tmp(tmp);
}
let seg_id = b.seg_id as usize;
let lossless = recon.frame.seg_lossless[seg_id] != 0;
let uvtx = if lossless {
0usize
} else {
let layout_idx =
(crate::headers::PixelLayout::I444 as i32 - recon.frame.layout as i32) as usize;
crate::tables::MAX_TXFM_SIZE_FOR_BS[cbs as u8 as usize][layout_idx] as usize
};
let uv_txtp_seed = recon.scratch.txtp_map[(by & 15) as usize * 16 + (bx & 15) as usize];
let cbw4ss = (cbw4 + ss_hor) >> ss_hor;
let cbh4ss = (cbh4 + ss_ver) >> ss_ver;
inter_chroma_residual_8bpc(
recon,
msac,
cdf_m,
a,
l,
b,
uvtx,
cbx,
cby,
cbw4ss,
cbh4ss,
cw4ss,
ch4ss,
uv_txtp_seed,
chroma_stage,
fi,
)?;
}
recon.scratch.put_compound_seg_mask(seg_mask);
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn rmv_uvpred<BD: crate::pixel::BitDepth>(
recon: &mut ReconCtx<BD>,
b: &Av2Block,
tmp: &mut [Vec<i16>; 2],
plane: usize,
r_step: i32,
o_step: i32,
bw4: i32,
bh4: i32,
cbx: i32,
cby: i32,
r_pair: crate::levels::RefPair,
tip: bool,
mask: &mut [u8],
fi: &SbFrameInfo,
put_dst: Option<usize>,
) -> bool {
let bd = recon.bd;
let ss_hor = recon.frame.ss_hor;
let ss_ver = recon.frame.ss_ver;
let refs = r_pair.refs();
let r0 = refs[0] as usize;
let r1 = refs[1] as usize;
let b_mv = [b.inter_data().mv[0].xy(), b.inter_data().mv[1].xy()];
let refp0 = match recon.refp[r0].clone() {
Some(p) => p,
None => return false,
};
let refp1 = match recon.refp[r1].clone() {
Some(p) => p,
None => return false,
};
let refp = [&refp0, &refp1];
let filter = b.inter_data().filter;
let stride = (bw4 * 4 >> ss_hor) as usize;
let bacp = plane == 0 && recon.seq_hdr.imp_msk_bld && b.inter_data().cwp_idx == 8;
if bacp {
for m in mask.iter_mut().take((bw4 * bh4 * 16) as usize) {
*m = 0x20;
}
}
let mut have_bacp = false;
let w = fi.bw * 4 >> ss_hor;
let h = fi.bh * 4 >> ss_ver;
let rw4 = imin(bw4, r_step);
let rh4 = imin(bh4, r_step);
let ow4 = imin(bw4, o_step);
let oh4 = imin(bh4, o_step);
let hhtaps = 2 + 2 * (rw4 > 1 + ss_hor) as i32;
let hvtaps = 2 + 2 * (rh4 > 1 + ss_ver) as i32;
let h4 = imin(bh4, fi.bh - cby);
let w4 = imin(bw4, fi.bw - cbx);
let mut uvoff = 0usize;
let mut y = 0i32;
while y < h4 {
let mut x = 0i32;
while x < w4 {
let rmv_base = (((cby + y) & 31) >> 1) as usize * 16 + (((cbx + x) & 31) >> 1) as usize;
let rmv = recon.scratch.rmv[rmv_base];
let mut top = [0i32; 2];
let mut left = [0i32; 2];
let mut bottom = [0i32; 2];
let mut right = [0i32; 2];
for i in 0..2 {
let (dy, dx) = if tip {
(rmv[1][i].y() >> 4, rmv[1][i].x() >> 4)
} else {
(b_mv[i].y >> (3 + ss_ver), b_mv[i].x >> (3 + ss_hor))
};
top[i] = ((cby + y) * 4 >> ss_ver) + dy;
left[i] = ((cbx + x) * 4 >> ss_hor) + dx;
bottom[i] = iclip(top[i] + (4 * rh4 >> ss_ver) + hvtaps, 1, h);
right[i] = iclip(left[i] + (4 * rw4 >> ss_hor) + hhtaps, 1, w);
top[i] = iclip(top[i] + 1 - hvtaps, 0, h - 1);
left[i] = iclip(left[i] + 1 - hhtaps, 0, w - 1);
}
let mut uvoffi = uvoff;
let mut by = 0i32;
while by < rh4 {
let mut bx = 0i32;
while bx < rw4 {
let rmv2_idx = (((cby + y) & 31) >> 1) as usize * 16
+ (by != 0) as usize * 16
+ (((cbx + x + bx) & 31) >> 1) as usize;
let rmv2 = recon.scratch.rmv[rmv2_idx];
if let Some(doff) = put_dst {
let uv_stride = recon.frame.uv_stride_px;
let o = doff
+ ((y * 4 >> ss_ver) + (by * 4 >> ss_ver)) as usize * uv_stride
+ ((x + bx) * 4 >> ss_hor) as usize;
let dst = if plane == 0 {
&mut recon.dst_u[o..]
} else {
&mut recon.dst_v[o..]
};
mc_put_bounded(
bd,
recon.frame.exec,
dst,
uv_stride,
ow4 >> ss_hor,
oh4 >> ss_ver,
(cbx + x + bx) >> ss_hor,
(cby + y + by) >> ss_ver,
1 + plane,
rmv2[0][0].x(),
rmv2[0][0].y(),
refp[0],
filter,
[left[0], right[0], top[0], bottom[0]],
recon.scratch.inter_mc_tmp_mut(),
);
bx += ow4;
continue;
}
for i in 0..2 {
let off = uvoffi + (((x + bx) * 4 >> ss_hor) as usize);
let mvy = rmv2[0][i].y();
let mvx = rmv2[0][i].x();
mc_opfl_8bpc(
bd,
recon.frame.exec,
&mut tmp[i],
off,
stride,
ow4 >> ss_hor,
oh4 >> ss_ver,
(cbx + x + bx) >> ss_hor,
(cby + y + by) >> ss_ver,
1 + plane,
mvx,
mvy,
refp[i],
filter,
left[i],
right[i],
top[i],
bottom[i],
recon.scratch.inter_mc_tmp_mut(),
);
}
if bacp {
have_bacp |= crate::recon::get_mask(
mask,
(bw4 * 4 >> ss_hor) as usize,
cbx >> ss_hor,
(x + bx) >> ss_hor,
cby >> ss_ver,
(y + by) >> ss_ver,
&rmv2[0],
4,
4,
ow4 >> ss_hor,
oh4 >> ss_ver,
fi.bw * 4 >> ss_hor,
fi.bh * 4 >> ss_ver,
);
}
bx += ow4;
}
uvoffi += (oh4 * 4 * stride as i32 >> ss_ver) as usize;
by += oh4;
}
x += rw4;
}
uvoff += (rh4 * 4 * stride as i32 >> ss_ver) as usize;
y += rh4;
}
bacp && have_bacp
}
#[allow(clippy::too_many_arguments)]
fn prep_opfl_prefetch_8bpc<BD: crate::pixel::BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
p: &mut [BD::Pixel],
p_stride: usize,
ref_pic: &crate::picture::Picture,
bx4: i32,
by4: i32,
step: i32,
mvx: i32,
mvy: i32,
left: i32,
right: i32,
top: i32,
bottom: i32,
inter_scratch: &mut Vec<i16>,
) {
let ref_stride = ref_pic.stride[0].unsigned_abs() / std::mem::size_of::<BD::Pixel>();
let ref_data: &[BD::Pixel] = match ref_pic.ref_plane_slice::<BD::Pixel>(0) {
Some(s) => s,
None => return,
};
let dim = ((step + 2) * 4) as i32;
let mx = mvx & 7;
let my = mvy & 7;
let dx = bx4 * 4 + (mvx >> 3);
let dy = by4 * 4 + (mvy >> 3);
let need_emu = dx - (mx != 0) as i32 * 3 < left
|| dy - (my != 0) as i32 * 3 < top
|| dx + dim + (mx != 0) as i32 * 4 > right
|| dy + dim + (my != 0) as i32 * 4 > bottom;
let dimu = dim as usize;
let mut emu_buf = if need_emu {
Some(vec![BD::Pixel::default(); 192 * 192])
} else {
None
};
let (src, src_off, src_stride) = if let Some(ref mut buf) = emu_buf {
let emu_w = dimu + (mx != 0) as usize * 7;
let emu_h = dimu + (my != 0) as usize * 7;
let emu_stride = 192usize;
let src_base = ((left + top * ref_stride as i32).max(0) as usize).min(ref_data.len());
inter_emu_edge_8bpc::<BD>(
buf,
emu_stride,
&ref_data[src_base..],
ref_stride,
emu_w,
emu_h,
(right - left).max(0) as usize,
(bottom - top).max(0) as usize,
dx - (mx != 0) as i32 * 3 - left,
dy - (my != 0) as i32 * 3 - top,
);
let off = emu_stride * (my != 0) as usize * 3 + (mx != 0) as usize * 3;
(&buf[..], off, emu_stride)
} else {
let off = dy as usize * ref_stride + dx as usize;
(ref_data, off, ref_stride)
};
if BD::BPC == 8 {
let p8: &mut [u8] = BD::Pixel::slice_as_ne_bytes_mut(p);
let src8: &[u8] = BD::Pixel::slice_as_ne_bytes(src);
exec.put_bilin_8bpc_with_scratch(
p8,
p_stride,
&src8[src_off..],
src_stride,
dimu,
dimu,
mx << 1,
my << 1,
inter_scratch,
);
} else {
crate::mc::put_bilin(
bd,
p,
p_stride,
&src[src_off..],
src_stride,
dimu,
dimu,
mx << 1,
my << 1,
);
}
}
#[allow(clippy::too_many_arguments)]
fn update_temporal_grid<BD: crate::pixel::BitDepth>(
recon: &mut ReconCtx<BD>,
by_abs: i32,
bx_abs: i32,
w8: usize,
h8: usize,
r: crate::levels::RefPair,
mv: &[crate::levels::Mv; 2],
swap: bool,
) {
let t_stride = recon.rf.rp_stride;
let idx = ((by_abs >> 1) as isize * t_stride + (bx_abs >> 1) as isize) as usize;
if idx >= recon.cur_mvs.len() {
return;
}
crate::recon::update_temporal(
&mut recon.cur_mvs[idx..],
t_stride as usize,
w8,
h8,
r,
mv,
swap,
);
}
#[allow(clippy::too_many_arguments)]
fn update_temporal_grid_sub<BD: crate::pixel::BitDepth>(
recon: &mut ReconCtx<BD>,
by_abs: i32,
bx_abs: i32,
p: i32,
t_stride: isize,
r: crate::levels::RefPair,
mv: &[crate::levels::Mv; 2],
swap: bool,
) {
let base = (by_abs >> 1) as isize * t_stride + (bx_abs >> 1) as isize;
let idx = (base + ((p & 2) >> 1) as isize * t_stride + (p & 1) as isize) as usize;
if idx >= recon.cur_mvs.len() {
return;
}
crate::recon::update_temporal(
&mut recon.cur_mvs[idx..],
t_stride as usize,
1,
1,
r,
mv,
swap,
);
}
#[allow(clippy::too_many_arguments)]
fn inter_mc_plane_prep_at_8bpc<BD: crate::pixel::BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
tmp: &mut [i16],
off: usize,
tmp_stride: usize,
ref_pic: &crate::picture::Picture,
pl: usize,
bx: i32,
by: i32,
bw4: i32,
bh4: i32,
mvx: i32,
mvy: i32,
filter: u8,
ss_hor: i32,
ss_ver: i32,
cur_bw: i32,
cur_bh: i32,
inter_scratch: &mut Vec<i16>,
) {
mc_prep_bounds_8bpc(
bd,
exec,
&mut tmp[off..],
tmp_stride,
ref_pic,
pl,
bx,
by,
bw4,
bh4,
mvx,
mvy,
filter,
ss_hor,
ss_ver,
0,
cur_bw * 4 >> if pl != 0 { ss_hor } else { 0 },
0,
cur_bh * 4 >> if pl != 0 { ss_ver } else { 0 },
inter_scratch,
);
}
#[inline]
fn apply_sign_i8(x: i32, s: i32) -> i8 {
(if s < 0 { -x } else { x }) as i8
}
#[allow(clippy::too_many_arguments)]
fn mc_prep_bounds_8bpc<BD: crate::pixel::BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
tmp: &mut [i16],
tmp_stride: usize,
ref_pic: &crate::picture::Picture,
pl: usize,
bx: i32,
by: i32,
bw4: i32,
bh4: i32,
mvx: i32,
mvy: i32,
filter: u8,
ss_hor: i32,
ss_ver: i32,
left: i32,
right: i32,
top: i32,
bottom: i32,
inter_scratch: &mut Vec<i16>,
) {
let plss_ver = if pl != 0 { ss_ver } else { 0 };
let plss_hor = if pl != 0 { ss_hor } else { 0 };
let h_mul = 4 >> plss_hor;
let v_mul = 4 >> plss_ver;
let ref_stride =
ref_pic.stride[(pl != 0) as usize].unsigned_abs() / std::mem::size_of::<BD::Pixel>();
let ref_data: &[BD::Pixel] = match ref_pic.ref_plane_slice::<BD::Pixel>(pl) {
Some(s) => s,
None => return,
};
let mx = mvx & (15 >> (plss_hor == 0) as i32);
let my = mvy & (15 >> (plss_ver == 0) as i32);
let dx = bx * h_mul + (mvx >> (3 + plss_hor));
let dy = by * v_mul + (mvy >> (3 + plss_ver));
let need_emu = dx - (mx != 0) as i32 * 3 < left
|| dy - (my != 0) as i32 * 3 < top
|| dx + bw4 * h_mul + (mx != 0) as i32 * 4 > right
|| dy + bh4 * v_mul + (my != 0) as i32 * 4 > bottom;
let w = (bw4 * h_mul) as usize;
let h = (bh4 * v_mul) as usize;
let mxf = mx << (plss_hor == 0) as i32;
let myf = my << (plss_ver == 0) as i32;
let is_bilin = filter == 3;
let mut emu_buf = if need_emu {
Some(vec![BD::Pixel::default(); 192 * 192])
} else {
None
};
let (src, src_off, src_stride) = if let Some(ref mut buf) = emu_buf {
let emu_w = w + (mx != 0) as usize * 7;
let emu_h = h + (my != 0) as usize * 7;
let emu_stride = 192usize;
let src_base = ((left + top * ref_stride as i32).max(0) as usize).min(ref_data.len());
inter_emu_edge_8bpc::<BD>(
buf,
emu_stride,
&ref_data[src_base..],
ref_stride,
emu_w,
emu_h,
(right - left).max(0) as usize,
(bottom - top).max(0) as usize,
dx - (mx != 0) as i32 * 3 - left,
dy - (my != 0) as i32 * 3 - top,
);
let off = emu_stride * (my != 0) as usize * 3 + (mx != 0) as usize * 3;
(&buf[..], off, emu_stride)
} else {
let off = dy as usize * ref_stride + dx as usize;
(ref_data, off, ref_stride)
};
if BD::BPC == 8 {
let src8: &[u8] = BD::Pixel::slice_as_ne_bytes(src);
if is_bilin {
exec.prep_bilin_8bpc_with_scratch(
tmp,
tmp_stride,
&src8[src_off..],
src_stride,
w,
h,
mxf,
myf,
inter_scratch,
);
} else {
exec.prep_8tap_8bpc_with_scratch(
tmp,
tmp_stride,
src8,
src_off,
src_stride,
w,
h,
mxf,
myf,
filter as i32,
inter_scratch,
);
}
} else if is_bilin {
crate::mc::prep_bilin(
bd,
tmp,
tmp_stride,
&src[src_off..],
src_stride,
w,
h,
mxf,
myf,
);
} else {
crate::mc::prep_8tap(
bd,
tmp,
tmp_stride,
src,
src_off,
src_stride,
w,
h,
mxf,
myf,
filter as i32,
);
}
}
#[allow(clippy::too_many_arguments)]
fn mc_opfl_8bpc<BD: crate::pixel::BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
dst16: &mut [i16],
dst_off: usize,
dst_stride: usize,
bw4: i32,
bh4: i32,
bx4: i32,
by4: i32,
pl: usize,
mvx: i32,
mvy: i32,
ref_pic: &crate::picture::Picture,
filter: u8,
left: i32,
right: i32,
top: i32,
bottom: i32,
inter_scratch: &mut Vec<i16>,
) {
let ref_stride =
ref_pic.stride[(pl != 0) as usize].unsigned_abs() / std::mem::size_of::<BD::Pixel>();
let ref_data: &[BD::Pixel] = match ref_pic.ref_plane_slice::<BD::Pixel>(pl) {
Some(s) => s,
None => return,
};
let mx = mvx & 15;
let my = mvy & 15;
let w = (bw4 * 4) as usize;
let h = (bh4 * 4) as usize;
let is_bilin = filter == 3;
let (src, src_off, src_stride) = bounded_mc_src::<BD>(
ref_data,
ref_stride,
w,
h,
mx,
my,
bx4 * 4 + (mvx >> 4),
by4 * 4 + (mvy >> 4),
[left, right, top, bottom],
);
let src = &*src;
if BD::BPC == 8 {
let src8: &[u8] = BD::Pixel::slice_as_ne_bytes(src);
if is_bilin {
exec.prep_bilin_8bpc_with_scratch(
&mut dst16[dst_off..],
dst_stride,
&src8[src_off..],
src_stride,
w,
h,
mx,
my,
inter_scratch,
);
} else {
exec.prep_8tap_8bpc_with_scratch(
&mut dst16[dst_off..],
dst_stride,
src8,
src_off,
src_stride,
w,
h,
mx,
my,
filter as i32,
inter_scratch,
);
}
} else if is_bilin {
crate::mc::prep_bilin(
bd,
&mut dst16[dst_off..],
dst_stride,
&src[src_off..],
src_stride,
w,
h,
mx,
my,
);
} else {
crate::mc::prep_8tap(
bd,
&mut dst16[dst_off..],
dst_stride,
src,
src_off,
src_stride,
w,
h,
mx,
my,
filter as i32,
);
}
}
#[allow(clippy::too_many_arguments)]
fn bounded_mc_src<BD: crate::pixel::BitDepth>(
ref_data: &[BD::Pixel],
ref_stride: usize,
w: usize,
h: usize,
mx: i32,
my: i32,
dx: i32,
dy: i32,
bounds: [i32; 4],
) -> (std::borrow::Cow<'_, [BD::Pixel]>, usize, usize) {
let [left, right, top, bottom] = bounds;
let need_emu = dx - (mx != 0) as i32 * 3 < left
|| dy - (my != 0) as i32 * 3 < top
|| dx + w as i32 + (mx != 0) as i32 * 4 > right
|| dy + h as i32 + (my != 0) as i32 * 4 > bottom;
if !need_emu {
let off = dy as usize * ref_stride + dx as usize;
return (std::borrow::Cow::Borrowed(ref_data), off, ref_stride);
}
let mut buf = vec![BD::Pixel::default(); 192 * 192];
let emu_w = w + (mx != 0) as usize * 7;
let emu_h = h + (my != 0) as usize * 7;
let emu_stride = 192usize;
let src_base = ((left + top * ref_stride as i32).max(0) as usize).min(ref_data.len());
inter_emu_edge_8bpc::<BD>(
&mut buf,
emu_stride,
&ref_data[src_base..],
ref_stride,
emu_w,
emu_h,
(right - left).max(0) as usize,
(bottom - top).max(0) as usize,
dx - (mx != 0) as i32 * 3 - left,
dy - (my != 0) as i32 * 3 - top,
);
let off = emu_stride * (my != 0) as usize * 3 + (mx != 0) as usize * 3;
(std::borrow::Cow::Owned(buf), off, emu_stride)
}
#[allow(clippy::too_many_arguments)]
fn mc_put_bounded<BD: crate::pixel::BitDepth>(
bd: BD,
exec: &crate::exec_context::ExecContext,
dst: &mut [BD::Pixel],
dst_stride: usize,
bw4: i32,
bh4: i32,
bx4: i32,
by4: i32,
pl: usize,
mvx: i32,
mvy: i32,
ref_pic: &crate::picture::Picture,
filter: u8,
bounds: [i32; 4],
inter_scratch: &mut Vec<i16>,
) {
let ref_stride =
ref_pic.stride[(pl != 0) as usize].unsigned_abs() / std::mem::size_of::<BD::Pixel>();
let ref_data: &[BD::Pixel] = match ref_pic.ref_plane_slice::<BD::Pixel>(pl) {
Some(s) => s,
None => return,
};
let mx = mvx & 15;
let my = mvy & 15;
let w = (bw4 * 4) as usize;
let h = (bh4 * 4) as usize;
let (src, src_off, src_stride) = bounded_mc_src::<BD>(
ref_data,
ref_stride,
w,
h,
mx,
my,
bx4 * 4 + (mvx >> 4),
by4 * 4 + (mvy >> 4),
bounds,
);
let src = &*src;
if BD::BPC == 8 {
let dst8: &mut [u8] = BD::Pixel::slice_as_ne_bytes_mut(dst);
let src8: &[u8] = BD::Pixel::slice_as_ne_bytes(src);
if filter == 3 {
exec.put_bilin_8bpc_with_scratch(
dst8,
dst_stride,
&src8[src_off..],
src_stride,
w,
h,
mx,
my,
inter_scratch,
);
} else {
exec.put_8tap_8bpc_with_scratch(
dst8,
dst_stride,
src8,
src_off,
src_stride,
w,
h,
mx,
my,
filter as i32,
inter_scratch,
);
}
} else if let (Some(dst16), Some(src16)) = (
<BD::Pixel as Pixel>::try_as_u16_slice_mut(dst),
<BD::Pixel as Pixel>::try_as_u16_slice(src),
) {
if filter == 3 {
exec.put_bilin_hbd_with_scratch(
dst16,
dst_stride,
&src16[src_off..],
src_stride,
w,
h,
mx,
my,
bd.bitdepth(),
inter_scratch,
);
} else {
exec.put_8tap_hbd_with_scratch(
dst16,
dst_stride,
src16,
src_off,
src_stride,
w,
h,
mx,
my,
filter as i32,
bd.bitdepth(),
inter_scratch,
);
}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn recon_b_inter<
BD: crate::pixel::BitDepth,
const UPDATE_CDF: bool,
M: MsacReader<UPDATE_CDF>,
>(
recon: &mut ReconCtx<BD>,
msac: &mut M,
cdf_m: &mut CdfModeContext,
a: &mut BlockContext,
l: &mut BlockContext,
b: &Av2Block,
bx: i32,
by: i32,
cbx: i32,
cby: i32,
lbs: BlockSize,
cbs: BlockSize,
has_luma: bool,
has_chroma: bool,
chroma_stage: ChromaPhase,
fi: &SbFrameInfo,
) -> Result<(), ()>
where
BD::Coef: DecodeCoeff,
{
let bd = recon.bd;
let refs = b.ref_pair.refs();
let ref0 = refs[0];
let ref1 = refs[1];
if ref0 as usize == crate::levels::TIP_FRAME {
return recon_b_inter_tip(
recon,
msac,
cdf_m,
a,
l,
b,
bx,
by,
cbx,
cby,
lbs,
cbs,
has_luma,
has_chroma,
chroma_stage,
fi,
);
}
if ref0 < 0 || ref0 as usize >= 7 {
return Ok(());
}
{
let bs0 = if lbs == BlockSize::Invalid { cbs } else { lbs };
let bdim0 = &BLOCK_DIMENSIONS[bs0 as u8 as usize];
let bw4_0 = bdim0[0] as i32;
let bh4_0 = bdim0[1] as i32;
if imax(bw4_0, bh4_0) > 16 {
debug_assert!(chroma_stage == ChromaPhase::Both);
return recon_b_inter_split(
recon, msac, cdf_m, a, l, b, bx, by, cbx, cby, lbs, cbs, has_luma, has_chroma, fi,
bs0, bw4_0, bh4_0,
);
}
}
let mv = b.inter_data().mv[0].xy();
let mv1 = b.inter_data().mv[1].xy();
let filter = b.inter_data().filter;
let comp_type = b.inter_data().comp_type;
let ss_hor = recon.frame.ss_hor;
let ss_ver = recon.frame.ss_ver;
let is_compound = ref1 >= 0 && (ref1 as usize) < 7;
if is_compound {
return recon_b_inter_compound(
recon,
msac,
cdf_m,
a,
l,
b,
bx,
by,
cbx,
cby,
lbs,
cbs,
has_luma,
has_chroma,
chroma_stage,
fi,
);
}
let refp = match recon.refp[ref0 as usize].clone() {
Some(p) => p,
None => return Ok(()),
};
let _ = (mv1, comp_type);
let motion_mode = b.inter_data().motion_mode;
let inter_mode = b.inter_data().inter_mode;
let warp_block = {
let bdim = &BLOCK_DIMENSIONS[lbs as u8 as usize];
let bw4 = bdim[0] as i32;
let bh4 = bdim[1] as i32;
let mut gmv = recon.frm_hdr.gmv.m[ref0 as usize];
let gmv_warp_allowed = gmv.wm_type > crate::headers::WarpedMotionType::Translation
&& recon.frm_hdr.force_integer_mv == 0
&& crate::warpmv::get_shear_params(&mut gmv) == 0
&& recon.svc[ref0 as usize][0].scale == 0;
recon.frm_hdr.force_integer_mv == 0
&& ((inter_mode == crate::levels::InterPredMode::GlobalMv as u8
&& imin(bw4, bh4) > 1
&& gmv_warp_allowed)
|| (motion_mode >= MotionMode::WarpCausal as u8
&& recon.warpmv[0].wm_type > crate::headers::WarpedMotionType::Invalid))
};
let use_local_warp = motion_mode >= MotionMode::WarpCausal as u8;
if has_luma {
let bs = lbs;
let b_dim = &BLOCK_DIMENSIONS[bs as u8 as usize];
let bw4 = b_dim[0] as i32;
let bh4 = b_dim[1] as i32;
let y_stride = recon.frame.y_stride_px;
let dst_off = 4 * (by as usize * y_stride + bx as usize);
let wmp = if use_local_warp {
recon.warpmv[0]
} else {
recon.frm_hdr.gmv.m[ref0 as usize]
};
if warp_block {
if wmp.affine != 0 && imin(bw4 * 4, bh4 * 4) >= 8 {
warp_affine_plane_8bpc(
bd,
recon.frame.exec,
&mut recon.dst_y[dst_off..],
y_stride,
&refp,
0,
bx,
by,
b_dim,
&wmp,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
);
} else {
ext_warp_plane_8bpc(
bd,
recon.frame.exec,
&mut recon.dst_y[dst_off..],
y_stride,
&refp,
0,
bx,
by,
b_dim,
&wmp,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
} else {
inter_mc_plane_8bpc(
bd,
recon.frame.exec,
&mut recon.dst_y[dst_off..],
y_stride,
&refp,
0,
bx,
by,
bw4,
bh4,
mv.x,
mv.y,
filter,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
let bawp0 = b.inter_data().bawp[0] as i32;
if bawp0 != 0 {
let w4c = imin(bw4, fi.bw - bx);
let h4c = imin(bh4, fi.bh - by);
bawp_plane(
recon,
bawp0,
mv,
dst_off,
y_stride,
&refp,
ref0 as usize,
0,
bw4,
bh4,
w4c,
h4c,
bx,
by,
bs,
fi,
);
} else if motion_mode == MotionMode::InterIntra as u8 || b.inter_data().warp_ii != 0 {
let dst_off_y = dst_off;
iiblend_luma_8bpc(recon, &b, dst_off_y, y_stride, bw4, bh4, by, bx, bs, fi);
}
let seg_id = b.seg_id as usize;
let lossless = recon.frame.seg_lossless[seg_id] != 0;
if lossless {
let tx = if b.tx_size_ll != 0 {
crate::tables::MAX_TXFM_SIZE_FOR_BS[bs as usize][3] as usize
} else {
0
};
let t_dim = &TXFM_DIMENSIONS[tx];
let (tw4, th4) = (t_dim.w as i32, t_dim.h as i32);
let h4 = imin(bh4, fi.bh - by);
let w4 = imin(bw4, fi.bw - bx);
let mut y = 0;
while y < h4 {
let mut x = 0;
while x < w4 {
inter_residual_tx_8bpc(
recon,
msac,
cdf_m,
a,
l,
b,
0,
tx,
bx + x,
by + y,
false,
0,
fi,
)?;
x += tw4;
}
y += th4;
}
} else {
let tp = &crate::tables::TX_PART_TBL[bs as usize];
let tx = tp[b.tx_part as usize] as usize;
inter_luma_tx_walk(recon, msac, cdf_m, a, l, b, tx, bx, by, fi)?;
}
}
if has_chroma && cbs != BlockSize::Invalid {
let cb_dim = &BLOCK_DIMENSIONS[cbs as u8 as usize];
let cbw4 = cb_dim[0] as i32;
let cbh4 = cb_dim[1] as i32;
let cw4 = imin(fi.bw - cbx, cbw4);
let ch4 = imin(fi.bh - cby, cbh4);
let cw4ss = (cw4 + ss_hor) >> ss_hor;
let ch4ss = (ch4 + ss_ver) >> ss_ver;
let uv_stride = recon.frame.uv_stride_px;
let (luma_bw4, luma_bh4) = {
let ld = &BLOCK_DIMENSIONS[lbs as u8 as usize];
(ld[0] as i32, ld[1] as i32)
};
let sub8x8 =
lbs != BlockSize::Invalid && cbs != lbs && imin(luma_bw4, luma_bh4) < 16 && !warp_block;
let do_chroma_mc = chroma_stage != ChromaPhase::ReadOnly;
if sub8x8 && do_chroma_mc {
let base = ((cby & 63) as usize) * 128 + ((cbx & 127) as usize);
for y in 0..ch4 {
for x in 0..cw4 {
let idx = base + (y as usize) * 128 + (x as usize);
let r2 = &recon.rt.r[idx];
if r2.ox4 != 0 || r2.oy4 != 0 {
continue;
}
let s_ref0 = r2.reference.ref_at(0);
if s_ref0 < 0 || s_ref0 as usize >= 7 {
continue;
}
let s_mv = if r2.mf & 2 != 0 {
r2.lmv[0].xy()
} else {
r2.mv[0].xy()
};
let s_filter = r2.subpel_filter;
let sdim = &BLOCK_DIMENSIONS[r2.bs as usize];
let s_bw4 = sdim[0] as i32;
let s_bh4 = sdim[1] as i32;
let s_refp = match recon.refp[s_ref0 as usize].clone() {
Some(p) => p,
None => continue,
};
let s_cbx = cbx + x;
let s_cby = cby + y;
let base_off =
4 * ((cby >> ss_ver) as usize * uv_stride + (cbx >> ss_hor) as usize);
let dst_off = base_off
+ (((y * 4) >> ss_ver) as usize) * uv_stride
+ (((x * 4) >> ss_hor) as usize);
for pl in 1..3usize {
let dst: &mut [BD::Pixel] = if pl == 1 {
&mut recon.dst_u[dst_off..]
} else {
&mut recon.dst_v[dst_off..]
};
inter_mc_plane_8bpc(
bd,
recon.frame.exec,
dst,
uv_stride,
&s_refp,
pl,
s_cbx,
s_cby,
s_bw4,
s_bh4,
s_mv.x,
s_mv.y,
s_filter,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
}
}
}
let c_wmp = if use_local_warp {
recon.warpmv[0]
} else {
recon.frm_hdr.gmv.m[ref0 as usize]
};
let c_affine = c_wmp.affine != 0 && imin(cbw4 * (4 >> ss_hor), cbh4 * (4 >> ss_ver)) >= 8;
for pl in (1..3).filter(|_| !sub8x8 && do_chroma_mc) {
let dst_off = 4 * ((cby >> ss_ver) as usize * uv_stride + (cbx >> ss_hor) as usize);
let dst: &mut [BD::Pixel] = if pl == 1 {
&mut recon.dst_u[dst_off..]
} else {
&mut recon.dst_v[dst_off..]
};
if warp_block {
if c_affine {
warp_affine_plane_8bpc(
bd,
recon.frame.exec,
dst,
uv_stride,
&refp,
pl,
cbx,
cby,
cb_dim,
&c_wmp,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
);
} else {
ext_warp_plane_8bpc(
bd,
recon.frame.exec,
dst,
uv_stride,
&refp,
pl,
cbx,
cby,
cb_dim,
&c_wmp,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
} else {
inter_mc_plane_8bpc(
bd,
recon.frame.exec,
dst,
uv_stride,
&refp,
pl,
cbx,
cby,
cbw4,
cbh4,
mv.x,
mv.y,
filter,
ss_hor,
ss_ver,
fi.bw,
fi.bh,
recon.scratch.inter_mc_tmp_mut(),
);
}
}
let chroma_bawp = !sub8x8 && do_chroma_mc && b.inter_data().bawp[1] != 0;
if chroma_bawp {
let cw4c = imin(cbw4, fi.bw - cbx);
let ch4c = imin(cbh4, fi.bh - cby);
let blk_bs = BlockSize::from_raw(b.bs);
for pl in 1..3usize {
let dst_off = 4 * ((cby >> ss_ver) as usize * uv_stride + (cbx >> ss_hor) as usize);
bawp_plane(
recon,
1,
mv,
dst_off,
uv_stride,
&refp,
ref0 as usize,
pl,
cbw4,
cbh4,
cw4c,
ch4c,
cbx,
cby,
blk_bs,
fi,
);
}
}
if !sub8x8
&& !chroma_bawp
&& do_chroma_mc
&& (motion_mode == MotionMode::InterIntra as u8 || b.inter_data().warp_ii != 0)
{
let ii_ss_bs = if b.inter_data().wedge_idx == -1 {
let layout_idx = (recon.frame.layout as usize) - 1;
BlockSize::from_raw(crate::tables::SS_BS[cbs as usize][layout_idx] as i8)
} else {
cbs
};
let dst_off = 4 * ((cby >> ss_ver) as usize * uv_stride + (cbx >> ss_hor) as usize);
for pl in 1..3usize {
iiblend_chroma_8bpc(
recon, &b, pl, dst_off, uv_stride, cbw4, cbh4, cby, cbx, ii_ss_bs, fi,
);
}
}
let seg_id = b.seg_id as usize;
let lossless = recon.frame.seg_lossless[seg_id] != 0;
let uvtx = if lossless {
0usize
} else {
let layout_idx =
(crate::headers::PixelLayout::I444 as i32 - recon.frame.layout as i32) as usize;
crate::tables::MAX_TXFM_SIZE_FOR_BS[cbs as u8 as usize][layout_idx] as usize
};
let uv_txtp_seed = recon.scratch.txtp_map[(by & 15) as usize * 16 + (bx & 15) as usize];
let cbw4ss = (cbw4 + ss_hor) >> ss_hor;
let cbh4ss = (cbh4 + ss_ver) >> ss_ver;
inter_chroma_residual_8bpc(
recon,
msac,
cdf_m,
a,
l,
b,
uvtx,
cbx,
cby,
cbw4ss,
cbh4ss,
cw4ss,
ch4ss,
uv_txtp_seed,
chroma_stage,
fi,
)?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn recon_b_inter_split<
BD: crate::pixel::BitDepth,
const UPDATE_CDF: bool,
M: MsacReader<UPDATE_CDF>,
>(
recon: &mut ReconCtx<BD>,
msac: &mut M,
cdf_m: &mut CdfModeContext,
a: &mut BlockContext,
l: &mut BlockContext,
b: &Av2Block,
bx: i32,
by: i32,
cbx: i32,
cby: i32,
lbs: BlockSize,
cbs: BlockSize,
has_luma: bool,
has_chroma: bool,
fi: &SbFrameInfo,
bs: BlockSize,
bw4: i32,
bh4: i32,
) -> Result<(), ()>
where
BD::Coef: DecodeCoeff,
{
static CSPLIT: [[BlockSize; 3]; 3] = [
[
BlockSize::Bs64x64,
BlockSize::Bs128x64,
BlockSize::Bs128x128,
],
[BlockSize::Bs64x64, BlockSize::Bs128x64, BlockSize::Bs128x64],
[BlockSize::Bs64x64, BlockSize::Bs64x64, BlockSize::Bs64x128],
];
let ss_hor = fi.ss_hor;
let ss_ver = fi.ss_ver;
let y_end = imin(by + bh4, fi.bh);
let x_end = imin(bx + bw4, fi.bw);
let (step, lbs2, cbs2i) = if imax(bw4, bh4) == 64 {
(
32,
if lbs == BlockSize::Invalid {
BlockSize::Invalid
} else {
BlockSize::Bs128x128
},
if cbs == BlockSize::Invalid {
BlockSize::Invalid
} else {
BlockSize::Bs128x128
},
)
} else {
let csplit_row = (bs as i32 - BlockSize::Bs128x128 as i32) as usize;
let csi = (ss_hor + ss_ver) as usize;
(
16,
if lbs == BlockSize::Invalid {
BlockSize::Invalid
} else {
BlockSize::Bs64x64
},
if cbs == BlockSize::Invalid {
BlockSize::Invalid
} else {
CSPLIT[csplit_row][csi]
},
)
};
let _ = (has_luma, has_chroma);
let mut sub_by = by;
let mut sub_cby = cby;
let mut yy = 0;
while sub_by < y_end {
let mut sub_bx = bx;
let mut sub_cbx = cbx;
let mut xx = 0;
while sub_bx < x_end {
let (read_cbs, recon_cbs) = if step == 32 {
(cbs2i, cbs2i)
} else {
let read = if ((xx & ss_hor) | (yy & ss_ver)) == 0 {
cbs2i
} else {
BlockSize::Invalid
};
let recon = if (ss_hor == 0 || sub_bx + step >= x_end)
&& (ss_ver == 0 || sub_by + step >= y_end)
{
cbs2i
} else {
BlockSize::Invalid
};
(read, recon)
};
let read_valid = read_cbs != BlockSize::Invalid;
let recon_valid = recon_cbs != BlockSize::Invalid;
let sub_has_chroma = read_valid || recon_valid;
let chroma_stage = match (read_valid, recon_valid) {
(true, true) => ChromaPhase::Both,
(true, false) => ChromaPhase::ReadOnly,
(false, true) => ChromaPhase::ReconOnly,
(false, false) => ChromaPhase::Both,
};
let sub_cbs = if sub_has_chroma {
cbs2i
} else {
BlockSize::Invalid
};
recon_b_inter(
recon,
msac,
cdf_m,
a,
l,
b,
sub_bx,
sub_by,
sub_cbx,
sub_cby,
lbs2,
sub_cbs,
lbs2 != BlockSize::Invalid,
sub_has_chroma,
chroma_stage,
fi,
)?;
sub_bx += step;
if step == 32 {
sub_cbx += step;
} else if (xx & ss_hor) == ss_hor {
sub_cbx += step << ss_hor;
}
xx += 1;
}
sub_by += step;
if step == 32 {
sub_cby += step;
} else if (yy & ss_ver) == ss_ver {
sub_cby += step << ss_ver;
}
yy += 1;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn inter_luma_tx_walk<
BD: crate::pixel::BitDepth,
const UPDATE_CDF: bool,
M: MsacReader<UPDATE_CDF>,
>(
recon: &mut ReconCtx<BD>,
msac: &mut M,
cdf_m: &mut CdfModeContext,
a: &mut BlockContext,
l: &mut BlockContext,
b: &Av2Block,
tx: usize,
bx: i32,
by: i32,
fi: &SbFrameInfo,
) -> Result<(), ()>
where
BD::Coef: DecodeCoeff,
{
let tp = &crate::tables::TX_PART_TBL[b.bs as usize];
macro_rules! resid {
($tx:expr, $x:expr, $y:expr) => {
inter_residual_tx_8bpc(recon, msac, cdf_m, a, l, b, 0, $tx, $x, $y, false, 0, fi)?
};
}
match TxPartition::from_raw(b.tx_part) {
TxPartition::None => {
resid!(tx, bx, by);
}
TxPartition::Split => {
let t_dim = &TXFM_DIMENSIONS[tx];
let (tw4, th4) = (t_dim.w as i32, t_dim.h as i32);
resid!(tx, bx, by);
let have_v_split = bx + tw4 < fi.bw;
if have_v_split {
resid!(tx, bx + tw4, by);
}
if by + th4 >= fi.bh {
return Ok(());
}
resid!(tx, bx, by + th4);
if have_v_split {
resid!(tx, bx + tw4, by + th4);
}
}
TxPartition::H => {
let th4 = TXFM_DIMENSIONS[tx].h as i32;
resid!(tx, bx, by);
if by + th4 >= fi.bh {
return Ok(());
}
resid!(tx, bx, by + th4);
}
TxPartition::V => {
let tw4 = TXFM_DIMENSIONS[tx].w as i32;
resid!(tx, bx, by);
if bx + tw4 >= fi.bw {
return Ok(());
}
resid!(tx, bx + tw4, by);
}
TxPartition::H4 => {
let th4 = TXFM_DIMENSIONS[tx].h as i32;
for i in 0..4 {
let yy = by + i * th4;
resid!(tx, bx, yy);
if yy + th4 >= fi.bh {
break;
}
}
}
TxPartition::V4 => {
let tw4 = TXFM_DIMENSIONS[tx].w as i32;
for i in 0..4 {
let xx = bx + i * tw4;
resid!(tx, xx, by);
if xx + tw4 >= fi.bw {
break;
}
}
}
TxPartition::H5 => {
let tx_big = tp[TxPartition::H as usize] as usize;
let t_dim_small = &TXFM_DIMENSIONS[tx];
let (tw4_small, th4_small) = (t_dim_small.w as i32, t_dim_small.h as i32);
let th4_big = TXFM_DIMENSIONS[tx_big].h as i32;
resid!(tx, bx, by);
let have_v_split = bx + tw4_small < fi.bw;
if have_v_split {
resid!(tx, bx + tw4_small, by);
}
if by + th4_small >= fi.bh {
return Ok(());
}
resid!(tx_big, bx, by + th4_small);
if by + th4_small + th4_big < fi.bh {
resid!(tx, bx, by + th4_small + th4_big);
if have_v_split {
resid!(tx, bx + tw4_small, by + th4_small + th4_big);
}
}
}
TxPartition::V5 => {
let tx_big = tp[TxPartition::V as usize] as usize;
let t_dim_small = &TXFM_DIMENSIONS[tx];
let (tw4_small, th4_small) = (t_dim_small.w as i32, t_dim_small.h as i32);
let tw4_big = TXFM_DIMENSIONS[tx_big].w as i32;
resid!(tx, bx, by);
let have_h_split = by + th4_small < fi.bh;
if have_h_split {
resid!(tx, bx, by + th4_small);
}
if bx + tw4_small >= fi.bw {
return Ok(());
}
resid!(tx_big, bx + tw4_small, by);
if bx + tw4_small + tw4_big < fi.bw {
resid!(tx, bx + tw4_small + tw4_big, by);
if have_h_split {
resid!(tx, bx + tw4_small + tw4_big, by + th4_small);
}
}
}
}
Ok(())
}