use super::{
InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange, RowShapeMismatch,
RowSlice, check_dimensions_match, rgb_row_buf_or_scratch, rgba_plane_row_slice,
rgba_u16_plane_row_slice,
};
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
use super::{
packed_rgb_f16_resample_emit, packed_rgb_f32_resample, packed_rgb_f32_resample_filter,
};
use crate::{
PixelSink,
row::{
rgb_to_hsv_row, rgb_to_luma_row, rgb_to_luma_u16_row, rgbf16_to_rgb_f16_row,
rgbf16_to_rgb_f32_row, rgbf16_to_rgb_row, rgbf16_to_rgb_u16_row, rgbf16_to_rgba_row,
rgbf16_to_rgba_u16_row,
},
source::{Rgbf16, Rgbf16Row, Rgbf16Sink},
};
impl<'a, R, const BE: bool> MixedSinker<'a, Rgbf16<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_f16(mut self, buf: &'a mut [half::f16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f16(&mut self, buf: &'a mut [half::f16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f16 = 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)
}
fn rgbf16_process_direct(
&mut self,
row: Rgbf16Row<'_>,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
let w = self.width;
let h = self.height;
let idx = row.row();
let Self {
rgb,
rgb_u16,
rgb_f32,
rgb_f16,
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 rgb_in = row.rgb();
if let Some(buf) = rgb_f16.as_deref_mut() {
let f16_start = one_plane_start * 3;
let f16_end = one_plane_end * 3;
rgbf16_to_rgb_f16_row::<BE>(rgb_in, &mut buf[f16_start..f16_end], w, use_simd);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
let f32_start = one_plane_start * 3;
let f32_end = one_plane_end * 3;
rgbf16_to_rgb_f32_row::<BE>(rgb_in, &mut buf[f32_start..f32_end], w, use_simd);
}
if let Some(buf) = rgb_u16.as_deref_mut() {
let u16_start = one_plane_start * 3;
let u16_end = one_plane_end * 3;
rgbf16_to_rgb_u16_row::<BE>(rgb_in, &mut buf[u16_start..u16_end], w, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
let rgba_row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
rgbf16_to_rgba_u16_row::<BE>(rgb_in, rgba_row, w, use_simd);
}
let want_rgba_u8 = rgba.is_some();
let want_rgb_u8 = rgb.is_some();
let want_luma_u8 = luma.is_some();
let want_luma_u16 = luma_u16.is_some();
let want_hsv = hsv.is_some();
let need_u8_rgb = want_rgb_u8 || want_luma_u8 || want_luma_u16 || want_hsv;
if want_rgba_u8 && !need_u8_rgb {
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)?;
rgbf16_to_rgba_row::<BE>(rgb_in, rgba_row, w, use_simd);
return Ok(());
}
if !need_u8_rgb && !want_rgba_u8 {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
rgbf16_to_rgb_row::<BE>(rgb_in, rgb_row, w, use_simd);
if let Some(luma) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut luma[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(luma_buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut luma_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.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[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)?;
rgbf16_to_rgba_row::<BE>(rgb_in, rgba_row, w, use_simd);
}
Ok(())
}
}
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
impl<R, const BE: bool> Rgbf16Sink<BE> for MixedSinker<'_, Rgbf16<BE>, R> {}
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Rgbf16<BE>, R> {
type Input<'r> = Rgbf16Row<'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_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Rgbf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let idx = row.row();
let use_simd = self.simd;
if row.rgb().len() != w * 3 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::RgbF16Packed,
idx,
w * 3,
row.rgb().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgb_u16,
rgb_f32,
rgb_f16,
rgba,
rgba_u16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgb_scratch_f32,
rgb_packed_scratch_f16,
rgb_stream_f32,
rgb_filter_stream_f32,
resample_outputs,
plan,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
return match plan.kind() {
crate::resample::SpanKind::Area => packed_rgb_f32_resample(
rgb_stream_f32,
resample_outputs,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
&mut None,
rgb_f16,
&mut None,
hsv,
rgb_scratch_f32,
w,
plan,
idx,
|src_f32| crate::row::rgbf16_to_rgb_f32_row::<BE>(row.rgb(), src_f32, w, use_simd),
|stream,
src,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
_,
rgb_f16,
_,
hsv| {
packed_rgb_f16_resample_emit(
stream,
plan,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgb_f16,
hsv,
src,
rgb_packed_scratch_f16,
rgb_scratch,
matrix,
full_range,
idx,
use_simd,
)
},
),
crate::resample::SpanKind::Filter => packed_rgb_f32_resample_filter(
rgb_filter_stream_f32,
resample_outputs,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
&mut None,
rgb_f16,
&mut None,
hsv,
rgb_scratch_f32,
w,
plan,
idx,
|src_f32| crate::row::rgbf16_to_rgb_f32_row::<BE>(row.rgb(), src_f32, w, use_simd),
|stream,
src,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
_,
rgb_f16,
_,
hsv| {
packed_rgb_f16_resample_emit(
stream,
plan,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgb_f16,
hsv,
src,
rgb_packed_scratch_f16,
rgb_scratch,
matrix,
full_range,
idx,
use_simd,
)
},
),
};
}
self.rgbf16_process_direct(row, use_simd)
}
}
#[cfg(not(any(feature = "yuv-planar", feature = "rgb")))]
impl<const BE: bool> Rgbf16Sink<BE> for MixedSinker<'_, Rgbf16<BE>> {}
#[cfg(not(any(feature = "yuv-planar", feature = "rgb")))]
impl<const BE: bool> PixelSink for MixedSinker<'_, Rgbf16<BE>> {
type Input<'r> = Rgbf16Row<'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)
}
fn process(&mut self, row: Rgbf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let idx = row.row();
let use_simd = self.simd;
if row.rgb().len() != w * 3 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::RgbF16Packed,
idx,
w * 3,
row.rgb().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
self.rgbf16_process_direct(row, use_simd)
}
}
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
use super::{
packed_rgba_f16_resample_emit, packed_rgba_f32_packed_filter, packed_rgba_f32_packed_resample,
};
use crate::{
row::{
rgbaf16_to_rgb_f16_row, rgbaf16_to_rgb_f32_row, rgbaf16_to_rgb_row, rgbaf16_to_rgb_u16_row,
rgbaf16_to_rgba_f16_row, rgbaf16_to_rgba_f32_row, rgbaf16_to_rgba_row, rgbaf16_to_rgba_u16_row,
},
source::{Rgbaf16, Rgbaf16Row, Rgbaf16Sink},
};
impl<'a, R, const BE: bool> MixedSinker<'a, Rgbaf16<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_f16(mut self, buf: &'a mut [half::f16]) -> Result<Self, MixedSinkerError> {
self.set_rgb_f16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgb_f16(&mut self, buf: &'a mut [half::f16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(3)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbF16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgb_f16 = Some(buf);
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn with_rgba_f16(mut self, buf: &'a mut [half::f16]) -> Result<Self, MixedSinkerError> {
self.set_rgba_f16(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_f16(&mut self, buf: &'a mut [half::f16]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaF16Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_f16 = 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_rgba_f32(mut self, buf: &'a mut [f32]) -> Result<Self, MixedSinkerError> {
self.set_rgba_f32(buf)?;
Ok(self)
}
#[cfg_attr(not(tarpaulin), inline(always))]
pub fn set_rgba_f32(&mut self, buf: &'a mut [f32]) -> Result<&mut Self, MixedSinkerError> {
let expected = self.frame_elems(4)?;
if buf.len() < expected {
return Err(MixedSinkerError::InsufficientRgbaF32Buffer(
InsufficientBuffer::new(expected, buf.len()),
));
}
self.rgba_f32 = Some(buf);
Ok(self)
}
fn rgbaf16_process_direct(
&mut self,
row: Rgbaf16Row<'_>,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
let w = self.width;
let h = self.height;
let idx = row.row();
let Self {
rgb,
rgb_u16,
rgb_f32,
rgb_f16,
rgba,
rgba_u16,
rgba_f32,
rgba_f16,
luma,
luma_u16,
hsv,
rgb_scratch,
..
} = self;
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
let rgba_in = row.rgba();
if let Some(buf) = rgba_f16.as_deref_mut() {
let start = one_plane_start * 4;
let end = one_plane_end * 4;
rgbaf16_to_rgba_f16_row::<BE>(rgba_in, &mut buf[start..end], w, use_simd);
}
if let Some(buf) = rgb_f16.as_deref_mut() {
let start = one_plane_start * 3;
let end = one_plane_end * 3;
rgbaf16_to_rgb_f16_row::<BE>(rgba_in, &mut buf[start..end], w, use_simd);
}
if let Some(buf) = rgba_f32.as_deref_mut() {
let start = one_plane_start * 4;
let end = one_plane_end * 4;
rgbaf16_to_rgba_f32_row::<BE>(rgba_in, &mut buf[start..end], w, use_simd);
}
if let Some(buf) = rgb_f32.as_deref_mut() {
let start = one_plane_start * 3;
let end = one_plane_end * 3;
rgbaf16_to_rgb_f32_row::<BE>(rgba_in, &mut buf[start..end], w, use_simd);
}
if let Some(buf) = rgb_u16.as_deref_mut() {
let start = one_plane_start * 3;
let end = one_plane_end * 3;
rgbaf16_to_rgb_u16_row::<BE>(rgba_in, &mut buf[start..end], w, use_simd);
}
if let Some(buf) = rgba_u16.as_deref_mut() {
let rgba_row = rgba_u16_plane_row_slice(buf, one_plane_start, one_plane_end, w, h)?;
rgbaf16_to_rgba_u16_row::<BE>(rgba_in, rgba_row, w, use_simd);
}
let want_rgba_u8 = rgba.is_some();
let want_rgb_u8 = rgb.is_some();
let want_luma_u8 = luma.is_some();
let want_luma_u16 = luma_u16.is_some();
let want_hsv = hsv.is_some();
let need_u8_rgb = want_rgb_u8 || want_luma_u8 || want_luma_u16 || want_hsv;
if want_rgba_u8 && !need_u8_rgb {
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)?;
rgbaf16_to_rgba_row::<BE>(rgba_in, rgba_row, w, use_simd);
return Ok(());
}
if !need_u8_rgb && !want_rgba_u8 {
return Ok(());
}
let rgb_row = rgb_row_buf_or_scratch(
rgb.as_deref_mut(),
rgb_scratch,
one_plane_start,
one_plane_end,
w,
h,
)?;
rgbaf16_to_rgb_row::<BE>(rgba_in, rgb_row, w, use_simd);
if let Some(luma) = luma.as_deref_mut() {
rgb_to_luma_row(
rgb_row,
&mut luma[one_plane_start..one_plane_end],
w,
row.matrix(),
row.full_range(),
use_simd,
);
}
if let Some(luma_buf) = luma_u16.as_deref_mut() {
rgb_to_luma_u16_row(
rgb_row,
&mut luma_buf[one_plane_start..one_plane_end],
w,
row.matrix(),
row.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[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)?;
rgbaf16_to_rgba_row::<BE>(rgba_in, rgba_row, w, use_simd);
}
Ok(())
}
}
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
impl<R, const BE: bool> Rgbaf16Sink<BE> for MixedSinker<'_, Rgbaf16<BE>, R> {}
#[cfg(any(feature = "yuv-planar", feature = "rgb"))]
impl<R, const BE: bool> PixelSink for MixedSinker<'_, Rgbaf16<BE>, R> {
type Input<'r> = Rgbaf16Row<'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_f32.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgba_filter_stream_f32.as_mut() {
stream.reset();
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Rgbaf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let idx = row.row();
let use_simd = self.simd;
if row.rgba().len() != w * 4 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::RgbaF16Packed,
idx,
w * 4,
row.rgba().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgb_u16,
rgb_f32,
rgb_f16,
rgba,
rgba_u16,
rgba_f32,
rgba_f16,
luma,
luma_u16,
hsv,
rgb_scratch,
rgba_scratch_f32,
rgba_packed_scratch_f16,
rgba_stream_f32,
rgba_filter_stream_f32,
resample_outputs,
plan,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
return match plan.kind() {
crate::resample::SpanKind::Area => packed_rgba_f32_packed_resample(
rgba_stream_f32,
resample_outputs,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv,
rgba_scratch_f32,
w,
plan,
idx,
|src_rgba| crate::row::rgbaf16_to_rgba_f32_row::<BE>(row.rgba(), src_rgba, w, use_simd),
|stream,
src,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv| {
packed_rgba_f16_resample_emit(
stream,
plan,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv,
src,
rgba_packed_scratch_f16,
rgb_scratch,
matrix,
full_range,
idx,
use_simd,
)
},
),
crate::resample::SpanKind::Filter => packed_rgba_f32_packed_filter(
rgba_filter_stream_f32,
resample_outputs,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv,
rgba_scratch_f32,
w,
plan,
idx,
|src_rgba| crate::row::rgbaf16_to_rgba_f32_row::<BE>(row.rgba(), src_rgba, w, use_simd),
|stream,
src,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv| {
packed_rgba_f16_resample_emit(
stream,
plan,
rgb,
rgba,
luma,
rgb_u16,
rgba_u16,
luma_u16,
rgb_f32,
rgba_f32,
rgb_f16,
rgba_f16,
hsv,
src,
rgba_packed_scratch_f16,
rgb_scratch,
matrix,
full_range,
idx,
use_simd,
)
},
),
};
}
self.rgbaf16_process_direct(row, use_simd)
}
}
#[cfg(not(any(feature = "yuv-planar", feature = "rgb")))]
impl<const BE: bool> Rgbaf16Sink<BE> for MixedSinker<'_, Rgbaf16<BE>> {}
#[cfg(not(any(feature = "yuv-planar", feature = "rgb")))]
impl<const BE: bool> PixelSink for MixedSinker<'_, Rgbaf16<BE>> {
type Input<'r> = Rgbaf16Row<'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)
}
fn process(&mut self, row: Rgbaf16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let idx = row.row();
let use_simd = self.simd;
if row.rgba().len() != w * 4 {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::RgbaF16Packed,
idx,
w * 4,
row.rgba().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
self.rgbaf16_process_direct(row, use_simd)
}
}