use crate::primitives::{sa8d_u8, sa8d_u16, satd_u8, satd_u16};
use super::price::x265_sad_lambda;
const ZERO_U8: [u8; 64] = [0; 64];
const ZERO_U16: [u16; 64] = [0; 64];
#[inline]
fn tile_energy_u8(tile: &[u8], stride: usize) -> i64 {
let sa8d = i64::from(sa8d_u8(tile, stride, &ZERO_U8, 8, 8));
let mut sad = 0u64;
for row in tile.chunks(stride).take(8) {
sad += row[..8].iter().map(|&s| u64::from(s)).sum::<u64>();
}
sa8d - (sad >> 2) as i64
}
#[inline]
fn tile_energy_u16(tile: &[u16], stride: usize) -> i64 {
let sa8d = i64::from(sa8d_u16(tile, stride, &ZERO_U16, 8, 8));
let mut sad = 0u64;
for row in tile.chunks(stride).take(8) {
sad += row[..8].iter().map(|&s| u64::from(s)).sum::<u64>();
}
sa8d - (sad >> 2) as i64
}
#[inline]
fn energy_4x4_u8(block: &[u8], stride: usize) -> i64 {
let satd = i64::from(satd_u8(block, stride, &ZERO_U8, 8, 4));
let mut sad = 0u64;
for row in block.chunks(stride).take(4) {
sad += row[..4].iter().map(|&s| u64::from(s)).sum::<u64>();
}
satd - (sad >> 2) as i64
}
#[inline]
fn energy_4x4_u16(block: &[u16], stride: usize) -> i64 {
let satd = i64::from(satd_u16(block, stride, &ZERO_U16, 8, 4));
let mut sad = 0u64;
for row in block.chunks(stride).take(4) {
sad += row[..4].iter().map(|&s| u64::from(s)).sum::<u64>();
}
satd - (sad >> 2) as i64
}
pub(super) fn psy_energy_diff_u8(
src: &[u8],
s_stride: usize,
rec: &[u8],
r_stride: usize,
size: usize,
) -> u64 {
debug_assert!(matches!(size, 4 | 8 | 16 | 32));
if size == 4 {
return energy_4x4_u8(src, s_stride).abs_diff(energy_4x4_u8(rec, r_stride));
}
let mut energy = 0u64;
for y in (0..size).step_by(8) {
for x in (0..size).step_by(8) {
let e_src = tile_energy_u8(&src[y * s_stride + x..], s_stride);
let e_rec = tile_energy_u8(&rec[y * r_stride + x..], r_stride);
energy += e_src.abs_diff(e_rec);
}
}
energy
}
pub(super) fn psy_energy_diff_u16(
src: &[u16],
s_stride: usize,
rec: &[u16],
r_stride: usize,
size: usize,
) -> u64 {
debug_assert!(matches!(size, 4 | 8 | 16 | 32));
if size == 4 {
return energy_4x4_u16(src, s_stride).abs_diff(energy_4x4_u16(rec, r_stride));
}
let mut energy = 0u64;
for y in (0..size).step_by(8) {
for x in (0..size).step_by(8) {
let e_src = tile_energy_u16(&src[y * s_stride + x..], s_stride);
let e_rec = tile_energy_u16(&rec[y * r_stride + x..], r_stride);
energy += e_src.abs_diff(e_rec);
}
}
energy
}
pub(super) fn psy_rd_weight(psy_rd: f32, qp: i32, bit_depth: u8) -> f64 {
let mut factor = f64::from(psy_rd) * 0.33 * (96.0 / 256.0);
if qp >= 40 {
factor *= if qp >= 51 {
0.0
} else {
(51 - qp) as f64 * 23.0 / 256.0
};
}
x265_sad_lambda(qp, bit_depth) * factor
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn flat_blocks_have_zero_energy() {
for size in [8usize, 16, 32] {
let src = vec![128u8; size * size];
let rec = vec![37u8; size * size];
assert_eq!(psy_energy_diff_u8(&src, size, &rec, size, size), 0);
let src16 = vec![512u16; size * size];
let rec16 = vec![100u16; size * size];
assert_eq!(psy_energy_diff_u16(&src16, size, &rec16, size, size), 0);
}
let flat4 = vec![128u8; 16];
assert_eq!(psy_energy_diff_u8(&flat4, 4, &flat4, 4, 4), 0);
let flat4_16 = vec![512u16; 16];
assert_eq!(psy_energy_diff_u16(&flat4_16, 4, &flat4_16, 4, 4), 0);
}
#[test]
fn identical_blocks_have_zero_energy() {
for size in [4usize, 8, 16, 32] {
let src: Vec<u8> = (0..size * size).map(|i| (i * 7 % 251) as u8).collect();
assert_eq!(psy_energy_diff_u8(&src, size, &src, size, size), 0);
}
}
#[test]
fn blurred_recon_of_sharp_source_scores_positive() {
for size in [4usize, 8, 16, 32] {
let src: Vec<u8> = (0..size * size)
.map(|i| {
let (x, y) = (i % size, i / size);
if (x ^ y) & 1 == 0 { 50 } else { 200 }
})
.collect();
let flat = vec![125u8; size * size];
let e = psy_energy_diff_u8(&src, size, &flat, size, size);
assert!(e > 0, "size {size}: blur scored 0");
assert_eq!(e, psy_energy_diff_u8(&flat, size, &src, size, size));
}
}
#[test]
fn u8_and_u16_kernels_match_on_8bit_content() {
for size in [4usize, 8, 16, 32] {
let src: Vec<u8> = (0..size * size).map(|i| (i * 13 % 256) as u8).collect();
let rec: Vec<u8> = (0..size * size).map(|i| (i * 5 % 256) as u8).collect();
let src16: Vec<u16> = src.iter().map(|&v| u16::from(v)).collect();
let rec16: Vec<u16> = rec.iter().map(|&v| u16::from(v)).collect();
assert_eq!(
psy_energy_diff_u8(&src, size, &rec, size, size),
psy_energy_diff_u16(&src16, size, &rec16, size, size),
);
}
}
#[test]
fn tile_wise_abs_does_not_cancel_across_tiles() {
let size = 16usize;
let flat = vec![128u8; size * size];
let mut src = flat.clone();
for y in 0..8 {
for x in 0..8 {
src[y * size + x] = if (x ^ y) & 1 == 0 { 50 } else { 200 };
}
}
let mut rec = flat.clone();
for y in 8..16 {
for x in 8..16 {
rec[y * size + x] = if (x ^ y) & 1 == 0 { 50 } else { 200 };
}
}
let e_src = psy_energy_diff_u8(&src, size, &flat, size, size);
let e_rec = psy_energy_diff_u8(&rec, size, &flat, size, size);
assert_eq!(
psy_energy_diff_u8(&src, size, &rec, size, size),
e_src + e_rec
);
}
#[test]
fn psy_rd_weight_matches_x265_shape() {
let w = psy_rd_weight(2.0, 29, 8);
let expected = x265_sad_lambda(29, 8) * 2.0 * 0.33 * (96.0 / 256.0);
assert!((w - expected).abs() < 1e-12);
assert!((psy_rd_weight(4.0, 29, 8) - 2.0 * w).abs() < 1e-12);
let w45 = psy_rd_weight(2.0, 45, 8);
let base45 = x265_sad_lambda(45, 8) * 2.0 * 0.33 * (96.0 / 256.0);
assert!((w45 - base45 * (6.0 * 23.0 / 256.0)).abs() < 1e-9);
assert_eq!(psy_rd_weight(2.0, 51, 8), 0.0);
assert_eq!(psy_rd_weight(0.0, 29, 8), 0.0);
}
}