use super::{
GeometryOverflow, InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange,
RowShapeMismatch, RowSlice, check_dimensions_match, frozen_outputs_check,
resample_preflight_check_only, rgb_row_buf_or_scratch, rgba_plane_row_slice,
rgba_u16_plane_row_slice, source_rgb_scratch,
};
use crate::{
PixelSink,
resample::ResamplePlan,
row::{
bgr4_byte_to_rgb_row, bgr4_byte_to_rgb_u16_row, bgr4_byte_to_rgba_row,
bgr4_byte_to_rgba_u16_row, bgr4_to_rgb_row, bgr4_to_rgb_u16_row, bgr4_to_rgba_row,
bgr4_to_rgba_u16_row, bgr8_to_rgb_row, bgr8_to_rgb_u16_row, bgr8_to_rgba_row,
bgr8_to_rgba_u16_row, bgr444_to_rgb_row, bgr444_to_rgb_u16_row, bgr444_to_rgba_row,
bgr444_to_rgba_u16_row, bgr555_to_rgb_row, bgr555_to_rgb_u16_row, bgr555_to_rgba_row,
bgr555_to_rgba_u16_row, bgr565_to_rgb_row, bgr565_to_rgb_u16_row, bgr565_to_rgba_row,
bgr565_to_rgba_u16_row, rgb_to_hsv_row, rgb_to_luma_row, rgb_to_luma_u16_row,
rgb4_byte_to_rgb_row, rgb4_byte_to_rgb_u16_row, rgb4_byte_to_rgba_row,
rgb4_byte_to_rgba_u16_row, rgb4_to_rgb_row, rgb4_to_rgb_u16_row, rgb4_to_rgba_row,
rgb4_to_rgba_u16_row, rgb8_to_rgb_row, rgb8_to_rgb_u16_row, rgb8_to_rgba_row,
rgb8_to_rgba_u16_row, rgb444_to_rgb_row, rgb444_to_rgb_u16_row, rgb444_to_rgba_row,
rgb444_to_rgba_u16_row, rgb555_to_rgb_row, rgb555_to_rgb_u16_row, rgb555_to_rgba_row,
rgb555_to_rgba_u16_row, rgb565_to_rgb_row, rgb565_to_rgb_u16_row, rgb565_to_rgba_row,
rgb565_to_rgba_u16_row,
},
source::{
Bgr4, Bgr4Byte, Bgr4ByteRow, Bgr4ByteSink, Bgr4Row, Bgr4Sink, Bgr8, Bgr8Row, Bgr8Sink, Bgr444,
Bgr444Row, Bgr444Sink, Bgr555, Bgr555Row, Bgr555Sink, Bgr565, Bgr565Row, Bgr565Sink,
HsvFrameMut, Rgb4, Rgb4Byte, Rgb4ByteRow, Rgb4ByteSink, Rgb4Row, Rgb4Sink, Rgb8, Rgb8Row,
Rgb8Sink, Rgb444, Rgb444Row, Rgb444Sink, Rgb555, Rgb555Row, Rgb555Sink, Rgb565, Rgb565Row,
Rgb565Sink,
},
};
#[inline(always)]
fn rgb_u16_plane_row_slice(
buf: &mut [u16],
one_plane_start: usize,
one_plane_end: usize,
width: usize,
height: usize,
) -> Result<&mut [u16], MixedSinkerError> {
let end = one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
width, height, 3,
)))?;
let start = one_plane_start * 3;
Ok(&mut buf[start..end])
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn legacy_rgb_packed_scratch<'s>(
scratch: &'s mut std::vec::Vec<u8>,
width: usize,
plan: &ResamplePlan,
) -> Result<&'s mut [u8], MixedSinkerError> {
let row_bytes = width
.checked_mul(2)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
width,
plan.out_h(),
2,
)))?;
if scratch.len() < row_bytes {
scratch
.try_reserve_exact(row_bytes - scratch.len())
.map_err(|_| {
MixedSinkerError::Resample(crate::resample::ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
scratch.resize(row_bytes, 0);
}
Ok(&mut scratch[..row_bytes])
}
#[allow(clippy::too_many_arguments)]
fn legacy_rgb_resample_emit(
stream: &mut crate::resample::AreaStream<u8>,
plan: &ResamplePlan,
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<'_>>,
src_native: &[u8],
rgb_stage_scratch: &mut std::vec::Vec<u8>,
packed_scratch: &mut std::vec::Vec<u8>,
matrix: crate::KernelMatrix,
full_range: bool,
idx: usize,
use_simd: bool,
repack: impl Fn(u8, u8, u8) -> u16,
to_rgb: fn(&[u8], &mut [u8], usize, bool),
to_rgba: fn(&[u8], &mut [u8], usize, bool),
to_rgb_u16: fn(&[u8], &mut [u16], usize, bool),
to_rgba_u16: fn(&[u8], &mut [u16], usize, bool),
) -> Result<(), MixedSinkerError> {
let ow = plan.out_w();
let packed = legacy_rgb_packed_scratch(packed_scratch, ow, plan)?;
let need_rgb_stage = rgb.is_none() && (luma.is_some() || luma_u16.is_some() || hsv.is_some());
let stage: &mut [u8] = if need_rgb_stage {
source_rgb_scratch(rgb_stage_scratch, ow, plan)?
} else {
&mut []
};
stream.feed_row(idx, src_native, use_simd, |oy, binned| {
let prow = &mut packed[..2 * ow];
for x in 0..ow {
let word = repack(binned[x * 3], binned[x * 3 + 1], binned[x * 3 + 2]);
let bytes = word.to_le_bytes();
prow[x * 2] = bytes[0];
prow[x * 2 + 1] = bytes[1];
}
if let Some(buf) = rgb_u16.as_deref_mut() {
to_rgb_u16(prow, &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow], ow, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
to_rgba_u16(prow, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow, use_simd);
}
if let Some(buf) = rgba.as_deref_mut() {
to_rgba(prow, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow, use_simd);
}
if rgb.is_some() || need_rgb_stage {
let rgb_row: &mut [u8] = match rgb.as_deref_mut() {
Some(buf) => &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
None => &mut stage[..3 * ow],
};
to_rgb(prow, rgb_row, ow, use_simd);
if let Some(buf) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
matrix,
full_range,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
matrix,
full_range,
use_simd,
);
}
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[oy * ow..(oy + 1) * ow],
&mut s[oy * ow..(oy + 1) * ow],
&mut v[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
}
})?;
Ok(())
}
macro_rules! impl_legacy_rgb_sinker {
(
marker: $marker:ident,
sink_trait: $sink_trait:ident,
row_ty: $row_ty:ident,
buf_field: $buf_field:ident,
row_slice: $row_slice:expr,
to_rgb: $to_rgb:ident,
to_rgba: $to_rgba:ident,
to_rgb_u16: $to_rgb_u16:ident,
to_rgba_u16: $to_rgba_u16:ident,
unpack: $unpack:expr,
repack: $repack:expr,
) => {
impl<'a, R> MixedSinker<'a, $marker, 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> $sink_trait for MixedSinker<'_, $marker, R> {}
impl<R> PixelSink for MixedSinker<'_, $marker, R> {
type Input<'r> = $row_ty<'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.rgb_stream.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: $row_ty<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
if row.$buf_field().len() != w * 2 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
$row_slice,
idx,
w * 2,
row.$buf_field().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
if let Some(plan) = self.plan.as_ref() {
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
legacy_rgb_native_scratch,
legacy_rgb_packed_scratch: packed_scratch,
rgb_stream,
resample_outputs,
..
} = self;
let expected = if rgb.is_some()
|| rgba.is_some()
|| rgb_u16.is_some()
|| rgba_u16.is_some()
|| luma.is_some()
|| luma_u16.is_some()
|| hsv.is_some()
{
Some(rgb_stream.as_ref().map_or(0, |s| s.next_y()))
} else {
None
};
if let core::ops::ControlFlow::Break(()) = 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 plan.kind().is_filter() {
return Err(plan.unsupported_filter().into());
}
let new_stream = if rgb_stream.is_none() {
let stream =
crate::resample::AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 3)?;
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
};
let ow = plan.out_w();
legacy_rgb_packed_scratch(packed_scratch, ow, plan)?;
if rgb.is_none() && (luma.is_some() || luma_u16.is_some() || hsv.is_some()) {
source_rgb_scratch(rgb_scratch, ow, plan)?;
}
source_rgb_scratch(legacy_rgb_native_scratch, w, plan)?;
if let Some(s) = new_stream {
*rgb_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 = rgb_stream.as_mut().expect("created above");
let native = source_rgb_scratch(legacy_rgb_native_scratch, w, plan)?;
let src = row.$buf_field();
let unpack = $unpack;
for x in 0..w {
let px = u16::from_le_bytes([src[x * 2], src[x * 2 + 1]]);
let (r, g, b) = unpack(px);
native[x * 3] = r;
native[x * 3 + 1] = g;
native[x * 3 + 2] = b;
}
return legacy_rgb_resample_emit(
stream,
plan,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
native,
rgb_scratch,
packed_scratch,
row.matrix(),
row.full_range(),
idx,
use_simd,
$repack,
$to_rgb,
$to_rgba,
$to_rgb_u16,
$to_rgba_u16,
);
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
..
} = self;
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let src = row.$buf_field();
if let Some(buf) = rgb_u16.as_deref_mut() {
let rgb_u16_row = rgb_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgb_u16(src, rgb_u16_row, w, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
let rgba_u16_row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgba_u16(src, rgba_u16_row, w, use_simd);
}
let want_rgb = rgb.is_some();
let want_luma = luma.is_some();
let want_luma_u16 = luma_u16.is_some();
let want_hsv = hsv.is_some();
let need_u8_rgb = want_rgb || want_luma || want_luma_u16 || want_hsv;
if !need_u8_rgb {
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgba(src, rgba_row, w, use_simd);
}
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(src, rgb_row, w, use_simd);
if let Some(luma_buf) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut luma_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(luma_u16_buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut luma_u16_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(hsv_bufs) = hsv.as_mut() {
let (h, s, v) = hsv_bufs.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)?;
$to_rgba(src, rgba_row, w, use_simd);
}
Ok(())
}
}
};
}
impl_legacy_rgb_sinker! {
marker: Rgb565,
sink_trait: Rgb565Sink,
row_ty: Rgb565Row,
buf_field: rgb565,
row_slice: RowSlice::Rgb565Packed,
to_rgb: rgb565_to_rgb_row,
to_rgba: rgb565_to_rgba_row,
to_rgb_u16: rgb565_to_rgb_u16_row,
to_rgba_u16: rgb565_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
((px >> 11) & 0x1F) as u8,
((px >> 5) & 0x3F) as u8,
(px & 0x1F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((r as u16) << 11) | ((g as u16) << 5) | (b as u16)
},
}
impl_legacy_rgb_sinker! {
marker: Bgr565,
sink_trait: Bgr565Sink,
row_ty: Bgr565Row,
buf_field: bgr565,
row_slice: RowSlice::Bgr565Packed,
to_rgb: bgr565_to_rgb_row,
to_rgba: bgr565_to_rgba_row,
to_rgb_u16: bgr565_to_rgb_u16_row,
to_rgba_u16: bgr565_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
(px & 0x1F) as u8,
((px >> 5) & 0x3F) as u8,
((px >> 11) & 0x1F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((b as u16) << 11) | ((g as u16) << 5) | (r as u16)
},
}
impl_legacy_rgb_sinker! {
marker: Rgb555,
sink_trait: Rgb555Sink,
row_ty: Rgb555Row,
buf_field: rgb555,
row_slice: RowSlice::Rgb555Packed,
to_rgb: rgb555_to_rgb_row,
to_rgba: rgb555_to_rgba_row,
to_rgb_u16: rgb555_to_rgb_u16_row,
to_rgba_u16: rgb555_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
((px >> 10) & 0x1F) as u8,
((px >> 5) & 0x1F) as u8,
(px & 0x1F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((r as u16) << 10) | ((g as u16) << 5) | (b as u16)
},
}
impl_legacy_rgb_sinker! {
marker: Bgr555,
sink_trait: Bgr555Sink,
row_ty: Bgr555Row,
buf_field: bgr555,
row_slice: RowSlice::Bgr555Packed,
to_rgb: bgr555_to_rgb_row,
to_rgba: bgr555_to_rgba_row,
to_rgb_u16: bgr555_to_rgb_u16_row,
to_rgba_u16: bgr555_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
(px & 0x1F) as u8,
((px >> 5) & 0x1F) as u8,
((px >> 10) & 0x1F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((b as u16) << 10) | ((g as u16) << 5) | (r as u16)
},
}
impl_legacy_rgb_sinker! {
marker: Rgb444,
sink_trait: Rgb444Sink,
row_ty: Rgb444Row,
buf_field: rgb444,
row_slice: RowSlice::Rgb444Packed,
to_rgb: rgb444_to_rgb_row,
to_rgba: rgb444_to_rgba_row,
to_rgb_u16: rgb444_to_rgb_u16_row,
to_rgba_u16: rgb444_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
((px >> 8) & 0x0F) as u8,
((px >> 4) & 0x0F) as u8,
(px & 0x0F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((r as u16) << 8) | ((g as u16) << 4) | (b as u16)
},
}
impl_legacy_rgb_sinker! {
marker: Bgr444,
sink_trait: Bgr444Sink,
row_ty: Bgr444Row,
buf_field: bgr444,
row_slice: RowSlice::Bgr444Packed,
to_rgb: bgr444_to_rgb_row,
to_rgba: bgr444_to_rgba_row,
to_rgb_u16: bgr444_to_rgb_u16_row,
to_rgba_u16: bgr444_to_rgba_u16_row,
unpack: |px: u16| -> (u8, u8, u8) {
(
(px & 0x0F) as u8,
((px >> 4) & 0x0F) as u8,
((px >> 8) & 0x0F) as u8,
)
},
repack: |r: u8, g: u8, b: u8| -> u16 {
((b as u16) << 8) | ((g as u16) << 4) | (r as u16)
},
}
#[cfg_attr(not(tarpaulin), inline(always))]
fn legacy_rgb_byte_packed_scratch<'s>(
scratch: &'s mut std::vec::Vec<u8>,
row_bytes: usize,
plan: &ResamplePlan,
) -> Result<&'s mut [u8], MixedSinkerError> {
if scratch.len() < row_bytes {
scratch
.try_reserve_exact(row_bytes - scratch.len())
.map_err(|_| {
MixedSinkerError::Resample(crate::resample::ResampleError::AllocationFailed(
crate::resample::PlanGeometry::new(
plan.src_w(),
plan.src_h(),
plan.out_w(),
plan.out_h(),
),
))
})?;
scratch.resize(row_bytes, 0);
}
Ok(&mut scratch[..row_bytes])
}
#[allow(clippy::too_many_arguments)]
fn legacy_rgb_packed_resample_emit(
stream: &mut crate::resample::AreaStream<u8>,
plan: &ResamplePlan,
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<'_>>,
src_native: &[u8],
rgb_stage_scratch: &mut std::vec::Vec<u8>,
packed_scratch: &mut std::vec::Vec<u8>,
matrix: crate::KernelMatrix,
full_range: bool,
idx: usize,
use_simd: bool,
nibble_packed: bool,
repack: impl Fn(u8, u8, u8) -> u8,
to_rgb: fn(&[u8], &mut [u8], usize, bool),
to_rgba: fn(&[u8], &mut [u8], usize, bool),
to_rgb_u16: fn(&[u8], &mut [u16], usize, bool),
to_rgba_u16: fn(&[u8], &mut [u16], usize, bool),
) -> Result<(), MixedSinkerError> {
let ow = plan.out_w();
let pack_row_bytes = if nibble_packed { ow.div_ceil(2) } else { ow };
let packed = legacy_rgb_byte_packed_scratch(packed_scratch, pack_row_bytes, plan)?;
let need_rgb_stage = rgb.is_none() && (luma.is_some() || luma_u16.is_some() || hsv.is_some());
let stage: &mut [u8] = if need_rgb_stage {
source_rgb_scratch(rgb_stage_scratch, ow, plan)?
} else {
&mut []
};
stream.feed_row(idx, src_native, use_simd, |oy, binned| {
let prow = &mut packed[..pack_row_bytes];
if nibble_packed {
prow.fill(0);
for x in 0..ow {
let v = repack(binned[x * 3], binned[x * 3 + 1], binned[x * 3 + 2]);
if x & 1 == 0 {
prow[x >> 1] = v << 4;
} else {
prow[x >> 1] |= v;
}
}
} else {
for x in 0..ow {
prow[x] = repack(binned[x * 3], binned[x * 3 + 1], binned[x * 3 + 2]);
}
}
if let Some(buf) = rgb_u16.as_deref_mut() {
to_rgb_u16(prow, &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow], ow, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
to_rgba_u16(prow, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow, use_simd);
}
if let Some(buf) = rgba.as_deref_mut() {
to_rgba(prow, &mut buf[oy * 4 * ow..(oy + 1) * 4 * ow], ow, use_simd);
}
if rgb.is_some() || need_rgb_stage {
let rgb_row: &mut [u8] = match rgb.as_deref_mut() {
Some(buf) => &mut buf[oy * 3 * ow..(oy + 1) * 3 * ow],
None => &mut stage[..3 * ow],
};
to_rgb(prow, rgb_row, ow, use_simd);
if let Some(buf) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
matrix,
full_range,
use_simd,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut buf[oy * ow..(oy + 1) * ow],
ow,
matrix,
full_range,
use_simd,
);
}
if let Some(hsv) = hsv.as_mut() {
let (h, s, v) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut h[oy * ow..(oy + 1) * ow],
&mut s[oy * ow..(oy + 1) * ow],
&mut v[oy * ow..(oy + 1) * ow],
ow,
use_simd,
);
}
}
})?;
Ok(())
}
macro_rules! impl_legacy_rgb_packed_sinker {
(
marker: $marker:ident,
sink_trait: $sink_trait:ident,
row_ty: $row_ty:ident,
buf_field: $buf_field:ident,
row_slice: $row_slice:expr,
src_kind: $src_kind:tt,
to_rgb: $to_rgb:path,
to_rgba: $to_rgba:path,
to_rgb_u16: $to_rgb_u16:path,
to_rgba_u16: $to_rgba_u16:path,
unpack: $unpack:expr,
repack: $repack:expr,
) => {
impl<'a, R> MixedSinker<'a, $marker, 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> $sink_trait for MixedSinker<'_, $marker, R> {}
impl<R> PixelSink for MixedSinker<'_, $marker, R> {
type Input<'r> = $row_ty<'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.rgb_stream.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: $row_ty<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let expected = impl_legacy_rgb_packed_sinker!(@row_len $src_kind, w);
if row.$buf_field().len() != expected {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
$row_slice,
idx,
expected,
row.$buf_field().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
if let Some(plan) = self.plan.as_ref() {
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
legacy_rgb_native_scratch,
legacy_rgb_packed_scratch: packed_scratch,
rgb_stream,
resample_outputs,
..
} = self;
let expected = if rgb.is_some()
|| rgba.is_some()
|| rgb_u16.is_some()
|| rgba_u16.is_some()
|| luma.is_some()
|| luma_u16.is_some()
|| hsv.is_some()
{
Some(rgb_stream.as_ref().map_or(0, |s| s.next_y()))
} else {
None
};
if let core::ops::ControlFlow::Break(()) = 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 plan.kind().is_filter() {
return Err(plan.unsupported_filter().into());
}
let new_stream = if rgb_stream.is_none() {
let stream =
crate::resample::AreaStream::new(plan.h(), plan.v(), plan.src_w(), plan.src_h(), 3)?;
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
};
let ow = plan.out_w();
let nibble_packed = impl_legacy_rgb_packed_sinker!(@nibble $src_kind);
let pack_row_bytes = if nibble_packed { ow.div_ceil(2) } else { ow };
legacy_rgb_byte_packed_scratch(packed_scratch, pack_row_bytes, plan)?;
if rgb.is_none() && (luma.is_some() || luma_u16.is_some() || hsv.is_some()) {
source_rgb_scratch(rgb_scratch, ow, plan)?;
}
source_rgb_scratch(legacy_rgb_native_scratch, w, plan)?;
if let Some(s) = new_stream {
*rgb_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 = rgb_stream.as_mut().expect("created above");
let native = source_rgb_scratch(legacy_rgb_native_scratch, w, plan)?;
let src = row.$buf_field();
let unpack = $unpack;
for x in 0..w {
let px = impl_legacy_rgb_packed_sinker!(@read $src_kind, src, x);
let (r, g, b) = unpack(px);
native[x * 3] = r;
native[x * 3 + 1] = g;
native[x * 3 + 2] = b;
}
return legacy_rgb_packed_resample_emit(
stream,
plan,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
native,
rgb_scratch,
packed_scratch,
row.matrix(),
row.full_range(),
idx,
use_simd,
nibble_packed,
$repack,
$to_rgb,
$to_rgba,
$to_rgb_u16,
$to_rgba_u16,
);
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
..
} = self;
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let src = row.$buf_field();
if let Some(buf) = rgb_u16.as_deref_mut() {
let rgb_u16_row = rgb_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgb_u16(src, rgb_u16_row, w, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
let rgba_u16_row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgba_u16(src, rgba_u16_row, w, use_simd);
}
let want_rgb = rgb.is_some();
let want_luma = luma.is_some();
let want_luma_u16 = luma_u16.is_some();
let want_hsv = hsv.is_some();
let need_u8_rgb = want_rgb || want_luma || want_luma_u16 || want_hsv;
if !need_u8_rgb {
if let Some(buf) = rgba.as_deref_mut() {
let rgba_row = rgba_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
$to_rgba(src, rgba_row, w, use_simd);
}
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(src, rgb_row, w, use_simd);
if let Some(luma_buf) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut luma_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(luma_u16_buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut luma_u16_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(hsv_bufs) = hsv.as_mut() {
let (h, s, v) = hsv_bufs.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)?;
$to_rgba(src, rgba_row, w, use_simd);
}
Ok(())
}
}
};
(@row_len byte, $w:expr) => {
$w
};
(@row_len nibble, $w:expr) => {
($w).div_ceil(2)
};
(@read byte, $src:expr, $x:expr) => {
$src[$x]
};
(@read nibble, $src:expr, $x:expr) => {
if $x & 1 == 0 {
$src[$x >> 1] >> 4
} else {
$src[$x >> 1] & 0x0F
}
};
(@nibble byte) => {
false
};
(@nibble nibble) => {
true
};
}
impl_legacy_rgb_packed_sinker! {
marker: Rgb8,
sink_trait: Rgb8Sink,
row_ty: Rgb8Row,
buf_field: rgb8,
row_slice: RowSlice::Rgb8Packed,
src_kind: byte,
to_rgb: rgb8_to_rgb_row,
to_rgba: rgb8_to_rgba_row,
to_rgb_u16: rgb8_to_rgb_u16_row,
to_rgba_u16: rgb8_to_rgba_u16_row,
unpack: |px: u8| -> (u8, u8, u8) { ((px >> 5) & 0x07, (px >> 2) & 0x07, px & 0x03) },
repack: |r: u8, g: u8, b: u8| -> u8 { (r << 5) | (g << 2) | b },
}
impl_legacy_rgb_packed_sinker! {
marker: Bgr8,
sink_trait: Bgr8Sink,
row_ty: Bgr8Row,
buf_field: bgr8,
row_slice: RowSlice::Bgr8Packed,
src_kind: byte,
to_rgb: bgr8_to_rgb_row,
to_rgba: bgr8_to_rgba_row,
to_rgb_u16: bgr8_to_rgb_u16_row,
to_rgba_u16: bgr8_to_rgba_u16_row,
unpack: |px: u8| -> (u8, u8, u8) { (px & 0x07, (px >> 3) & 0x07, (px >> 6) & 0x03) },
repack: |r: u8, g: u8, b: u8| -> u8 { (b << 6) | (g << 3) | r },
}
impl_legacy_rgb_packed_sinker! {
marker: Rgb4Byte,
sink_trait: Rgb4ByteSink,
row_ty: Rgb4ByteRow,
buf_field: rgb4_byte,
row_slice: RowSlice::Rgb4BytePacked,
src_kind: byte,
to_rgb: rgb4_byte_to_rgb_row,
to_rgba: rgb4_byte_to_rgba_row,
to_rgb_u16: rgb4_byte_to_rgb_u16_row,
to_rgba_u16: rgb4_byte_to_rgba_u16_row,
unpack: |px: u8| -> (u8, u8, u8) { ((px >> 3) & 0x01, (px >> 1) & 0x03, px & 0x01) },
repack: |r: u8, g: u8, b: u8| -> u8 { (r << 3) | (g << 1) | b },
}
impl_legacy_rgb_packed_sinker! {
marker: Bgr4Byte,
sink_trait: Bgr4ByteSink,
row_ty: Bgr4ByteRow,
buf_field: bgr4_byte,
row_slice: RowSlice::Bgr4BytePacked,
src_kind: byte,
to_rgb: bgr4_byte_to_rgb_row,
to_rgba: bgr4_byte_to_rgba_row,
to_rgb_u16: bgr4_byte_to_rgb_u16_row,
to_rgba_u16: bgr4_byte_to_rgba_u16_row,
unpack: |px: u8| -> (u8, u8, u8) { (px & 0x01, (px >> 1) & 0x03, (px >> 3) & 0x01) },
repack: |r: u8, g: u8, b: u8| -> u8 { (b << 3) | (g << 1) | r },
}
impl_legacy_rgb_packed_sinker! {
marker: Rgb4,
sink_trait: Rgb4Sink,
row_ty: Rgb4Row,
buf_field: rgb4,
row_slice: RowSlice::Rgb4Packed,
src_kind: nibble,
to_rgb: rgb4_to_rgb_row,
to_rgba: rgb4_to_rgba_row,
to_rgb_u16: rgb4_to_rgb_u16_row,
to_rgba_u16: rgb4_to_rgba_u16_row,
unpack: |n: u8| -> (u8, u8, u8) { ((n >> 3) & 0x01, (n >> 1) & 0x03, n & 0x01) },
repack: |r: u8, g: u8, b: u8| -> u8 { (r << 3) | (g << 1) | b },
}
impl_legacy_rgb_packed_sinker! {
marker: Bgr4,
sink_trait: Bgr4Sink,
row_ty: Bgr4Row,
buf_field: bgr4,
row_slice: RowSlice::Bgr4Packed,
src_kind: nibble,
to_rgb: bgr4_to_rgb_row,
to_rgba: bgr4_to_rgba_row,
to_rgb_u16: bgr4_to_rgb_u16_row,
to_rgba_u16: bgr4_to_rgba_u16_row,
unpack: |n: u8| -> (u8, u8, u8) { (n & 0x01, (n >> 1) & 0x03, (n >> 3) & 0x01) },
repack: |r: u8, g: u8, b: u8| -> u8 { (b << 3) | (g << 1) | r },
}