use super::{
GeometryOverflow, InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange,
RowShapeMismatch, RowSlice, check_dimensions_match, packed_yuv444_triple_filter_resample,
packed_yuv444_triple_resample, rgb_row_buf_or_scratch, rgba_plane_row_slice,
rgba_u16_plane_row_slice,
};
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
use super::{NativeRouteChanged, packed_yuv444_hb_process_native};
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
use crate::resample::{AveragingDomain, InsertionContext, InsertionPoint, select_insertion_point};
use crate::{
PixelSink,
row::{
expand_rgb_to_rgba_row, expand_rgb_u16_to_rgba_u16_row, rgb_to_hsv_row, v410_to_hsv_row,
v410_to_luma_row, v410_to_luma_u16_row, v410_to_rgb_row, v410_to_rgb_u16_row, v410_to_rgba_row,
v410_to_rgba_u16_row,
},
source::{V410, V410Row, V410Sink},
};
impl<'a, R, const BE: bool> MixedSinker<'a, V410<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<const BE: bool, R> V410Sink<BE> for MixedSinker<'_, V410<BE>, R> {}
impl<const BE: bool, R> PixelSink for MixedSinker<'_, V410<BE>, R> {
type Input<'r> = V410Row<'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();
}
if let Some(stream) = self.rgb_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream_u16.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream_u16.as_mut() {
stream.reset();
}
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
if let Some(native) = self.native_planar_u16.as_mut() {
native.reset();
}
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
{
self.frozen_native_route = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: V410Row<'_>) -> Result<(), Self::Error> {
const BITS: u32 = 10;
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
let packed_expected = w;
if row.packed().len() != packed_expected {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::V410Packed,
idx,
packed_expected,
row.packed().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgb_u16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_u16,
luma_scratch_u16,
plan,
rgb_stream,
rgb_stream_u16,
luma_stream_u16,
rgb_filter_stream,
rgb_filter_stream_u16,
luma_filter_stream_u16,
resample_outputs,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
native,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
native_planar_u16,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
packed_444_y_full_u16,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
packed_444_u_full_u16,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
packed_444_v_full_u16,
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
frozen_native_route,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
let packed = row.packed();
if let crate::resample::SpanKind::Filter = plan.kind() {
return packed_yuv444_triple_filter_resample::<BITS>(
rgb_filter_stream,
rgb_filter_stream_u16,
luma_filter_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
matrix,
full_range,
|scratch| v410_to_rgb_row(packed, scratch, w, matrix, full_range, use_simd, BE),
|scratch| v410_to_rgb_u16_row(packed, scratch, w, matrix, full_range, use_simd, BE),
|scratch| v410_to_luma_u16_row(packed, scratch, w, use_simd, BE),
);
}
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
{
let need_output = 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 take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(all(feature = "yuv-444-packed", feature = "yuv-planar")),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
if take_native {
packed_yuv444_hb_process_native::<BITS>(
plan,
native_planar_u16,
packed_444_y_full_u16,
packed_444_u_full_u16,
packed_444_v_full_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_u16,
|y_dst| {
for (dst, &raw) in y_dst.iter_mut().zip(packed) {
let word = if BE {
u32::from_be(raw)
} else {
u32::from_le(raw)
};
*dst = ((word >> 10) & 0x3FF) as u16;
}
},
|u_dst, v_dst| {
for ((u, v), &raw) in u_dst.iter_mut().zip(v_dst.iter_mut()).zip(packed) {
let word = if BE {
u32::from_be(raw)
} else {
u32::from_le(raw)
};
*u = (word & 0x3FF) as u16;
*v = ((word >> 20) & 0x3FF) as u16;
}
},
matrix,
full_range,
idx,
w,
h,
use_simd,
)?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
return Ok(());
}
}
packed_yuv444_triple_resample::<BITS>(
rgb_stream,
rgb_stream_u16,
luma_stream_u16,
resample_outputs,
rgb,
rgba,
rgb_u16,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_u16,
luma_scratch_u16,
w,
plan,
idx,
use_simd,
matrix,
full_range,
|scratch| v410_to_rgb_row(packed, scratch, w, matrix, full_range, use_simd, BE),
|scratch| v410_to_rgb_u16_row(packed, scratch, w, matrix, full_range, use_simd, BE),
|scratch| v410_to_luma_u16_row(packed, scratch, w, use_simd, BE),
)?;
#[cfg(all(feature = "yuv-444-packed", feature = "yuv-planar"))]
{
let need_output = luma.is_some()
|| luma_u16.is_some()
|| rgb.is_some()
|| rgba.is_some()
|| rgb_u16.is_some()
|| rgba_u16.is_some()
|| hsv.is_some();
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
}
return Ok(());
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let packed = row.packed();
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() {
v410_to_luma_row(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
BE,
);
}
if let Some(buf) = luma_u16.as_deref_mut() {
v410_to_luma_u16_row(
packed,
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
BE,
);
}
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)?;
v410_to_rgba_u16_row(
packed,
rgba_u16_row,
w,
row.matrix(),
row.full_range(),
use_simd,
BE,
);
} else if want_rgb_u16 {
let rgb_u16_buf = rgb_u16.as_deref_mut().unwrap();
let rgb_plane_end =
one_plane_end
.checked_mul(3)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 3,
)))?;
let rgb_plane_start = one_plane_start * 3;
let rgb_u16_row = &mut rgb_u16_buf[rgb_plane_start..rgb_plane_end];
v410_to_rgb_u16_row(
packed,
rgb_u16_row,
w,
row.matrix(),
row.full_range(),
use_simd,
BE,
);
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_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_u8_rgb_kernel = want_rgb || (want_hsv && want_rgba);
if want_hsv_direct {
let hsv = hsv.as_mut().expect("want_hsv_direct implies hsv attached");
let (h, s, v) = hsv.hsv();
v410_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,
row.matrix(),
row.full_range(),
use_simd,
BE,
);
return Ok(());
}
if want_rgba && !need_u8_rgb_kernel {
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)?;
v410_to_rgba_row(
packed,
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
BE,
);
return Ok(());
}
if !need_u8_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,
)?;
v410_to_rgb_row(
packed,
rgb_row,
w,
row.matrix(),
row.full_range(),
use_simd,
BE,
);
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(())
}
}