use super::{
InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange, RowShapeMismatch,
RowSlice, check_dimensions_match, frozen_outputs_check, source_luma_scratch,
};
use crate::{
PixelSink,
resample::{AreaStream, FilterStream, ResamplePlan, RowResampler},
row,
source::{Monoblack, MonoblackRow, MonoblackSink, Monowhite, MonowhiteRow, MonowhiteSink},
};
use mediaframe::source::HsvFrameMut;
#[allow(clippy::too_many_arguments)]
fn mono_luma_resample(
luma_stream: &mut Option<std::boxed::Box<AreaStream<u8>>>,
luma_filter_stream: &mut Option<std::boxed::Box<FilterStream<u8>>>,
resample_outputs: &mut Option<super::FrozenOutputs>,
rgb: &mut Option<&mut [u8]>,
rgba: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
hsv: &mut Option<HsvFrameMut<'_>>,
scratch: &mut std::vec::Vec<u8>,
w: usize,
plan: &ResamplePlan,
idx: usize,
use_simd: bool,
expand_luma: impl FnOnce(&mut [u8]),
) -> Result<(), MixedSinkerError> {
plan.ensure_single_kernel_filter()?;
let is_filter = plan.kind().is_filter();
let need_any = luma.is_some()
|| luma_u16.is_some()
|| rgb.is_some()
|| rgba.is_some()
|| rgb_u16.is_some()
|| rgba_u16.is_some()
|| hsv.is_some();
let expected = if need_any {
Some(if is_filter {
luma_filter_stream
.as_ref()
.map_or(0, |stream| stream.next_y())
} else {
luma_stream.as_ref().map_or(0, |stream| stream.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,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
expected,
idx,
)? {
return Ok(());
}
if is_filter {
let (fh, fv) = (
plan
.filter_h()
.expect("filter plan carries horizontal windows"),
plan
.filter_v()
.expect("filter plan carries vertical windows"),
);
let new_stream = if luma_filter_stream.is_none() {
let stream = FilterStream::new(fh, fv, plan.src_w(), plan.src_h(), 1)?;
Some(crate::resample::try_box(stream).map_err(|_| {
MixedSinkerError::Resample(crate::resample::ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?)
} else {
None
};
source_luma_scratch(scratch, w, plan)?;
if let Some(s) = new_stream {
*luma_filter_stream = Some(s);
}
frozen_outputs_check(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
rgb_u16,
rgba_u16,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
idx,
)?;
let stream = luma_filter_stream.as_mut().expect("created above");
mono_luma_feed_emit(
stream,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
scratch,
w,
plan,
idx,
use_simd,
expand_luma,
)
} else {
let new_stream = if luma_stream.is_none() {
let stream = AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 1)?;
Some(crate::resample::try_box(stream).map_err(|_| {
MixedSinkerError::Resample(crate::resample::ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?)
} else {
None
};
source_luma_scratch(scratch, w, plan)?;
if let Some(s) = new_stream {
*luma_stream = Some(s);
}
frozen_outputs_check(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
rgb_u16,
rgba_u16,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
idx,
)?;
let stream = luma_stream.as_mut().expect("created above");
mono_luma_feed_emit(
stream,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
scratch,
w,
plan,
idx,
use_simd,
expand_luma,
)
}
}
#[allow(clippy::too_many_arguments)]
fn mono_luma_feed_emit<S: RowResampler<u8>>(
stream: &mut S,
rgb: &mut Option<&mut [u8]>,
rgba: &mut Option<&mut [u8]>,
rgb_u16: &mut Option<&mut [u16]>,
rgba_u16: &mut Option<&mut [u16]>,
luma: &mut Option<&mut [u8]>,
luma_u16: &mut Option<&mut [u16]>,
hsv: &mut Option<HsvFrameMut<'_>>,
scratch: &mut std::vec::Vec<u8>,
w: usize,
plan: &ResamplePlan,
idx: usize,
use_simd: bool,
expand_luma: impl FnOnce(&mut [u8]),
) -> Result<(), MixedSinkerError> {
let ow = plan.out_w();
let luma_row = source_luma_scratch(scratch, w, plan)?;
expand_luma(luma_row);
stream.feed_row(idx, luma_row, use_simd, |oy, out_row| {
if let Some(buf) = luma.as_deref_mut() {
buf[oy * ow..(oy + 1) * ow].copy_from_slice(out_row);
}
if let Some(buf) = luma_u16.as_deref_mut() {
for (dst, &y) in buf[oy * ow..(oy + 1) * ow].iter_mut().zip(out_row) {
*dst = y as u16;
}
}
if let Some(buf) = rgb.as_deref_mut() {
for (px, &y) in buf[oy * 3 * ow..(oy + 1) * 3 * ow]
.as_chunks_mut::<3>()
.0
.iter_mut()
.zip(out_row)
{
px[0] = y;
px[1] = y;
px[2] = y;
}
}
if let Some(buf) = rgba.as_deref_mut() {
for (px, &y) in buf[oy * 4 * ow..(oy + 1) * 4 * ow]
.as_chunks_mut::<4>()
.0
.iter_mut()
.zip(out_row)
{
px[0] = y;
px[1] = y;
px[2] = y;
px[3] = 0xFF;
}
}
if let Some(buf) = rgb_u16.as_deref_mut() {
for (px, &y) in buf[oy * 3 * ow..(oy + 1) * 3 * ow]
.as_chunks_mut::<3>()
.0
.iter_mut()
.zip(out_row)
{
let y16 = y as u16;
px[0] = y16;
px[1] = y16;
px[2] = y16;
}
}
if let Some(buf) = rgba_u16.as_deref_mut() {
for (px, &y) in buf[oy * 4 * ow..(oy + 1) * 4 * ow]
.as_chunks_mut::<4>()
.0
.iter_mut()
.zip(out_row)
{
let y16 = y as u16;
px[0] = y16;
px[1] = y16;
px[2] = y16;
px[3] = 0x00FF;
}
}
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
let span = oy * ow..(oy + 1) * ow;
v[span.clone()].copy_from_slice(out_row);
for px in &mut h[span.clone()] {
*px = 0;
}
for px in &mut s[span] {
*px = 0;
}
}
})?;
Ok(())
}
impl<'a, R> MixedSinker<'a, Monoblack, 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> MonoblackSink for MixedSinker<'_, Monoblack, R> {}
impl<R> PixelSink for MixedSinker<'_, Monoblack, R> {
type Input<'i> = MonoblackRow<'i>;
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: Self::Input<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let min_bytes = w.div_ceil(8);
if row.data().len() < min_bytes {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
min_bytes,
row.data().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
plan,
luma_stream,
luma_filter_stream,
resample_outputs,
rgb_scratch,
..
} = self;
if let Some(plan) = plan.as_ref() {
let data = row.data();
return mono_luma_resample(
luma_stream,
luma_filter_stream,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
w,
plan,
idx,
use_simd,
|scratch| row::monoblack_to_luma_row(data, scratch, w, use_simd),
);
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = rgb.as_deref_mut() {
row::monoblack_to_rgb_or_rgba_row::<false>(
row.data(),
&mut buf[one_plane_start * 3..one_plane_end * 3],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
row::monoblack_to_rgb_or_rgba_row::<true>(
row.data(),
&mut buf[one_plane_start * 4..one_plane_end * 4],
w,
use_simd,
);
}
if let Some(buf) = rgb_u16.as_deref_mut() {
row::monoblack_to_rgb_u16_or_rgba_u16_row::<false>(
row.data(),
&mut buf[one_plane_start * 3..one_plane_end * 3],
w,
use_simd,
);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
row::monoblack_to_rgb_u16_or_rgba_u16_row::<true>(
row.data(),
&mut buf[one_plane_start * 4..one_plane_end * 4],
w,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
row::monoblack_to_luma_row(
row.data(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
row::monoblack_to_luma_u16_row(
row.data(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
row::monoblack_to_hsv_row(
row.data(),
&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,
);
}
Ok(())
}
}
impl<'a, R> MixedSinker<'a, Monowhite, 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> MonowhiteSink for MixedSinker<'_, Monowhite, R> {}
impl<R> PixelSink for MixedSinker<'_, Monowhite, R> {
type Input<'i> = MonowhiteRow<'i>;
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: Self::Input<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let min_bytes = w.div_ceil(8);
if row.data().len() < min_bytes {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
min_bytes,
row.data().len(),
)));
}
if idx >= h {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, h),
));
}
let Self {
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
plan,
luma_stream,
luma_filter_stream,
resample_outputs,
rgb_scratch,
..
} = self;
if let Some(plan) = plan.as_ref() {
let data = row.data();
return mono_luma_resample(
luma_stream,
luma_filter_stream,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
w,
plan,
idx,
use_simd,
|scratch| row::monowhite_to_luma_row(data, scratch, w, use_simd),
);
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
if let Some(buf) = rgb.as_deref_mut() {
row::monowhite_to_rgb_or_rgba_row::<false>(
row.data(),
&mut buf[one_plane_start * 3..one_plane_end * 3],
w,
use_simd,
);
}
if let Some(buf) = rgba.as_deref_mut() {
row::monowhite_to_rgb_or_rgba_row::<true>(
row.data(),
&mut buf[one_plane_start * 4..one_plane_end * 4],
w,
use_simd,
);
}
if let Some(buf) = rgb_u16.as_deref_mut() {
row::monowhite_to_rgb_u16_or_rgba_u16_row::<false>(
row.data(),
&mut buf[one_plane_start * 3..one_plane_end * 3],
w,
use_simd,
);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
row::monowhite_to_rgb_u16_or_rgba_u16_row::<true>(
row.data(),
&mut buf[one_plane_start * 4..one_plane_end * 4],
w,
use_simd,
);
}
if let Some(buf) = luma.as_deref_mut() {
row::monowhite_to_luma_row(
row.data(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
row::monowhite_to_luma_u16_row(
row.data(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
row::monowhite_to_hsv_row(
row.data(),
&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,
);
}
Ok(())
}
}