use super::{
GeometryOverflow, InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange,
RowShapeMismatch, RowSlice, check_dimensions_match, check_frozen_alpha_mode,
frozen_outputs_check, packed_rgba_resample, packed_rgba_u16_resample,
packed_yuva444_filter_resample, rgb_row_buf_or_scratch, rgba_plane_row_slice,
rgba_u16_plane_row_slice, source_luma_u16_scratch, source_luma_u32_scratch,
};
use crate::{
PixelSink,
resample::{AreaStream, ResampleError, ResamplePlan},
row::{
expand_rgb_to_rgba_row, expand_rgb_u16_to_rgba_u16_row, gray_n_to_hsv_row, gray_n_to_luma_row,
gray_n_to_luma_u16_row, gray_n_to_rgb_row, gray_n_to_rgb_u16_row, gray_n_to_rgba_row,
gray_n_to_rgba_u16_row, gray8_to_hsv_row, gray8_to_rgb_row, gray8_to_rgba_row,
gray16_to_hsv_row, gray16_to_luma_row, gray16_to_luma_u16_row, gray16_to_rgb_row,
gray16_to_rgb_u16_row, gray16_to_rgba_row, gray16_to_rgba_u16_row, gray32_to_hsv_row,
gray32_to_luma_row, gray32_to_luma_u16_row, gray32_to_rgb_row, gray32_to_rgb_u16_row,
gray32_to_rgba_row, gray32_to_rgba_u16_row, grayf16_to_hsv_row, grayf16_to_luma_f32_row,
grayf16_to_luma_row, grayf16_to_luma_u16_row, grayf16_to_rgb_f32_row, grayf16_to_rgb_row,
grayf16_to_rgb_u16_row, grayf16_to_rgba_row, grayf16_to_rgba_u16_row, grayf32_to_hsv_row,
grayf32_to_luma_f32_row, grayf32_to_luma_row, grayf32_to_luma_u16_row, grayf32_to_rgb_f32_row,
grayf32_to_rgb_row, grayf32_to_rgb_u16_row, grayf32_to_rgba_row, grayf32_to_rgba_u16_row,
rgb_to_hsv_row,
scalar::alpha_extract::{copy_alpha_ya_u8, copy_alpha_ya_u16, copy_alpha_ya_u16_to_u8},
y_plane_to_luma_u16_row, ya8_to_hsv_row, ya8_to_luma_row, ya8_to_luma_u16_row, ya8_to_rgb_row,
ya8_to_rgb_u16_row, ya8_to_rgba_row, ya8_to_rgba_u16_row, ya16_to_hsv_row, ya16_to_luma_row,
ya16_to_luma_u16_row, ya16_to_rgb_row, ya16_to_rgb_u16_row, ya16_to_rgba_row,
ya16_to_rgba_u16_row, yaf16_to_hsv_row, yaf16_to_luma_f32_row, yaf16_to_luma_row,
yaf16_to_luma_u16_row, yaf16_to_rgb_f32_row, yaf16_to_rgb_row, yaf16_to_rgb_u16_row,
yaf16_to_rgba_row, yaf16_to_rgba_u16_row, yaf32_to_hsv_row, yaf32_to_luma_f32_row,
yaf32_to_luma_row, yaf32_to_luma_u16_row, yaf32_to_rgb_f32_row, yaf32_to_rgb_row,
yaf32_to_rgb_u16_row, yaf32_to_rgba_row, yaf32_to_rgba_u16_row,
},
source::{
Gray8, Gray8Row, Gray8Sink, Gray16, Gray16Row, Gray16Sink, Gray32, Gray32Row, Gray32Sink,
Grayf16, Grayf16Row, Grayf16Sink, Grayf32, Grayf32Row, Grayf32Sink, Ya8, Ya8Row, Ya8Sink, Ya16,
Ya16Row, Ya16Sink, Yaf16, Yaf16Row, Yaf16Sink, Yaf32, Yaf32Row, Yaf32Sink,
},
};
impl<'a, R> MixedSinker<'a, Gray8, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R> Gray8Sink for MixedSinker<'_, Gray8, R> {}
impl<R> PixelSink for MixedSinker<'_, Gray8, R> {
type Input<'r> = Gray8Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Gray8Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
luma_stream,
luma_filter_stream,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
let full_range = row.full_range();
return gray8_process_resampled(
luma_stream,
luma_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
plan,
idx,
use_simd,
full_range,
);
}
let y_plane = row.y();
let full_range = row.full_range();
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
if want_hsv && want_rgba && !want_rgb {
rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
}
if let Some(buf) = luma.as_deref_mut() {
buf[one_plane_start..one_plane_end].copy_from_slice(y_plane);
}
if let Some(buf) = luma_u16.as_deref_mut() {
y_plane_to_luma_u16_row(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
gray8_to_rgba_row(y_plane, rgba_row, w, use_simd, full_range);
return Ok(());
}
if want_hsv && !want_rgb && !want_rgba {
let hsv = hsv.as_mut().unwrap();
let (h, s, v) = hsv.hsv();
gray8_to_hsv_row(
y_plane,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
full_range,
);
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
gray8_to_rgb_row(y_plane, rgb_row, w, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn gray8_process_resampled(
luma_stream: &mut Option<std::boxed::Box<AreaStream<u8>>>,
luma_filter_stream: &mut Option<std::boxed::Box<crate::resample::FilterStream<u8>>>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgba: &mut Option<&mut [u8]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
rgb_scratch: &mut std::vec::Vec<u8>,
y_row: &[u8],
plan: &ResamplePlan,
idx: usize,
use_simd: bool,
full_range: bool,
) -> Result<(), MixedSinkerError> {
let ow = plan.out_w();
super::gray_luma_resample::<u8>(
luma_stream,
luma_filter_stream,
resample_outputs,
rgb,
rgba,
&mut None,
&mut None,
luma,
luma_u16,
&mut None,
&mut None,
hsv,
plan,
idx,
|stream, rgb, rgba, _rgb_u16, _rgba_u16, luma, luma_u16, _rgb_f32, _luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb || (want_hsv && want_rgba);
if need_rgb_kernel && !want_rgb {
rgb_row_buf_or_scratch(None, rgb_scratch, 0, ow, ow, plan.out_h())?;
}
let Some(stream) = stream else {
return Ok(());
};
let mut emit = |oy: usize, binned_y: &[u8]| {
if let Some(buf) = luma.as_deref_mut() {
buf[oy * ow..(oy + 1) * ow].copy_from_slice(binned_y);
}
if let Some(buf) = luma_u16.as_deref_mut() {
y_plane_to_luma_u16_row(binned_y, &mut buf[oy * ow..(oy + 1) * ow], ow, use_simd);
}
if want_rgba && !want_rgb && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
gray8_to_rgba_row(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
return;
}
if want_hsv && !want_rgb && !want_rgba {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray8_to_hsv_row(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
full_range,
);
return;
}
if !need_rgb_kernel {
return;
}
if let Some(buf) = rgb.as_deref_mut() {
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray8_to_rgb_row(binned_y, rgb_row, ow, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
} else {
let rgb_row = &mut rgb_scratch[..ow * 3];
gray8_to_rgb_row(binned_y, rgb_row, ow, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, y_row, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, y_row, use_simd, &mut emit),
}?;
Ok(())
},
)
}
#[allow(clippy::too_many_arguments)]
#[inline(always)]
fn process_gray_n<'a, const BITS: u32, const BE: bool>(
w: usize,
h: usize,
idx: usize,
use_simd: bool,
full_range: bool,
y_plane: &[u16],
rgb: &mut Option<&'a mut [u8]>,
rgb_u16: &mut Option<&'a mut [u16]>,
rgba: &mut Option<&'a mut [u8]>,
rgba_u16: &mut Option<&'a mut [u16]>,
luma: &mut Option<&'a mut [u8]>,
luma_u16: &mut Option<&'a mut [u16]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'a>>,
rgb_scratch: &mut std::vec::Vec<u8>,
) -> Result<(), MixedSinkerError> {
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
if want_hsv && want_rgba && !want_rgb {
rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
}
if let Some(buf) = luma.as_deref_mut() {
gray_n_to_luma_row::<BITS, BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
gray_n_to_luma_u16_row::<BITS, BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
gray_n_to_rgba_u16_row::<BITS, BE>(y_plane, rgba_u16_row, w, use_simd, full_range);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
gray_n_to_rgb_u16_row::<BITS, BE>(y_plane, rgb_u16_row, w, use_simd, full_range);
if want_rgba_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<BITS>(rgb_u16_row, rgba_u16_row, w);
}
}
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
gray_n_to_rgba_row::<BITS, BE>(y_plane, rgba_row, w, use_simd, full_range);
return Ok(());
}
if want_hsv && !want_rgb && !want_rgba {
let hsv = hsv.as_mut().unwrap();
let (h, s, v) = hsv.hsv();
gray_n_to_hsv_row::<BITS, BE>(
y_plane,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
full_range,
);
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
gray_n_to_rgb_row::<BITS, BE>(y_plane, rgb_row, w, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
#[inline(always)]
fn check_gray_n_row_shape(
y_len: usize,
w: usize,
idx: usize,
h: usize,
) -> Result<(), MixedSinkerError> {
if y_len != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
y_len,
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
Ok(())
}
macro_rules! impl_gray_n_sinker {
($marker:ident, $row:ident, $sink:ident, $bits:expr) => {
impl<'a, R, const BE: bool> MixedSinker<'a, $marker<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> $sink<BE> for MixedSinker<'_, $marker<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, $marker<BE>, R> {
type Input<'r> = $row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_u16.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: $row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let use_simd = self.simd;
let idx = row.row();
let full_range = row.full_range();
check_gray_n_row_shape(row.y().len(), w, idx, h)?;
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
luma_stream_u16,
luma_filter_stream_u16,
luma_scratch_u16,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
return gray_n_process_resampled::<$bits, BE>(
luma_stream_u16,
luma_filter_stream_u16,
luma_scratch_u16,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
row.y(),
plan,
w,
idx,
use_simd,
full_range,
);
}
process_gray_n::<$bits, BE>(
w,
h,
idx,
use_simd,
full_range,
row.y(),
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
)
}
}
};
}
use crate::source::{
Gray9, Gray9Row, Gray9Sink, Gray10, Gray10Row, Gray10Sink, Gray12, Gray12Row, Gray12Sink, Gray14,
Gray14Row, Gray14Sink,
};
impl_gray_n_sinker!(Gray9, Gray9Row, Gray9Sink, 9);
impl_gray_n_sinker!(Gray10, Gray10Row, Gray10Sink, 10);
impl_gray_n_sinker!(Gray12, Gray12Row, Gray12Sink, 12);
impl_gray_n_sinker!(Gray14, Gray14Row, Gray14Sink, 14);
#[allow(clippy::too_many_arguments)]
fn gray_n_process_resampled<'a, const BITS: u32, const BE: bool>(
luma_stream_u16: &mut Option<std::boxed::Box<AreaStream<u16>>>,
luma_filter_stream_u16: &mut Option<std::boxed::Box<crate::resample::FilterStream<u16>>>,
luma_scratch_u16: &mut std::vec::Vec<u16>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&'a mut [u8]>,
rgb_u16: &mut Option<&'a mut [u16]>,
rgba: &mut Option<&'a mut [u8]>,
rgba_u16: &mut Option<&'a mut [u16]>,
luma: &mut Option<&'a mut [u8]>,
luma_u16: &mut Option<&'a mut [u16]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'a>>,
y_row: &[u16],
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
full_range: bool,
) -> Result<(), MixedSinkerError> {
const { assert!(BITS < 16, "GrayN carries fewer than 16 active bits") };
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
let native_max: u16 = ((1u32 << BITS) - 1) as u16;
let ow = plan.out_w();
super::gray_luma_resample::<u16>(
luma_stream_u16,
luma_filter_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
&mut None,
&mut None,
hsv,
plan,
idx,
|stream, rgb, rgba, rgb_u16, rgba_u16, luma, luma_u16, _rgb_f32, _luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
let src_len = w;
let clamp_len = ow;
if luma_scratch_u16.len() < src_len + clamp_len {
let extra = src_len + clamp_len - luma_scratch_u16.len();
luma_scratch_u16.try_reserve_exact(extra).map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
luma_scratch_u16.resize(src_len + clamp_len, 0);
}
let Some(stream) = stream else {
return Ok(());
};
let (src_luma, clamp_scratch) = luma_scratch_u16.split_at_mut(src_len);
let src_luma = &mut src_luma[..src_len];
let clamp_scratch = &mut clamp_scratch[..clamp_len];
gray_n_to_luma_u16_row::<BITS, BE>(y_row, src_luma, w, use_simd);
let src_luma: &[u16] = src_luma;
let mut emit = |oy: usize, resampled_y: &[u16]| {
let binned_y = &mut clamp_scratch[..ow];
for (d, &s) in binned_y.iter_mut().zip(resampled_y.iter()) {
*d = s.min(native_max);
}
let binned_y: &[u16] = binned_y;
if let Some(buf) = luma_u16.as_deref_mut() {
gray_n_to_luma_u16_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
gray_n_to_luma_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
gray_n_to_rgba_u16_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_u16_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray_n_to_rgb_u16_row::<BITS, HOST_NATIVE_BE>(
binned_y,
rgb_u16_row,
ow,
use_simd,
full_range,
);
if let Some(buf) = rgba_u16.as_deref_mut() {
expand_rgb_u16_to_rgba_u16_row::<BITS>(
rgb_u16_row,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
gray_n_to_rgba_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray_n_to_hsv_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
full_range,
);
if let Some(buf) = rgba.as_deref_mut() {
gray_n_to_rgba_row::<BITS, HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray_n_to_rgb_row::<BITS, HOST_NATIVE_BE>(binned_y, rgb_row, ow, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
}?;
Ok(())
},
)
}
impl<'a, R, const BE: bool> MixedSinker<'a, Gray16<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Gray16Sink<BE> for MixedSinker<'_, Gray16<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Gray16<BE>, R> {
type Input<'r> = Gray16Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_u16.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Gray16Row<'_>) -> Result<(), Self::Error> {
const BITS: u32 = 16;
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let full_range = row.full_range();
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
luma_stream_u16,
luma_filter_stream_u16,
luma_scratch_u16,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
return gray16_process_resampled::<BE>(
luma_stream_u16,
luma_filter_stream_u16,
luma_scratch_u16,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
row.y(),
plan,
w,
idx,
use_simd,
full_range,
);
}
let y_plane = row.y();
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = luma.as_deref_mut() {
gray16_to_luma_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
gray16_to_luma_u16_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
gray16_to_rgba_u16_row::<BE>(y_plane, rgba_u16_row, w, use_simd, full_range);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
gray16_to_rgb_u16_row::<BE>(y_plane, rgb_u16_row, w, use_simd, full_range);
if want_rgba_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<BITS>(rgb_u16_row, rgba_u16_row, w);
}
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb || (want_hsv && want_rgba);
if want_rgba && !need_rgb_kernel && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
gray16_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd, full_range);
return Ok(());
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray16_to_hsv_row::<BE>(
y_plane,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
full_range,
);
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
gray16_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd, full_range);
}
return Ok(());
}
if !need_rgb_kernel {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
gray16_to_rgb_row::<BE>(y_plane, rgb_row, w, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn gray16_process_resampled<const BE: bool>(
luma_stream_u16: &mut Option<std::boxed::Box<AreaStream<u16>>>,
luma_filter_stream_u16: &mut Option<std::boxed::Box<crate::resample::FilterStream<u16>>>,
luma_scratch_u16: &mut std::vec::Vec<u16>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba: &mut Option<&mut [u8]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
y_row: &[u16],
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
full_range: bool,
) -> Result<(), MixedSinkerError> {
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
let ow = plan.out_w();
super::gray_luma_resample::<u16>(
luma_stream_u16,
luma_filter_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
&mut None,
&mut None,
hsv,
plan,
idx,
|stream, rgb, rgba, rgb_u16, rgba_u16, luma, luma_u16, _rgb_f32, _luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
let src_luma = source_luma_u16_scratch(luma_scratch_u16, w, plan)?;
let Some(stream) = stream else {
return Ok(());
};
gray16_to_luma_u16_row::<BE>(y_row, src_luma, w, use_simd);
let src_luma: &[u16] = src_luma;
let mut emit = |oy: usize, binned_y: &[u16]| {
if let Some(buf) = luma_u16.as_deref_mut() {
gray16_to_luma_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
gray16_to_luma_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
gray16_to_rgba_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_u16_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray16_to_rgb_u16_row::<HOST_NATIVE_BE>(binned_y, rgb_u16_row, ow, use_simd, full_range);
if let Some(buf) = rgba_u16.as_deref_mut() {
expand_rgb_u16_to_rgba_u16_row::<16>(
rgb_u16_row,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
gray16_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray16_to_hsv_row::<HOST_NATIVE_BE>(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
full_range,
);
if let Some(buf) = rgba.as_deref_mut() {
gray16_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray16_to_rgb_row::<HOST_NATIVE_BE>(binned_y, rgb_row, ow, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
}?;
Ok(())
},
)
}
impl<'a, R, const BE: bool> MixedSinker<'a, Gray32<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Gray32Sink<BE> for MixedSinker<'_, Gray32<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Gray32<BE>, R> {
type Input<'r> = Gray32Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream_u32.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_u32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Gray32Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let full_range = row.full_range();
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
luma_stream_u32,
luma_filter_stream_u32,
luma_scratch_u32,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
return gray32_process_resampled::<BE>(
luma_stream_u32,
luma_filter_stream_u32,
luma_scratch_u32,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
row.y(),
plan,
w,
idx,
use_simd,
full_range,
);
}
let y_plane = row.y();
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = luma.as_deref_mut() {
gray32_to_luma_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
gray32_to_luma_u16_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
gray32_to_rgba_u16_row::<BE>(y_plane, rgba_u16_row, w, use_simd, full_range);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
gray32_to_rgb_u16_row::<BE>(y_plane, rgb_u16_row, w, use_simd, full_range);
if want_rgba_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<16>(rgb_u16_row, rgba_u16_row, w);
}
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb || (want_hsv && want_rgba);
if want_rgba && !need_rgb_kernel && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
gray32_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd, full_range);
return Ok(());
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray32_to_hsv_row::<BE>(
y_plane,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
full_range,
);
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
gray32_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd, full_range);
}
return Ok(());
}
if !need_rgb_kernel {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
gray32_to_rgb_row::<BE>(y_plane, rgb_row, w, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn gray32_process_resampled<const BE: bool>(
luma_stream_u32: &mut Option<std::boxed::Box<AreaStream<u32>>>,
luma_filter_stream_u32: &mut Option<std::boxed::Box<crate::resample::FilterStream<u32>>>,
luma_scratch_u32: &mut std::vec::Vec<u32>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba: &mut Option<&mut [u8]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
y_row: &[u32],
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
full_range: bool,
) -> Result<(), MixedSinkerError> {
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
let ow = plan.out_w();
super::gray_luma_resample::<u32>(
luma_stream_u32,
luma_filter_stream_u32,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
&mut None,
&mut None,
hsv,
plan,
idx,
|stream, rgb, rgba, rgb_u16, rgba_u16, luma, luma_u16, _rgb_f32, _luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
let src_luma = source_luma_u32_scratch(luma_scratch_u32, w, plan)?;
let Some(stream) = stream else {
return Ok(());
};
crate::row::scalar::gray::gray32_to_native_u32_row::<BE>(y_row, src_luma, w);
let src_luma: &[u32] = src_luma;
let mut emit = |oy: usize, binned_y: &[u32]| {
if let Some(buf) = luma_u16.as_deref_mut() {
gray32_to_luma_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
gray32_to_luma_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
gray32_to_rgba_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_u16_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray32_to_rgb_u16_row::<HOST_NATIVE_BE>(binned_y, rgb_u16_row, ow, use_simd, full_range);
if let Some(buf) = rgba_u16.as_deref_mut() {
expand_rgb_u16_to_rgba_u16_row::<16>(
rgb_u16_row,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
gray32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
gray32_to_hsv_row::<HOST_NATIVE_BE>(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
full_range,
);
if let Some(buf) = rgba.as_deref_mut() {
gray32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
full_range,
);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
gray32_to_rgb_row::<HOST_NATIVE_BE>(binned_y, rgb_row, ow, use_simd, full_range);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
}?;
Ok(())
},
)
}
impl<'a, R, const BE: bool> MixedSinker<'a, Grayf32<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f32 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_luma_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(1)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_f32 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Grayf32Sink<BE> for MixedSinker<'_, Grayf32<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Grayf32<BE>, R> {
type Input<'r> = Grayf32Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Grayf32Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
rgb_scratch,
plan,
luma_stream_f32,
luma_filter_stream_f32,
luma_scratch_f32,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
return grayf32_process_resampled::<BE>(
luma_stream_f32,
luma_filter_stream_f32,
luma_scratch_f32,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
row.y(),
plan,
w,
idx,
use_simd,
);
}
let y_plane = row.y();
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = luma_f32.as_deref_mut() {
grayf32_to_luma_f32_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
let rgb_f32_start = one_plane_start * 3;
let rgb_f32_end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
grayf32_to_rgb_f32_row::<BE>(y_plane, &mut buf[rgb_f32_start..rgb_f32_end], w, use_simd);
}
if let Some(buf) = luma.as_deref_mut() {
grayf32_to_luma_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
grayf32_to_luma_u16_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
grayf32_to_rgba_u16_row::<BE>(y_plane, rgba_u16_row, w, use_simd);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
grayf32_to_rgb_u16_row::<BE>(y_plane, rgb_u16_row, w, use_simd);
if want_rgba_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<16>(rgb_u16_row, rgba_u16_row, w);
}
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
grayf32_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd);
return Ok(());
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
grayf32_to_hsv_row::<BE>(
y_plane,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
grayf32_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd);
}
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
grayf32_to_rgb_row::<BE>(y_plane, rgb_row, w, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn grayf32_process_resampled<const BE: bool>(
luma_stream_f32: &mut Option<std::boxed::Box<AreaStream<f32>>>,
luma_filter_stream_f32: &mut Option<std::boxed::Box<crate::resample::FilterStream<f32>>>,
luma_scratch_f32: &mut std::vec::Vec<f32>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba: &mut Option<&mut [u8]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
rgb_f32: &mut Option<&mut [f32]>,
luma_f32: &mut Option<&mut [f32]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
y_row: &[f32],
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
let ow = plan.out_w();
super::gray_luma_resample::<f32>(
luma_stream_f32,
luma_filter_stream_f32,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
plan,
idx,
|stream, rgb, rgba, rgb_u16, rgba_u16, luma, luma_u16, rgb_f32, luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
if luma_scratch_f32.len() < w {
luma_scratch_f32
.try_reserve_exact(w - luma_scratch_f32.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
luma_scratch_f32.resize(w, 0.0);
}
let Some(stream) = stream else {
return Ok(());
};
let src_luma = &mut luma_scratch_f32[..w];
grayf32_to_luma_f32_row::<BE>(y_row, src_luma, w, use_simd);
let src_luma: &[f32] = src_luma;
let mut emit = |oy: usize, binned_y: &[f32]| {
if let Some(buf) = luma_f32.as_deref_mut() {
grayf32_to_luma_f32_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
grayf32_to_rgb_f32_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
grayf32_to_luma_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
grayf32_to_luma_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
grayf32_to_rgba_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_u16_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
grayf32_to_rgb_u16_row::<HOST_NATIVE_BE>(binned_y, rgb_u16_row, ow, use_simd);
if let Some(buf) = rgba_u16.as_deref_mut() {
expand_rgb_u16_to_rgba_u16_row::<16>(
rgb_u16_row,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
grayf32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
grayf32_to_hsv_row::<HOST_NATIVE_BE>(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
grayf32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
grayf32_to_rgb_row::<HOST_NATIVE_BE>(binned_y, rgb_row, ow, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
}?;
Ok(())
},
)
}
impl<'a, R, const BE: bool> MixedSinker<'a, Grayf16<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f32 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_luma_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(1)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_f32 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Grayf16Sink<BE> for MixedSinker<'_, Grayf16<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Grayf16<BE>, R> {
type Input<'r> = Grayf16Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.luma_stream_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Grayf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
rgb_scratch,
plan,
luma_stream_f32,
luma_filter_stream_f32,
luma_scratch_f32,
resample_outputs,
..
} = self;
if let Some(plan) = plan.as_ref() {
return grayf16_process_resampled::<BE>(
luma_stream_f32,
luma_filter_stream_f32,
luma_scratch_f32,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
row.y(),
plan,
w,
idx,
use_simd,
);
}
let y_plane = row.y();
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = luma_f32.as_deref_mut() {
grayf16_to_luma_f32_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
let rgb_f32_start = one_plane_start * 3;
let rgb_f32_end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
grayf16_to_rgb_f32_row::<BE>(y_plane, &mut buf[rgb_f32_start..rgb_f32_end], w, use_simd);
}
if let Some(buf) = luma.as_deref_mut() {
grayf16_to_luma_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
grayf16_to_luma_u16_row::<BE>(
y_plane,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
grayf16_to_rgba_u16_row::<BE>(y_plane, rgba_u16_row, w, use_simd);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
grayf16_to_rgb_u16_row::<BE>(y_plane, rgb_u16_row, w, use_simd);
if want_rgba_u16 {
let rgba_u16_buf = rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<16>(rgb_u16_row, rgba_u16_row, w);
}
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
grayf16_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd);
return Ok(());
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
grayf16_to_hsv_row::<BE>(
y_plane,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
grayf16_to_rgba_row::<BE>(y_plane, rgba_row, w, use_simd);
}
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
grayf16_to_rgb_row::<BE>(y_plane, rgb_row, w, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
fn grayf16_process_resampled<const BE: bool>(
luma_stream_f32: &mut Option<std::boxed::Box<AreaStream<f32>>>,
luma_filter_stream_f32: &mut Option<std::boxed::Box<crate::resample::FilterStream<f32>>>,
luma_scratch_f32: &mut std::vec::Vec<f32>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba: &mut Option<&mut [u8]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
rgb_f32: &mut Option<&mut [f32]>,
luma_f32: &mut Option<&mut [f32]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
y_row: &[half::f16],
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
let ow = plan.out_w();
super::gray_luma_resample::<f32>(
luma_stream_f32,
luma_filter_stream_f32,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
plan,
idx,
|stream, rgb, rgba, rgb_u16, rgba_u16, luma, luma_u16, rgb_f32, luma_f32, hsv| {
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
if luma_scratch_f32.len() < w {
luma_scratch_f32
.try_reserve_exact(w - luma_scratch_f32.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
luma_scratch_f32.resize(w, 0.0);
}
let Some(stream) = stream else {
return Ok(());
};
let src_luma = &mut luma_scratch_f32[..w];
grayf16_to_luma_f32_row::<BE>(y_row, src_luma, w, use_simd);
let src_luma: &[f32] = src_luma;
let mut emit = |oy: usize, binned_y: &[f32]| {
if let Some(buf) = luma_f32.as_deref_mut() {
grayf32_to_luma_f32_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
grayf32_to_rgb_f32_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
grayf32_to_luma_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
grayf32_to_luma_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
grayf32_to_rgba_u16_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_u16_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
grayf32_to_rgb_u16_row::<HOST_NATIVE_BE>(binned_y, rgb_u16_row, ow, use_simd);
if let Some(buf) = rgba_u16.as_deref_mut() {
expand_rgb_u16_to_rgba_u16_row::<16>(
rgb_u16_row,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
grayf32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
grayf32_to_hsv_row::<HOST_NATIVE_BE>(
binned_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
grayf32_to_rgba_row::<HOST_NATIVE_BE>(
binned_y,
&mut buf[oy * 4 * ow..(oy + 1) * 4 * ow],
ow,
use_simd,
);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
grayf32_to_rgb_row::<HOST_NATIVE_BE>(binned_y, rgb_row, ow, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
expand_rgb_to_rgba_row(rgb_row, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow);
}
};
match stream {
super::GrayLumaStreamMut::Area(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
super::GrayLumaStreamMut::Filter(s) => s.feed_row(idx, src_luma, use_simd, &mut emit),
}?;
Ok(())
},
)
}
impl<'a, R> MixedSinker<'a, Ya8, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R> Ya8Sink for MixedSinker<'_, Ya8, R> {}
impl<R> PixelSink for MixedSinker<'_, Ya8, R> {
type Input<'r> = Ya8Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.rgba_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgba_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgba_filter_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
self.resample_outputs = None;
self.frozen_alpha_mode = Some(self.alpha_mode);
Ok(())
}
fn process(&mut self, row: Ya8Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let packed = row.packed();
if packed.len() != w * 2 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w * 2,
packed.len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
if self.plan.is_some() {
let alpha_mode = self.alpha_mode;
let matrix = row.matrix();
let full_range = row.full_range();
let Self {
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch,
rgb_scratch,
luma_scratch,
rgba_scratch_u16,
rgba_color_scratch_u16,
luma_scratch_u16,
plan,
rgba_stream,
luma_stream,
rgba_filter_stream,
rgba_filter_stream_u16,
luma_filter_stream,
luma_filter_stream_u16,
resample_outputs,
frozen_alpha_mode,
..
} = self;
let plan = plan.as_ref().expect("plan.is_some() checked above");
check_frozen_alpha_mode(*frozen_alpha_mode, alpha_mode, idx)?;
return match plan.kind() {
crate::resample::SpanKind::Area => packed_rgba_resample::<true>(
rgba_stream,
luma_stream,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch,
rgb_scratch,
luma_scratch,
w,
plan,
idx,
use_simd,
alpha_mode,
matrix,
full_range,
|dst| ya8_to_rgba_row(packed, dst, w, use_simd),
|dst| ya8_to_luma_row(packed, dst, w, use_simd),
),
crate::resample::SpanKind::Filter if alpha_mode.is_premultiplied() => {
packed_rgba_resample::<true>(
rgba_stream,
luma_stream,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch,
rgb_scratch,
luma_scratch,
w,
plan,
idx,
use_simd,
alpha_mode,
matrix,
full_range,
|dst| ya8_to_rgba_row(packed, dst, w, use_simd),
|dst| ya8_to_luma_row(packed, dst, w, use_simd),
)
}
crate::resample::SpanKind::Filter => packed_yuva444_filter_resample::<8, true, true>(
rgba_filter_stream,
rgba_filter_stream_u16,
luma_filter_stream,
luma_filter_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch,
rgb_scratch,
rgba_scratch_u16,
rgba_color_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
&[],
Some(luma_scratch),
|dst| ya8_to_rgba_row(packed, dst, w, use_simd),
|_dst: &mut [u16]| {},
|_dst: &mut [u16]| {},
|dst| ya8_to_luma_row(packed, dst, w, use_simd),
),
};
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let want_rgb = self.rgb.is_some();
let want_rgba = self.rgba.is_some();
let want_hsv = self.hsv.is_some();
if want_hsv && want_rgba && !want_rgb {
rgb_row_buf_or_scratch(
self.rgb.as_deref_mut(),
&mut self.rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
}
if let Some(buf) = self.luma.as_deref_mut() {
ya8_to_luma_row(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.luma_u16.as_deref_mut() {
ya8_to_luma_u16_row(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.rgb_u16.as_deref_mut() {
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
ya8_to_rgb_u16_row(
packed,
&mut buf[rgb_plane_start..rgb_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.rgba_u16.as_deref_mut() {
let rgba_u16_row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
ya8_to_rgba_u16_row(packed, rgba_u16_row, w, use_simd);
}
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = self.rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
ya8_to_rgba_row(packed, rgba_row, w, use_simd);
return Ok(());
}
if want_hsv && !want_rgb && !want_rgba {
let hsv = self.hsv.as_mut().unwrap();
let (h, s, v) = hsv.hsv();
ya8_to_hsv_row(
packed,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
self.rgb.as_deref_mut(),
&mut self.rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
ya8_to_rgb_row(packed, rgb_row, w, use_simd);
if let Some(hsv) = self.hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
copy_alpha_ya_u8(packed, rgba_row, w);
}
Ok(())
}
}
impl<'a, R, const BE: bool> MixedSinker<'a, Ya16<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Ya16Sink<BE> for MixedSinker<'_, Ya16<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Ya16<BE>, R> {
type Input<'r> = Ya16Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.rgba_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgba_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgba_filter_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_u16.as_mut() {
stream.reset();
}
self.resample_outputs = None;
self.frozen_alpha_mode = Some(self.alpha_mode);
Ok(())
}
fn process(&mut self, row: Ya16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let packed = row.packed();
if packed.len() != w * 2 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w * 2,
packed.len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
if self.plan.is_some() {
let alpha_mode = self.alpha_mode;
let matrix = row.matrix();
let full_range = row.full_range();
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_u16,
rgba_scratch,
rgba_scratch_u16,
rgba_color_scratch_u16,
luma_scratch_u16,
rgba_stream_u16,
luma_stream_u16,
rgba_filter_stream,
rgba_filter_stream_u16,
luma_filter_stream,
luma_filter_stream_u16,
resample_outputs,
frozen_alpha_mode,
plan,
..
} = self;
let plan = plan.as_ref().expect("plan.is_some() checked above");
check_frozen_alpha_mode(*frozen_alpha_mode, alpha_mode, idx)?;
return match plan.kind() {
crate::resample::SpanKind::Area => packed_rgba_u16_resample::<16, false, true>(
rgba_stream_u16,
luma_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch_u16,
rgba_color_scratch_u16,
rgb_scratch,
rgb_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
alpha_mode,
matrix,
full_range,
|dst| ya16_to_rgba_u16_row::<BE>(packed, dst, w, use_simd),
|dst| ya16_to_luma_u16_row::<BE>(packed, dst, w, use_simd),
),
crate::resample::SpanKind::Filter if alpha_mode.is_premultiplied() => {
packed_rgba_u16_resample::<16, false, true>(
rgba_stream_u16,
luma_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch_u16,
rgba_color_scratch_u16,
rgb_scratch,
rgb_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
alpha_mode,
matrix,
full_range,
|dst| ya16_to_rgba_u16_row::<BE>(packed, dst, w, use_simd),
|dst| ya16_to_luma_u16_row::<BE>(packed, dst, w, use_simd),
)
}
crate::resample::SpanKind::Filter => packed_yuva444_filter_resample::<16, false, false>(
rgba_filter_stream,
rgba_filter_stream_u16,
luma_filter_stream,
luma_filter_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgba_scratch,
rgb_scratch,
rgba_scratch_u16,
rgba_color_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
&[],
None,
|dst| ya16_to_rgba_row::<BE>(packed, dst, w, use_simd),
|dst| ya16_to_rgba_u16_row::<BE>(packed, dst, w, use_simd),
|dst| ya16_to_luma_u16_row::<BE>(packed, dst, w, use_simd),
|_dst: &mut [u8]| {},
),
};
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let want_rgb = self.rgb.is_some();
let want_rgba = self.rgba.is_some();
let want_hsv = self.hsv.is_some();
if want_hsv && want_rgba && !want_rgb {
rgb_row_buf_or_scratch(
self.rgb.as_deref_mut(),
&mut self.rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
}
if let Some(buf) = self.luma.as_deref_mut() {
ya16_to_luma_row::<BE>(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.luma_u16.as_deref_mut() {
ya16_to_luma_u16_row::<BE>(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = self.rgb_u16.is_some();
let want_rgba_u16 = self.rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let rgba_u16_buf = self.rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
ya16_to_rgba_u16_row::<BE>(packed, rgba_u16_row, w, use_simd);
} else if want_rgb_u16 {
let rgb_u16_buf = self.rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
ya16_to_rgb_u16_row::<BE>(packed, rgb_u16_row, w, use_simd);
if want_rgba_u16 {
let rgba_u16_buf = self.rgba_u16.as_deref_mut().unwrap();
let rgba_u16_row =
rgba_u16_plane_row_slice(rgba_u16_buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_u16_to_rgba_u16_row::<16>(rgb_u16_row, rgba_u16_row, w);
copy_alpha_ya_u16::<BE>(packed, rgba_u16_row, w);
}
}
if want_rgba && !want_rgb && !want_hsv {
let rgba_buf = self.rgba.as_deref_mut().unwrap();
let rgba_row = rgba_plane_row_slice(rgba_buf, one_plane_start, one_plane_end, w, h)?;
ya16_to_rgba_row::<BE>(packed, rgba_row, w, use_simd);
return Ok(());
}
if want_hsv && !want_rgb && !want_rgba {
let hsv = self.hsv.as_mut().unwrap();
let (h, s, v) = hsv.hsv();
ya16_to_hsv_row::<BE>(
packed,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
self.rgb.as_deref_mut(),
&mut self.rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
ya16_to_rgb_row::<BE>(packed, rgb_row, w, use_simd);
if let Some(hsv) = self.hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[one_plane_start..one_plane_end],
&mut s[one_plane_start..one_plane_end],
&mut v[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = self.rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
copy_alpha_ya_u16_to_u8::<BE>(packed, rgba_row, w);
}
Ok(())
}
}
impl<'a, R, const BE: bool> MixedSinker<'a, Yaf32<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f32 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_luma_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(1)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_f32 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Yaf32Sink<BE> for MixedSinker<'_, Yaf32<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Yaf32<BE>, R> {
type Input<'r> = Yaf32Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.yaf_stream_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.yaf_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
self.frozen_alpha_mode = Some(self.alpha_mode);
Ok(())
}
fn process(&mut self, row: Yaf32Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let packed = row.packed();
if packed.len() != w * 2 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w * 2,
packed.len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
if self.plan.is_some() {
let alpha_mode = self.alpha_mode;
let premult = alpha_mode.is_premultiplied();
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
yaf_stream_f32,
yaf_filter_stream_f32,
yaf_stage_scratch_f32,
yaf_plane_scratch_f32,
resample_outputs,
frozen_alpha_mode,
plan,
..
} = self;
let plan = plan.as_ref().expect("plan.is_some() checked above");
check_frozen_alpha_mode(*frozen_alpha_mode, alpha_mode, idx)?;
return yaf_process_resampled(
yaf_stream_f32,
yaf_filter_stream_f32,
yaf_stage_scratch_f32,
yaf_plane_scratch_f32,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
plan,
w,
idx,
use_simd,
premult,
|stage| {
for x in 0..w {
let y = if BE {
f32::from_bits(u32::from_be(packed[x * 2].to_bits()))
} else {
f32::from_bits(u32::from_le(packed[x * 2].to_bits()))
};
let a = if BE {
f32::from_bits(u32::from_be(packed[x * 2 + 1].to_bits()))
} else {
f32::from_bits(u32::from_le(packed[x * 2 + 1].to_bits()))
};
stage[x * 3] = y;
stage[x * 3 + 1] = a;
stage[x * 3 + 2] = y;
}
},
);
}
yaf_direct_emit(
packed,
w,
h,
idx,
use_simd,
&mut self.luma_f32,
&mut self.rgb_f32,
&mut self.luma,
&mut self.luma_u16,
&mut self.rgb_u16,
&mut self.rgba_u16,
&mut self.rgb,
&mut self.rgba,
&mut self.hsv,
&mut self.rgb_scratch,
yaf32_to_luma_f32_row::<BE>,
yaf32_to_rgb_f32_row::<BE>,
yaf32_to_luma_row::<BE>,
yaf32_to_luma_u16_row::<BE>,
yaf32_to_rgb_u16_row::<BE>,
yaf32_to_rgba_u16_row::<BE>,
yaf32_to_rgb_row::<BE>,
yaf32_to_rgba_row::<BE>,
yaf32_to_hsv_row::<BE>,
)
}
}
impl<'a, R, const BE: bool> MixedSinker<'a, Yaf16<BE>, R> {
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba(mut self, buf: &'a mut [u8]) -> Result<Self, MixedSinkerError> {
self.set_rgba(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba(&mut self, buf: &'a mut [u8]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaBuffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_u16(mut self, buf: &'a mut [u16]) -> Result<Self, MixedSinkerError> {
self.set_luma_u16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_u16(&mut self, buf: &'a mut [u16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_pixels()?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaU16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_u16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgb_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f32 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_luma_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_luma_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_luma_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(1)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientLumaF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.luma_f32 = Some(buf);
Ok(self)
}
}
impl<R, const BE: bool> Yaf16Sink<BE> for MixedSinker<'_, Yaf16<BE>, R> {}
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Yaf16<BE>, R> {
type Input<'r> = Yaf16Row<'r>;
type Error = MixedSinkerError;
#[cfg_attr(not(tarpaulin), inline(always))]
fn kernel_matrix(&self) -> crate::KernelMatrix {
self.kernel_matrix
}
fn begin_frame(&mut self, width: u32, height: u32) -> Result<(), Self::Error> {
check_dimensions_match(self.width, self.height, width, height)?;
if let Some(stream) = self.yaf_stream_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.yaf_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
self.frozen_alpha_mode = Some(self.alpha_mode);
Ok(())
}
fn process(&mut self, row: Yaf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let packed = row.packed();
if packed.len() != w * 2 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w * 2,
packed.len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
if self.plan.is_some() {
let alpha_mode = self.alpha_mode;
let premult = alpha_mode.is_premultiplied();
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
yaf_stream_f32,
yaf_filter_stream_f32,
yaf_stage_scratch_f32,
yaf_plane_scratch_f32,
resample_outputs,
frozen_alpha_mode,
plan,
..
} = self;
let plan = plan.as_ref().expect("plan.is_some() checked above");
check_frozen_alpha_mode(*frozen_alpha_mode, alpha_mode, idx)?;
return yaf_process_resampled(
yaf_stream_f32,
yaf_filter_stream_f32,
yaf_stage_scratch_f32,
yaf_plane_scratch_f32,
resample_outputs,
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
rgb_f32,
luma_f32,
hsv,
plan,
w,
idx,
use_simd,
premult,
|stage| {
for x in 0..w {
let y = half::f16::from_bits(if BE {
u16::from_be(packed[x * 2].to_bits())
} else {
u16::from_le(packed[x * 2].to_bits())
})
.to_f32();
let a = half::f16::from_bits(if BE {
u16::from_be(packed[x * 2 + 1].to_bits())
} else {
u16::from_le(packed[x * 2 + 1].to_bits())
})
.to_f32();
stage[x * 3] = y;
stage[x * 3 + 1] = a;
stage[x * 3 + 2] = y;
}
},
);
}
yaf_direct_emit(
packed,
w,
h,
idx,
use_simd,
&mut self.luma_f32,
&mut self.rgb_f32,
&mut self.luma,
&mut self.luma_u16,
&mut self.rgb_u16,
&mut self.rgba_u16,
&mut self.rgb,
&mut self.rgba,
&mut self.hsv,
&mut self.rgb_scratch,
yaf16_to_luma_f32_row::<BE>,
yaf16_to_rgb_f32_row::<BE>,
yaf16_to_luma_row::<BE>,
yaf16_to_luma_u16_row::<BE>,
yaf16_to_rgb_u16_row::<BE>,
yaf16_to_rgba_u16_row::<BE>,
yaf16_to_rgb_row::<BE>,
yaf16_to_rgba_row::<BE>,
yaf16_to_hsv_row::<BE>,
)
}
}
#[allow(clippy::too_many_arguments)]
fn yaf_direct_emit<T, FLf32, FRf32, FL, FLu16, FRu16, FRAu16, FRgb, FRgba, FHsv>(
packed: &[T],
w: usize,
h: usize,
idx: usize,
use_simd: bool,
luma_f32: &mut Option<&mut [f32]>,
rgb_f32: &mut Option<&mut [f32]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba_u16: &mut Option<&mut [u16]>,
rgb: &mut Option<&mut [u8]>,
rgba: &mut Option<&mut [u8]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
rgb_scratch: &mut std::vec::Vec<u8>,
to_luma_f32: FLf32,
to_rgb_f32: FRf32,
to_luma: FL,
to_luma_u16: FLu16,
to_rgb_u16: FRu16,
to_rgba_u16: FRAu16,
to_rgb: FRgb,
to_rgba: FRgba,
to_hsv: FHsv,
) -> Result<(), MixedSinkerError>
where
FLf32: Fn(&[T], &mut [f32], usize, bool),
FRf32: Fn(&[T], &mut [f32], usize, bool),
FL: Fn(&[T], &mut [u8], usize, bool),
FLu16: Fn(&[T], &mut [u16], usize, bool),
FRu16: Fn(&[T], &mut [u16], usize, bool),
FRAu16: Fn(&[T], &mut [u16], usize, bool),
FRgb: Fn(&[T], &mut [u8], usize, bool),
FRgba: Fn(&[T], &mut [u8], usize, bool),
FHsv: Fn(&[T], &mut [u8], &mut [u8], &mut [u8], usize, bool),
{
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = luma_f32.as_deref_mut() {
to_luma_f32(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
let rgb_f32_start = one_plane_start * 3;
let rgb_f32_end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
to_rgb_f32(packed, &mut buf[rgb_f32_start..rgb_f32_end], w, use_simd);
}
if let Some(buf) = luma.as_deref_mut() {
to_luma(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
to_luma_u16(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba_u16 = rgba_u16.is_some();
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
let row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
to_rgba_u16(packed, row, w, use_simd);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_start = one_plane_start * 3;
let rgb_plane_end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
to_rgb_u16(
packed,
&mut buf[rgb_plane_start..rgb_plane_end],
w,
use_simd,
);
if want_rgba_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
let row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
to_rgba_u16(packed, row, w, use_simd);
}
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
if want_rgba && !want_rgb && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
let row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
to_rgba(packed, row, w, use_simd);
return Ok(());
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
to_hsv(
packed,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
let row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
to_rgba(packed, row, w, use_simd);
}
return Ok(());
}
if !want_rgb && !want_rgba && !want_hsv {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
to_rgb(packed, rgb_row, w, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[one_plane_start..one_plane_end],
&mut sp[one_plane_start..one_plane_end],
&mut vp[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
to_rgba(packed, row, w, use_simd);
}
Ok(())
}
#[cfg(feature = "gray")]
#[cfg_attr(not(tarpaulin), inline(always))]
fn yaf_patch_alpha_u8(alpha: &[f32], rgba: &mut [u8], width: usize) {
for (i, &a) in alpha[..width].iter().enumerate() {
rgba[i * 4 + 3] = (a.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
}
}
#[cfg(feature = "gray")]
#[cfg_attr(not(tarpaulin), inline(always))]
fn yaf_patch_alpha_u16(alpha: &[f32], rgba: &mut [u16], width: usize) {
for (i, &a) in alpha[..width].iter().enumerate() {
rgba[i * 4 + 3] = (a.clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
}
}
#[allow(clippy::too_many_arguments)]
fn yaf_process_resampled(
yaf_stream_f32: &mut Option<std::boxed::Box<AreaStream<f32>>>,
yaf_filter_stream_f32: &mut Option<std::boxed::Box<crate::resample::FilterStream<f32>>>,
stage_scratch: &mut std::vec::Vec<f32>,
plane_scratch: &mut std::vec::Vec<f32>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba: &mut Option<&mut [u8]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
rgb_f32: &mut Option<&mut [f32]>,
luma_f32: &mut Option<&mut [f32]>,
hsv: &mut Option<mediaframe::source::HsvFrameMut<'_>>,
plan: &ResamplePlan,
w: usize,
idx: usize,
use_simd: bool,
premult: bool,
stage_yay: impl FnOnce(&mut [f32]),
) -> Result<(), MixedSinkerError> {
const HOST_NATIVE_BE: bool = cfg!(target_endian = "big");
plan.ensure_single_kernel_filter()?;
if premult && plan.kind().is_filter() {
return Err(plan.unsupported_filter().into());
}
let ow = plan.out_w();
let want_rgb = rgb.is_some();
let want_rgb_u16 = rgb_u16.is_some();
let want_rgba = rgba.is_some();
let want_rgba_u16 = rgba_u16.is_some();
let want_hsv = hsv.is_some();
let need_rgb_kernel = want_rgb;
let need_any = luma.is_some()
|| luma_u16.is_some()
|| luma_f32.is_some()
|| rgb_f32.is_some()
|| want_rgb
|| want_rgb_u16
|| want_rgba
|| want_rgba_u16
|| want_hsv;
let is_filter = plan.kind().is_filter();
let expected = if need_any {
Some(if is_filter {
yaf_filter_stream_f32.as_ref().map_or(0, |s| s.next_y())
} else {
yaf_stream_f32.as_ref().map_or(0, |s| s.next_y())
})
} else {
None
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
rgb_u16,
rgba_u16,
rgb_f32,
&None,
&None,
&None,
&None,
hsv,
luma_f32,
expected,
idx,
)? {
return Ok(());
}
let stage_len =
w.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w,
plan.src_h(),
3,
)))?;
if stage_scratch.len() < stage_len {
stage_scratch
.try_reserve_exact(stage_len - stage_scratch.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
stage_scratch.resize(stage_len, 0.0);
}
let stage = &mut stage_scratch[..stage_len];
stage_yay(stage);
if premult {
for x in 0..w {
let a = stage[x * 3 + 1];
stage[x * 3] *= a;
}
}
let plane_len =
ow.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
ow,
plan.out_h(),
3,
)))?;
if plane_scratch.len() < plane_len {
plane_scratch
.try_reserve_exact(plane_len - plane_scratch.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
plane_scratch.resize(plane_len, 0.0);
}
let new_area = if !is_filter && yaf_stream_f32.is_none() {
let stream = AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 3)?;
Some(crate::resample::try_box(stream).map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(plan.src_w(), plan.src_h(), plan.out_w(), plan.out_h()),
))
})?)
} else {
None
};
let new_filter = if is_filter && yaf_filter_stream_f32.is_none() {
let (fh, fv) = (
plan
.filter_h()
.expect("filter plan carries horizontal windows"),
plan
.filter_v()
.expect("filter plan carries vertical windows"),
);
let stream = crate::resample::FilterStream::new(fh, fv, plan.src_w(), plan.src_h(), 3)?;
Some(crate::resample::try_box(stream).map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(plan.src_w(), plan.src_h(), plan.out_w(), plan.out_h()),
))
})?)
} else {
None
};
if let Some(s) = new_area {
*yaf_stream_f32 = Some(s);
}
if let Some(s) = new_filter {
*yaf_filter_stream_f32 = Some(s);
}
frozen_outputs_check(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
rgb_u16,
rgba_u16,
rgb_f32,
&None,
&None,
&None,
&None,
hsv,
luma_f32,
idx,
)?;
let mut emit = |oy: usize, binned: &[f32]| {
let planes = &mut plane_scratch[..plane_len];
let (color_y, rest) = planes.split_at_mut(ow);
let (alpha, native_y) = rest.split_at_mut(ow);
for x in 0..ow {
color_y[x] = binned[x * 3];
alpha[x] = binned[x * 3 + 1];
native_y[x] = binned[x * 3 + 2];
}
if premult {
for x in 0..ow {
let a = alpha[x];
color_y[x] = if a == 0.0 { 0.0 } else { color_y[x] / a };
}
}
let color_y: &[f32] = color_y;
let alpha: &[f32] = alpha;
let native_y: &[f32] = native_y;
if let Some(buf) = luma_f32.as_deref_mut() {
grayf32_to_luma_f32_row::<HOST_NATIVE_BE>(
native_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
grayf32_to_luma_row::<HOST_NATIVE_BE>(
native_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
grayf32_to_luma_u16_row::<HOST_NATIVE_BE>(
native_y,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
grayf32_to_rgb_f32_row::<HOST_NATIVE_BE>(
color_y,
&mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
ow,
use_simd,
);
}
if want_rgba_u16 && !want_rgb_u16 {
let buf = rgba_u16.as_deref_mut().unwrap();
let row = &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow];
grayf32_to_rgba_u16_row::<HOST_NATIVE_BE>(color_y, row, ow, use_simd);
yaf_patch_alpha_u16(alpha, row, ow);
} else if want_rgb_u16 {
let buf = rgb_u16.as_deref_mut().unwrap();
grayf32_to_rgb_u16_row::<HOST_NATIVE_BE>(
color_y,
&mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
ow,
use_simd,
);
if let Some(buf) = rgba_u16.as_deref_mut() {
let row = &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow];
grayf32_to_rgba_u16_row::<HOST_NATIVE_BE>(color_y, row, ow, use_simd);
yaf_patch_alpha_u16(alpha, row, ow);
}
}
if want_rgba && !need_rgb_kernel && !want_hsv {
let buf = rgba.as_deref_mut().unwrap();
let row = &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow];
grayf32_to_rgba_row::<HOST_NATIVE_BE>(color_y, row, ow, use_simd);
yaf_patch_alpha_u8(alpha, row, ow);
return;
}
if want_hsv && !want_rgb {
let hsv = hsv.as_mut().unwrap();
let (hp, sp, vp) = hsv.hsv();
grayf32_to_hsv_row::<HOST_NATIVE_BE>(
color_y,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
if let Some(buf) = rgba.as_deref_mut() {
let row = &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow];
grayf32_to_rgba_row::<HOST_NATIVE_BE>(color_y, row, ow, use_simd);
yaf_patch_alpha_u8(alpha, row, ow);
}
return;
}
if !need_rgb_kernel {
return;
}
let buf = rgb
.as_deref_mut()
.expect("need_rgb_kernel implies RGB is attached");
let rgb_row = &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow];
grayf32_to_rgb_row::<HOST_NATIVE_BE>(color_y, rgb_row, ow, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (hp, sp, vp) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hp[oy * ow..(oy + 1) * ow],
&mut sp[oy * ow..(oy + 1) * ow],
&mut vp[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
let row = &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow];
grayf32_to_rgba_row::<HOST_NATIVE_BE>(color_y, row, ow, use_simd);
yaf_patch_alpha_u8(alpha, row, ow);
}
};
match plan.kind() {
crate::resample::SpanKind::Area => {
let stream = yaf_stream_f32.as_mut().expect("created above");
stream.feed_row(idx, stage, use_simd, &mut emit)?;
}
crate::resample::SpanKind::Filter => {
let stream = yaf_filter_stream_f32.as_mut().expect("created above");
stream.feed_row(idx, stage, use_simd, &mut emit)?;
}
}
Ok(())
}