use std::vec::Vec;
use super::{
super::{OutOfSequenceRow, PlanGeometry, ResampleError},
FilterAxis,
};
pub(crate) trait FilterSample: crate::row::FilterSimdElem {
const NEEDS_SIMD_STAGING: bool = true;
fn coeffs(axis: &FilterAxis) -> &[f32];
#[cfg_attr(not(tarpaulin), inline(always))]
fn v_span(axis: &FilterAxis, j: usize) -> (usize, &[f32]) {
axis.span(j)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn h_reduce(
row: &[Self],
channels: usize,
h: &FilterAxis,
padded: Option<&crate::row::FilterPaddedSpans>,
h_tmp: &mut [f64],
use_simd: bool,
) {
crate::row::filter_h_reduce_row(
row,
channels,
&h.starts,
&h.offsets,
Self::coeffs(h),
padded,
h_tmp,
use_simd,
);
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn v_accumulate(acc: &mut [f64], h_tmp: &[f64], w: f32, use_simd: bool) {
crate::row::filter_v_accumulate(acc, h_tmp, w, use_simd);
}
fn quantize_intermediate(acc: f64) -> f64;
fn finalize(acc: f64) -> Self;
}
impl FilterSample for u8 {
#[cfg_attr(not(tarpaulin), inline(always))]
fn coeffs(axis: &FilterAxis) -> &[f32] {
&axis.coeffs_q8
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn v_span(axis: &FilterAxis, j: usize) -> (usize, &[f32]) {
axis.span_q8(j)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn quantize_intermediate(acc: f64) -> f64 {
floor_f64_local(acc + 0.5).clamp(0.0, 255.0)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn finalize(acc: f64) -> u8 {
floor_f64_local(acc + 0.5).clamp(0.0, 255.0) as u8
}
}
impl FilterSample for u16 {
#[cfg_attr(not(tarpaulin), inline(always))]
fn coeffs(axis: &FilterAxis) -> &[f32] {
&axis.coeffs
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn quantize_intermediate(acc: f64) -> f64 {
floor_f64_local(acc + 0.5)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn finalize(acc: f64) -> u16 {
floor_f64_local(acc + 0.5).clamp(0.0, 65535.0) as u16
}
}
impl FilterSample for u32 {
const NEEDS_SIMD_STAGING: bool = false;
#[cfg_attr(not(tarpaulin), inline(always))]
fn coeffs(axis: &FilterAxis) -> &[f32] {
&axis.coeffs
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn quantize_intermediate(acc: f64) -> f64 {
floor_f64_local(acc + 0.5)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn finalize(acc: f64) -> u32 {
floor_f64_local(acc + 0.5).clamp(0.0, u32::MAX as f64) as u32
}
}
impl FilterSample for f32 {
#[cfg_attr(not(tarpaulin), inline(always))]
fn coeffs(axis: &FilterAxis) -> &[f32] {
&axis.coeffs
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn quantize_intermediate(acc: f64) -> f64 {
f64::from(acc as f32)
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn finalize(acc: f64) -> f32 {
acc as f32
}
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn floor_f64_local(x: f64) -> f64 {
#[cfg(feature = "std")]
{
f64::floor(x)
}
#[cfg(all(not(feature = "std"), feature = "alloc"))]
{
libm::floor(x)
}
}
#[derive(Debug)]
pub(crate) struct FilterStream<S: FilterSample> {
h: FilterAxis,
v: FilterAxis,
channels: usize,
row_len: usize,
h_tmp: Vec<f64>,
ring: Vec<f64>,
h_padded: Option<crate::row::FilterPaddedSpans>,
ring_cap: usize,
out_tmp: Vec<S>,
cur_out: usize,
next_y: usize,
}
impl<S: FilterSample> FilterStream<S> {
pub(crate) fn new(
h: &FilterAxis,
v: &FilterAxis,
src_w: usize,
src_h: usize,
channels: usize,
) -> Result<Self, ResampleError> {
let geometry = || PlanGeometry::new(src_w, src_h, h.out_len(), v.out_len());
let row_len = h
.out_len()
.checked_mul(channels)
.ok_or_else(|| ResampleError::Overflow(geometry()))?;
let ring_cap = v.max_overlap().max(1);
let ring_len = ring_cap
.checked_mul(row_len)
.ok_or_else(|| ResampleError::Overflow(geometry()))?;
let alloc = |_| ResampleError::AllocationFailed(geometry());
let h = h.try_clone()?;
let v = v.try_clone()?;
let h_padded = if S::NEEDS_SIMD_STAGING {
crate::row::FilterPaddedSpans::build(&h.starts, &h.offsets, S::coeffs(&h))
} else {
None
};
Ok(Self {
h,
v,
channels,
row_len,
h_tmp: try_zeroed_f64(row_len).map_err(alloc)?,
ring: try_zeroed_f64(ring_len).map_err(alloc)?,
ring_cap,
h_padded,
out_tmp: try_zeroed::<S>(row_len).map_err(alloc)?,
cur_out: 0,
next_y: 0,
})
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub(crate) const fn next_y(&self) -> usize {
self.next_y
}
pub(crate) fn reset(&mut self) {
self.ring.fill(0.0);
self.cur_out = 0;
self.next_y = 0;
}
fn h_reduce(&mut self, row: &[S], use_simd: bool) {
S::h_reduce(
row,
self.channels,
&self.h,
self.h_padded.as_ref(),
&mut self.h_tmp,
use_simd,
);
for t in &mut self.h_tmp {
*t = S::quantize_intermediate(*t);
}
}
pub(crate) fn feed_row(
&mut self,
y: usize,
row: &[S],
use_simd: bool,
mut emit: impl FnMut(usize, &[S]),
) -> Result<(), ResampleError> {
if y != self.next_y {
return Err(ResampleError::OutOfSequenceRow(OutOfSequenceRow::new(
self.next_y,
y,
)));
}
self.next_y += 1;
let out_h = self.v.out_len();
if self.cur_out >= out_h {
return Ok(());
}
self.h_reduce(row, use_simd);
let mut oy = self.cur_out;
while oy < out_h {
let (vstart, vcoeffs) = S::v_span(&self.v, oy);
if vstart > y {
break;
}
let idx = y - vstart;
let Some(&w) = vcoeffs.get(idx) else {
oy += 1;
continue;
};
let slot = (oy % self.ring_cap) * self.row_len;
let acc_row = &mut self.ring[slot..slot + self.row_len];
S::v_accumulate(acc_row, &self.h_tmp, w, use_simd);
oy += 1;
}
while self.cur_out < out_h {
let (vstart, vcoeffs) = S::v_span(&self.v, self.cur_out);
let last = vstart + vcoeffs.len();
if vstart > y || last == 0 || last - 1 != y {
break;
}
let slot = (self.cur_out % self.ring_cap) * self.row_len;
{
let acc_row = &mut self.ring[slot..slot + self.row_len];
for (o, a) in self.out_tmp.iter_mut().zip(acc_row.iter_mut()) {
*o = S::finalize(*a);
*a = 0.0;
}
}
emit(self.cur_out, &self.out_tmp);
self.cur_out += 1;
}
Ok(())
}
}
fn try_zeroed_f64(n: usize) -> Result<Vec<f64>, std::collections::TryReserveError> {
let mut buf = Vec::new();
buf.try_reserve_exact(n)?;
buf.resize(n, 0.0);
Ok(buf)
}
fn try_zeroed<S: Copy + Default>(n: usize) -> Result<Vec<S>, std::collections::TryReserveError> {
let mut buf = Vec::new();
buf.try_reserve_exact(n)?;
buf.resize(n, S::default());
Ok(buf)
}