use std::sync::OnceLock;
pub(crate) type DeblockApply8bpcFn =
unsafe fn(&mut [u8], isize, isize, isize, i32, i32, i32, bool, bool);
pub(crate) type DeblockApplyHbdFn =
unsafe fn(&mut [u16], isize, isize, isize, i32, i32, i32, bool, bool, i32);
pub(crate) type DeblockSb64Fn =
unsafe fn(&mut [u8], usize, usize, &[u16], &[u16], &[u8], &[u8], bool);
pub(crate) type DeblockSb64HbdFn =
unsafe fn(&mut [u16], usize, usize, &[u16], &[u16], &[u8], &[u8], bool, i32);
pub(crate) type DeblockSetupColsSeg8bpcFn = unsafe fn(
&mut [u8; 256],
&mut [u8; 256],
&[u8],
isize,
isize,
&[[[u16; 4]; 5]; 64],
usize,
&[[u32; 16]; 2],
&mut [u8; 16],
&mut [u8; 16],
i32,
i32,
i32,
i32,
);
pub(crate) type DeblockSetupRowsSeg8bpcFn = unsafe fn(
&mut [u8; 256],
&mut [u8; 256],
&[u8],
isize,
isize,
&[[[u16; 4]; 5]; 64],
usize,
&[[u32; 16]; 2],
Option<&[[u32; 16]; 2]>,
Option<(&[u8], isize)>,
i32,
i32,
i32,
i32,
);
pub(crate) type DeblockSetupColsDq8bpcFn = unsafe fn(
&mut [u8; 256],
&mut [u8; 256],
&[[[u16; 4]; 5]; 64],
usize,
&[[u32; 16]; 2],
&mut [u8; 16],
&mut [u8; 16],
i32,
i32,
i32,
i32,
);
pub(crate) type DeblockSetupRowsDq8bpcFn = unsafe fn(
&mut [u8; 256],
&mut [u8; 256],
&[[[u16; 4]; 5]; 64],
usize,
&[[u32; 16]; 2],
Option<&[[u32; 16]; 2]>,
Option<(&[u8], isize)>,
i32,
i32,
i32,
i32,
);
pub(crate) type DeblockSetupSimple8bpcFn = unsafe fn(
&mut [u8; 256],
&mut [u8; 256],
&[[[u16; 4]; 5]; 64],
usize,
&[[u32; 16]; 2],
i32,
i32,
i32,
i32,
);
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_8bpc_scalar_h_const<const WN: i32, const WP: i32>(
dst: &mut [u8],
off: isize,
stride_line: isize,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
) {
debug_assert!((1..=8).contains(&WN));
debug_assert!((1..=8).contains(&WP));
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(WN - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(WP - 1) as usize] as i32;
let mut dp = off;
for _ in 0..4 {
let p = dp as usize;
let d0 = dst[p] as i32;
let dm1 = dst[p - 1] as i32;
let dp1 = dst[p + 1] as i32;
let dm2 = dst[p - 2] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
if !neg_lossless {
let dn = delta_m2 * wmul_neg;
for j in 0..WN {
let idx = p - j as usize - 1;
let diff = (dn * (WN - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, 255) as u8;
}
}
if !pos_lossless {
let dpv = delta_m2 * wmul_pos;
for j in 0..WP {
let idx = p + j as usize;
let diff = (dpv * (WP - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, 255) as u8;
}
}
dp += stride_line;
}
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_8bpc_scalar_h_specialized(
dst: &mut [u8],
off: isize,
stride_line: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
) -> bool {
match (width_neg, width_pos) {
(1, 1) => deblock_apply_8bpc_scalar_h_const::<1, 1>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(2, 2) => deblock_apply_8bpc_scalar_h_const::<2, 2>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(2, 3) => deblock_apply_8bpc_scalar_h_const::<2, 3>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(2, 4) => deblock_apply_8bpc_scalar_h_const::<2, 4>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(3, 3) => deblock_apply_8bpc_scalar_h_const::<3, 3>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(4, 4) => deblock_apply_8bpc_scalar_h_const::<4, 4>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(6, 6) => deblock_apply_8bpc_scalar_h_const::<6, 6>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(6, 8) => deblock_apply_8bpc_scalar_h_const::<6, 8>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
(8, 8) => deblock_apply_8bpc_scalar_h_const::<8, 8>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
),
_ => return false,
}
true
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_hbd_scalar_h_const<const WN: i32, const WP: i32>(
dst: &mut [u16],
off: isize,
stride_line: isize,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
bitdepth_max: i32,
) {
debug_assert!((1..=8).contains(&WN));
debug_assert!((1..=8).contains(&WP));
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(WN - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(WP - 1) as usize] as i32;
let mut dp = off;
for _ in 0..4 {
let p = dp as usize;
let d0 = dst[p] as i32;
let dm1 = dst[p - 1] as i32;
let dp1 = dst[p + 1] as i32;
let dm2 = dst[p - 2] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
if !neg_lossless {
let dn = delta_m2 * wmul_neg;
for j in 0..WN {
let idx = p - j as usize - 1;
let diff = (dn * (WN - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, bitdepth_max) as u16;
}
}
if !pos_lossless {
let dpv = delta_m2 * wmul_pos;
for j in 0..WP {
let idx = p + j as usize;
let diff = (dpv * (WP - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, bitdepth_max) as u16;
}
}
dp += stride_line;
}
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_hbd_scalar_h_specialized(
dst: &mut [u16],
off: isize,
stride_line: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
bitdepth_max: i32,
) -> bool {
match (width_neg, width_pos) {
(1, 1) => deblock_apply_hbd_scalar_h_const::<1, 1>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(2, 2) => deblock_apply_hbd_scalar_h_const::<2, 2>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(2, 3) => deblock_apply_hbd_scalar_h_const::<2, 3>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(2, 4) => deblock_apply_hbd_scalar_h_const::<2, 4>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(3, 3) => deblock_apply_hbd_scalar_h_const::<3, 3>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(4, 4) => deblock_apply_hbd_scalar_h_const::<4, 4>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(6, 6) => deblock_apply_hbd_scalar_h_const::<6, 6>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(6, 8) => deblock_apply_hbd_scalar_h_const::<6, 8>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
(8, 8) => deblock_apply_hbd_scalar_h_const::<8, 8>(
dst,
off,
stride_line,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
),
_ => return false,
}
true
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_8bpc_scalar_h(
dst: &mut [u8],
off: isize,
stride_line: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
) {
if deblock_apply_8bpc_scalar_h_specialized(
dst,
off,
stride_line,
width_neg,
width_pos,
q_thr_clamp,
neg_lossless,
pos_lossless,
) {
return;
}
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(width_neg - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(width_pos - 1) as usize] as i32;
let mut dp = off;
for _ in 0..4 {
let p = dp as usize;
let d0 = dst[p] as i32;
let dm1 = dst[p - 1] as i32;
let dp1 = dst[p + 1] as i32;
let dm2 = dst[p - 2] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
if !neg_lossless {
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = p - j as usize - 1;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, 255) as u8;
}
}
if !pos_lossless {
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = p + j as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, 255) as u8;
}
}
dp += stride_line;
}
}
pub(crate) fn deblock_apply_8bpc_scalar(
dst: &mut [u8],
off: isize,
stride_line: isize,
stride_tap: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
) {
if stride_tap == 1 {
deblock_apply_8bpc_scalar_h(
dst,
off,
stride_line,
width_neg,
width_pos,
q_thr_clamp,
neg_lossless,
pos_lossless,
);
return;
}
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(width_neg - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(width_pos - 1) as usize] as i32;
let mut dp = off;
if !neg_lossless && !pos_lossless {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = (dp + (-(j as isize) - 1) * stride_tap) as usize;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, 255) as u8;
}
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = (dp + (j as isize) * stride_tap) as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, 255) as u8;
}
dp += stride_line;
}
} else if !neg_lossless {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = (dp + (-(j as isize) - 1) * stride_tap) as usize;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, 255) as u8;
}
dp += stride_line;
}
} else {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = (dp + (j as isize) * stride_tap) as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, 255) as u8;
}
dp += stride_line;
}
}
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_apply_hbd_scalar_h(
dst: &mut [u16],
off: isize,
stride_line: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
bitdepth_max: i32,
) {
if deblock_apply_hbd_scalar_h_specialized(
dst,
off,
stride_line,
width_neg,
width_pos,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
) {
return;
}
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(width_neg - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(width_pos - 1) as usize] as i32;
let mut dp = off;
for _ in 0..4 {
let p = dp as usize;
let d0 = dst[p] as i32;
let dm1 = dst[p - 1] as i32;
let dp1 = dst[p + 1] as i32;
let dm2 = dst[p - 2] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
if !neg_lossless {
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = p - j as usize - 1;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, bitdepth_max) as u16;
}
}
if !pos_lossless {
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = p + j as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, bitdepth_max) as u16;
}
}
dp += stride_line;
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn deblock_apply_hbd_scalar(
dst: &mut [u16],
off: isize,
stride_line: isize,
stride_tap: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
bitdepth_max: i32,
) {
if stride_tap == 1 {
deblock_apply_hbd_scalar_h(
dst,
off,
stride_line,
width_neg,
width_pos,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
);
return;
}
if neg_lossless && pos_lossless {
return;
}
let wmul_neg = crate::deblock::W_MULT[(width_neg - 1) as usize] as i32;
let wmul_pos = crate::deblock::W_MULT[(width_pos - 1) as usize] as i32;
let mut dp = off;
if !neg_lossless && !pos_lossless {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = (dp + (-(j as isize) - 1) * stride_tap) as usize;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, bitdepth_max) as u16;
}
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = (dp + (j as isize) * stride_tap) as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, bitdepth_max) as u16;
}
dp += stride_line;
}
} else if !neg_lossless {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dn = delta_m2 * wmul_neg;
for j in 0..width_neg {
let idx = (dp + (-(j as isize) - 1) * stride_tap) as usize;
let diff = (dn * (width_neg - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 + diff).clamp(0, bitdepth_max) as u16;
}
dp += stride_line;
}
} else {
for _ in 0..4 {
let d0 = dst[dp as usize] as i32;
let dm1 = dst[(dp - stride_tap) as usize] as i32;
let dp1 = dst[(dp + stride_tap) as usize] as i32;
let dm2 = dst[(dp - 2 * stride_tap) as usize] as i32;
let delta_m2 = (4 * (3 * (d0 - dm1) - (dp1 - dm2))).clamp(-q_thr_clamp, q_thr_clamp);
let dpv = delta_m2 * wmul_pos;
for j in 0..width_pos {
let idx = (dp + (j as isize) * stride_tap) as usize;
let diff = (dpv * (width_pos - j) + (1 << 10)) >> 11;
dst[idx] = (dst[idx] as i32 - diff).clamp(0, bitdepth_max) as u16;
}
dp += stride_line;
}
}
}
#[inline(always)]
fn avg_abs2_i32(a: i32, b: i32) -> u32 {
((a.unsigned_abs() + b.unsigned_abs() + 1) >> 1) as u32
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn filter_choice_hbd(
buf: &[u16],
s: isize,
t: isize,
stride: isize,
max_width_neg: i32,
max_width_pos: i32,
q_thr: u32,
side_thr: u32,
) -> i32 {
let at = |off: isize| -> i32 { buf[off as usize] as i32 };
let second_deriv = |base: isize, dist: i32| -> i32 {
let d = dist as isize;
at(base + (d - 1) * stride) - 2 * at(base + d * stride) + at(base + (d + 1) * stride)
};
let sd_m2 = avg_abs2_i32(second_deriv(s, -2), second_deriv(t, -2));
let sd_m1 = avg_abs2_i32(second_deriv(s, -1), second_deriv(t, -1));
let sd_0 = avg_abs2_i32(second_deriv(s, 0), second_deriv(t, 0));
let sd_1 = avg_abs2_i32(second_deriv(s, 1), second_deriv(t, 1));
let high_deriv = sd_m2.max(sd_1);
if high_deriv > side_thr {
return 0;
}
if max_width_pos == 1 {
return 1;
}
let transition = sd_m1 + sd_0;
if high_deriv > (side_thr >> 2) || transition > q_thr * 4 {
return 1;
}
if high_deriv > (side_thr >> 3) || transition > q_thr * 3 {
return 2;
}
let end_thr = (side_thr * 3) >> 4;
if max_width_neg >= 3 {
let ds = (at(s - stride) - at(s - 4 * stride) - 3 * (at(s - stride) - at(s - 2 * stride)))
.unsigned_abs();
let dt = (at(t - stride) - at(t - 4 * stride) - 3 * (at(t - stride) - at(t - 2 * stride)))
.unsigned_abs();
if ((ds + dt + 1) >> 1) > end_thr {
return 2;
}
}
let ds = (at(s) - at(s + 3 * stride) - 3 * (at(s) - at(s + stride))).unsigned_abs();
let dt = (at(t) - at(t + 3 * stride) - 3 * (at(t) - at(t + stride))).unsigned_abs();
if ((ds + dt + 1) >> 1) > end_thr {
return 2;
}
if max_width_pos == 3 {
return 3;
}
let transition = transition << 4;
let mut prev_dist = 3i32;
let mut dist = 4i32;
while dist <= max_width_pos {
if transition > q_thr * crate::deblock::Q_FIRST[((dist - 4) >> 1) as usize] as u32 {
return prev_dist;
}
let dist2 = dist.min(7);
let end_thr = (side_thr * dist as u32) >> 4;
if max_width_neg >= dist2 {
let ds = (at(s - stride)
- at(s + (-dist2 as isize - 1) * stride)
- dist2 * (at(s - stride) - at(s - 2 * stride)))
.unsigned_abs();
let dt = (at(t - stride)
- at(t + (-dist2 as isize - 1) * stride)
- dist2 * (at(t - stride) - at(t - 2 * stride)))
.unsigned_abs();
if ((ds + dt + 1) >> 1) > end_thr {
return prev_dist;
}
}
let ds = (at(s) - at(s + dist2 as isize * stride) - dist2 * (at(s) - at(s + stride)))
.unsigned_abs();
let dt = (at(t) - at(t + dist2 as isize * stride) - dist2 * (at(t) - at(t + stride)))
.unsigned_abs();
if ((ds + dt + 1) >> 1) > end_thr {
return prev_dist;
}
prev_dist = dist;
dist += 2;
}
max_width_pos
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_hbd_edge(
dst: &mut [u16],
off: isize,
q_thr: u32,
side_thr: u32,
stridea: isize,
strideb: isize,
max_width_pos: i32,
max_width_neg: i32,
pos_lossless: bool,
neg_lossless: bool,
bitdepth_max: i32,
) {
let width = filter_choice_hbd(
dst,
off,
off + 3 * stridea,
strideb,
max_width_neg,
max_width_pos,
q_thr,
side_thr,
);
if width < 1 || (neg_lossless && pos_lossless) {
return;
}
let q_thr_clamp = q_thr as i32 * crate::deblock::Q_THRESH_MULTS[(width - 1) as usize] as i32;
if q_thr_clamp <= 0 {
return;
}
deblock_apply_hbd(
dst,
off,
stridea,
strideb,
width.min(max_width_neg),
width,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
);
}
#[allow(clippy::too_many_arguments, unused)]
#[inline(always)]
pub(crate) fn deblock_hbd_edge_with(
dst: &mut [u16],
off: isize,
q_thr: u32,
side_thr: u32,
stridea: isize,
strideb: isize,
max_width_pos: i32,
max_width_neg: i32,
pos_lossless: bool,
neg_lossless: bool,
bitdepth_max: i32,
apply: DeblockApplyHbdFn,
) {
let width = filter_choice_hbd(
dst,
off,
off + 3 * stridea,
strideb,
max_width_neg,
max_width_pos,
q_thr,
side_thr,
);
if width < 1 || (neg_lossless && pos_lossless) {
return;
}
let q_thr_clamp = q_thr as i32 * crate::deblock::Q_THRESH_MULTS[(width - 1) as usize] as i32;
if q_thr_clamp <= 0 {
return;
}
unsafe {
apply(
dst,
off,
stridea,
strideb,
width.min(max_width_neg),
width,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
);
}
}
#[inline(always)]
fn deblock_mask_class_bits(mask: u16, higher: u16, both_lossless: u16) -> u32 {
(mask & !higher & !both_lossless) as u32
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn deblock_sb64_hbd_mask<
const MAX_WIDTH_NEG: i32,
const MAX_WIDTH_POS: i32,
const HORIZONTAL: bool,
>(
dst: &mut [u16],
dst_off: usize,
stride: usize,
mut vm: u32,
ll_mask: &[u16],
q_thr: &[u8],
side_thr: &[u8],
bitdepth_max: i32,
) {
debug_assert!(MAX_WIDTH_NEG <= MAX_WIDTH_POS);
while vm != 0 {
let qi = vm.trailing_zeros() as usize;
let bit = 1u32 << qi;
let q = q_thr[qi] as u32;
if q != 0 {
let pos_ll = (ll_mask[1] as u32 & bit) != 0;
let neg_ll = (ll_mask[0] as u32 & bit) != 0;
if !(pos_ll && neg_ll) {
let off = if HORIZONTAL {
(dst_off + qi * 4 * stride) as isize
} else {
(dst_off + qi * 4) as isize
};
let stridea = if HORIZONTAL { stride as isize } else { 1 };
let strideb = if HORIZONTAL { 1 } else { stride as isize };
deblock_hbd_edge(
dst,
off,
q,
side_thr[qi] as u32,
stridea,
strideb,
MAX_WIDTH_POS,
MAX_WIDTH_NEG,
pos_ll,
neg_ll,
bitdepth_max,
);
}
}
vm &= vm - 1;
}
}
#[allow(clippy::too_many_arguments)]
#[inline]
pub(crate) fn deblock_h_sb64y_hbd_fast(
dst: &mut [u16],
dst_off: usize,
stride: usize,
vmask: &[u16],
ll_mask: &[u16],
q_thr: &[u8],
side_thr: &[u8],
edge: bool,
bitdepth_max: i32,
) {
let both_lossless = ll_mask[0] & ll_mask[1];
let m3 = deblock_mask_class_bits(vmask[3], 0, both_lossless);
let m2 = deblock_mask_class_bits(vmask[2], vmask[3], both_lossless);
let m1 = deblock_mask_class_bits(vmask[1], vmask[2] | vmask[3], both_lossless);
let m0 = deblock_mask_class_bits(vmask[0], vmask[1] | vmask[2] | vmask[3], both_lossless);
if m0 != 0 {
deblock_sb64_hbd_mask::<1, 1, true>(
dst,
dst_off,
stride,
m0,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m1 != 0 {
deblock_sb64_hbd_mask::<3, 3, true>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m2 != 0 {
deblock_sb64_hbd_mask::<6, 6, true>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m3 != 0 {
if edge {
deblock_sb64_hbd_mask::<6, 8, true>(
dst,
dst_off,
stride,
m3,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<8, 8, true>(
dst,
dst_off,
stride,
m3,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
}
#[allow(clippy::too_many_arguments)]
#[inline]
pub(crate) fn deblock_v_sb64y_hbd_fast(
dst: &mut [u16],
dst_off: usize,
stride: usize,
vmask: &[u16],
ll_mask: &[u16],
q_thr: &[u8],
side_thr: &[u8],
edge: bool,
bitdepth_max: i32,
) {
let both_lossless = ll_mask[0] & ll_mask[1];
let m3 = deblock_mask_class_bits(vmask[3], 0, both_lossless);
let m2 = deblock_mask_class_bits(vmask[2], vmask[3], both_lossless);
let m1 = deblock_mask_class_bits(vmask[1], vmask[2] | vmask[3], both_lossless);
let m0 = deblock_mask_class_bits(vmask[0], vmask[1] | vmask[2] | vmask[3], both_lossless);
if m0 != 0 {
deblock_sb64_hbd_mask::<1, 1, false>(
dst,
dst_off,
stride,
m0,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m1 != 0 {
deblock_sb64_hbd_mask::<3, 3, false>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m2 != 0 {
deblock_sb64_hbd_mask::<6, 6, false>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m3 != 0 {
if edge {
deblock_sb64_hbd_mask::<6, 8, false>(
dst,
dst_off,
stride,
m3,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<8, 8, false>(
dst,
dst_off,
stride,
m3,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
}
#[allow(clippy::too_many_arguments)]
#[inline]
pub(crate) fn deblock_h_sb64uv_hbd_fast(
dst: &mut [u16],
dst_off: usize,
stride: usize,
vmask: &[u16],
ll_mask: &[u16],
q_thr: &[u8],
side_thr: &[u8],
edge: bool,
bitdepth_max: i32,
) {
let both_lossless = ll_mask[0] & ll_mask[1];
let m2 = deblock_mask_class_bits(vmask[2], 0, both_lossless);
let m1 = deblock_mask_class_bits(vmask[1], vmask[2], both_lossless);
let m0 = deblock_mask_class_bits(vmask[0], vmask[1] | vmask[2], both_lossless);
if m0 != 0 {
deblock_sb64_hbd_mask::<1, 1, true>(
dst,
dst_off,
stride,
m0,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m1 != 0 {
if edge {
deblock_sb64_hbd_mask::<2, 3, true>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<3, 3, true>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
if m2 != 0 {
if edge {
deblock_sb64_hbd_mask::<2, 4, true>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<4, 4, true>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
}
#[allow(clippy::too_many_arguments)]
#[inline]
pub(crate) fn deblock_v_sb64uv_hbd_fast(
dst: &mut [u16],
dst_off: usize,
stride: usize,
vmask: &[u16],
ll_mask: &[u16],
q_thr: &[u8],
side_thr: &[u8],
edge: bool,
bitdepth_max: i32,
) {
let both_lossless = ll_mask[0] & ll_mask[1];
let m2 = deblock_mask_class_bits(vmask[2], 0, both_lossless);
let m1 = deblock_mask_class_bits(vmask[1], vmask[2], both_lossless);
let m0 = deblock_mask_class_bits(vmask[0], vmask[1] | vmask[2], both_lossless);
if m0 != 0 {
deblock_sb64_hbd_mask::<1, 1, false>(
dst,
dst_off,
stride,
m0,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
if m1 != 0 {
if edge {
deblock_sb64_hbd_mask::<2, 3, false>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<3, 3, false>(
dst,
dst_off,
stride,
m1,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
if m2 != 0 {
if edge {
deblock_sb64_hbd_mask::<2, 4, false>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
} else {
deblock_sb64_hbd_mask::<4, 4, false>(
dst,
dst_off,
stride,
m2,
ll_mask,
q_thr,
side_thr,
bitdepth_max,
);
}
}
}
static DEBLOCK_APPLY_8BPC: OnceLock<DeblockApply8bpcFn> = OnceLock::new();
static DEBLOCK_APPLY_HBD: OnceLock<DeblockApplyHbdFn> = OnceLock::new();
static DEBLOCK_H_SB64Y_8BPC: OnceLock<Option<DeblockSb64Fn>> = OnceLock::new();
static DEBLOCK_V_SB64Y_8BPC: OnceLock<Option<DeblockSb64Fn>> = OnceLock::new();
static DEBLOCK_H_SB64UV_8BPC: OnceLock<Option<DeblockSb64Fn>> = OnceLock::new();
static DEBLOCK_V_SB64UV_8BPC: OnceLock<Option<DeblockSb64Fn>> = OnceLock::new();
static DEBLOCK_H_SB64Y_HBD: OnceLock<Option<DeblockSb64HbdFn>> = OnceLock::new();
static DEBLOCK_V_SB64Y_HBD: OnceLock<Option<DeblockSb64HbdFn>> = OnceLock::new();
static DEBLOCK_H_SB64UV_HBD: OnceLock<Option<DeblockSb64HbdFn>> = OnceLock::new();
static DEBLOCK_V_SB64UV_HBD: OnceLock<Option<DeblockSb64HbdFn>> = OnceLock::new();
static SETUP_THR_COLS_SEG_8BPC: OnceLock<Option<DeblockSetupColsSeg8bpcFn>> = OnceLock::new();
static SETUP_THR_ROWS_SEG_8BPC: OnceLock<Option<DeblockSetupRowsSeg8bpcFn>> = OnceLock::new();
static SETUP_THR_COLS_DQ_8BPC: OnceLock<Option<DeblockSetupColsDq8bpcFn>> = OnceLock::new();
static SETUP_THR_ROWS_DQ_8BPC: OnceLock<Option<DeblockSetupRowsDq8bpcFn>> = OnceLock::new();
static SETUP_THR_COLS_SIMPLE_8BPC: OnceLock<Option<DeblockSetupSimple8bpcFn>> = OnceLock::new();
static SETUP_THR_ROWS_SIMPLE_8BPC: OnceLock<Option<DeblockSetupSimple8bpcFn>> = OnceLock::new();
#[inline]
pub(crate) fn resolve_deblock_apply_8bpc() -> DeblockApply8bpcFn {
*DEBLOCK_APPLY_8BPC.get_or_init(|| {
let mut _f = deblock_apply_8bpc_scalar as DeblockApply8bpcFn;
#[cfg(target_arch = "aarch64")]
{
_f = crate::neon::deblock_apply_8bpc_neon as DeblockApply8bpcFn;
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = crate::sse::deblock_apply_8bpc_sse41 as DeblockApply8bpcFn;
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = crate::avx::deblock_apply_8bpc_avx2 as DeblockApply8bpcFn;
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_apply_hbd() -> DeblockApplyHbdFn {
*DEBLOCK_APPLY_HBD.get_or_init(|| {
let mut _f = deblock_apply_hbd_scalar as DeblockApplyHbdFn;
#[cfg(target_arch = "aarch64")]
{
_f = crate::neon::deblock_apply_hbd_neon as DeblockApplyHbdFn;
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = crate::sse::deblock_apply_hbd_sse41 as DeblockApplyHbdFn;
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = crate::avx::deblock_apply_hbd_avx2 as DeblockApplyHbdFn;
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_h_sb64y_8bpc() -> Option<DeblockSb64Fn> {
*DEBLOCK_H_SB64Y_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSb64Fn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_h_sb64y_8bpc_neon as DeblockSb64Fn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_h_sb64y_8bpc_sse41 as DeblockSb64Fn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_h_sb64y_8bpc_avx2 as DeblockSb64Fn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_v_sb64y_8bpc() -> Option<DeblockSb64Fn> {
*DEBLOCK_V_SB64Y_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSb64Fn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_v_sb64y_8bpc_neon as DeblockSb64Fn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_v_sb64y_8bpc_sse41 as DeblockSb64Fn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_v_sb64y_8bpc_avx2 as DeblockSb64Fn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_h_sb64uv_8bpc() -> Option<DeblockSb64Fn> {
*DEBLOCK_H_SB64UV_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSb64Fn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_h_sb64uv_8bpc_neon as DeblockSb64Fn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_h_sb64uv_8bpc_sse41 as DeblockSb64Fn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_h_sb64uv_8bpc_avx2 as DeblockSb64Fn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_v_sb64uv_8bpc() -> Option<DeblockSb64Fn> {
*DEBLOCK_V_SB64UV_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSb64Fn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_v_sb64uv_8bpc_neon as DeblockSb64Fn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_v_sb64uv_8bpc_sse41 as DeblockSb64Fn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_v_sb64uv_8bpc_avx2 as DeblockSb64Fn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_h_sb64y_hbd() -> Option<DeblockSb64HbdFn> {
*DEBLOCK_H_SB64Y_HBD.get_or_init(|| {
let mut _f: Option<DeblockSb64HbdFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_h_sb64y_hbd_neon as DeblockSb64HbdFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_h_sb64y_hbd_sse41 as DeblockSb64HbdFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_h_sb64y_hbd_avx2 as DeblockSb64HbdFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_v_sb64y_hbd() -> Option<DeblockSb64HbdFn> {
*DEBLOCK_V_SB64Y_HBD.get_or_init(|| {
let mut _f: Option<DeblockSb64HbdFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_v_sb64y_hbd_neon as DeblockSb64HbdFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_v_sb64y_hbd_sse41 as DeblockSb64HbdFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_v_sb64y_hbd_avx2 as DeblockSb64HbdFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_h_sb64uv_hbd() -> Option<DeblockSb64HbdFn> {
*DEBLOCK_H_SB64UV_HBD.get_or_init(|| {
let mut _f: Option<DeblockSb64HbdFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_h_sb64uv_hbd_neon as DeblockSb64HbdFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_h_sb64uv_hbd_sse41 as DeblockSb64HbdFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_h_sb64uv_hbd_avx2 as DeblockSb64HbdFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_deblock_v_sb64uv_hbd() -> Option<DeblockSb64HbdFn> {
*DEBLOCK_V_SB64UV_HBD.get_or_init(|| {
let mut _f: Option<DeblockSb64HbdFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::deblock_v_sb64uv_hbd_neon as DeblockSb64HbdFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::deblock_v_sb64uv_hbd_sse41 as DeblockSb64HbdFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::deblock_v_sb64uv_hbd_avx2 as DeblockSb64HbdFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_cols_seg_8bpc() -> Option<DeblockSetupColsSeg8bpcFn> {
*SETUP_THR_COLS_SEG_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupColsSeg8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_cols_seg_8bpc_neon as DeblockSetupColsSeg8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_cols_seg_8bpc_sse41 as DeblockSetupColsSeg8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_cols_seg_8bpc_avx2 as DeblockSetupColsSeg8bpcFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_rows_seg_8bpc() -> Option<DeblockSetupRowsSeg8bpcFn> {
*SETUP_THR_ROWS_SEG_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupRowsSeg8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_rows_seg_8bpc_neon as DeblockSetupRowsSeg8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_rows_seg_8bpc_sse41 as DeblockSetupRowsSeg8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_rows_seg_8bpc_avx2 as DeblockSetupRowsSeg8bpcFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_cols_dq_8bpc() -> Option<DeblockSetupColsDq8bpcFn> {
*SETUP_THR_COLS_DQ_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupColsDq8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_cols_dq_8bpc_neon as DeblockSetupColsDq8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_cols_dq_8bpc_sse41 as DeblockSetupColsDq8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_cols_dq_8bpc_avx2 as DeblockSetupColsDq8bpcFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_rows_dq_8bpc() -> Option<DeblockSetupRowsDq8bpcFn> {
*SETUP_THR_ROWS_DQ_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupRowsDq8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_rows_dq_8bpc_neon as DeblockSetupRowsDq8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_rows_dq_8bpc_sse41 as DeblockSetupRowsDq8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_rows_dq_8bpc_avx2 as DeblockSetupRowsDq8bpcFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_cols_simple_8bpc() -> Option<DeblockSetupSimple8bpcFn> {
*SETUP_THR_COLS_SIMPLE_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupSimple8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_cols_simple_8bpc_neon as DeblockSetupSimple8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_cols_simple_8bpc_sse41 as DeblockSetupSimple8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_cols_simple_8bpc_avx2 as DeblockSetupSimple8bpcFn);
}
}
_f
})
}
#[inline]
pub(crate) fn resolve_setup_thr_rows_simple_8bpc() -> Option<DeblockSetupSimple8bpcFn> {
*SETUP_THR_ROWS_SIMPLE_8BPC.get_or_init(|| {
let mut _f: Option<DeblockSetupSimple8bpcFn> = None;
#[cfg(target_arch = "aarch64")]
{
_f = Some(crate::neon::setup_thr_rows_simple_8bpc_neon as DeblockSetupSimple8bpcFn);
}
#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "sse"))]
{
if std::is_x86_feature_detected!("sse4.1") {
_f = Some(crate::sse::setup_thr_rows_simple_8bpc_sse41 as DeblockSetupSimple8bpcFn);
}
}
#[cfg(all(target_arch = "x86_64", feature = "avx"))]
{
if std::is_x86_feature_detected!("avx2") {
_f = Some(crate::avx::setup_thr_rows_simple_8bpc_avx2 as DeblockSetupSimple8bpcFn);
}
}
_f
})
}
#[allow(clippy::too_many_arguments)]
#[inline]
pub(crate) fn deblock_apply_hbd(
dst: &mut [u16],
off: isize,
stride_line: isize,
stride_tap: isize,
width_neg: i32,
width_pos: i32,
q_thr_clamp: i32,
neg_lossless: bool,
pos_lossless: bool,
bitdepth_max: i32,
) {
unsafe {
resolve_deblock_apply_hbd()(
dst,
off,
stride_line,
stride_tap,
width_neg,
width_pos,
q_thr_clamp,
neg_lossless,
pos_lossless,
bitdepth_max,
)
};
}