use super::{
GeometryOverflow, InsufficientBuffer, MixedSinker, MixedSinkerError, RowIndexOutOfRange,
RowShapeMismatch, RowSlice, WidthAlignment, check_dimensions_match,
planar_resample::{planar_dual_filter_resample, planar_dual_resample},
rgb_row_buf_or_scratch, rgba_plane_row_slice,
};
use crate::{PixelSink, row::*, source::*};
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
use super::{
ChromaSitingChanged, HsvFrameMut, NativeRouteChanged, chroma_420_bottom_sited_v,
chroma_420_center_sited_h, chroma_420_top_sited_v, chroma_422_center_sited_h,
planar_8bit::{
NativePlanarYuv, YUV422P_CENTERED_H_PHASE, native_planar_preflight_check_only,
reserve_420_chroma_full, reserve_420_chroma_prev, stage_420_chroma_prev,
upsample_420_chroma_sited, yuv_planar_process_native, yuv420p_process_native,
},
};
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
use crate::{
KernelMatrix,
resample::{
AveragingDomain, InsertionContext, InsertionPoint, PlanGeometry, ResampleError, ResamplePlan,
select_insertion_point,
},
};
#[cfg(all(
test,
feature = "std",
feature = "yuv-semi-planar",
feature = "yuv-planar"
))]
std::thread_local! {
static FORCE_DEINTERLEAVE_ALLOC_FAILURE: core::cell::Cell<bool> =
const { core::cell::Cell::new(false) };
}
#[cfg(all(
test,
feature = "std",
feature = "yuv-semi-planar",
feature = "yuv-planar",
feature = "rgb"
))]
pub(super) fn arm_deinterleave_alloc_failure() {
FORCE_DEINTERLEAVE_ALLOC_FAILURE.with(|f| f.set(true));
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
#[allow(clippy::too_many_arguments)]
fn semi_planar_process_native(
plan: &ResamplePlan,
native_420: &mut Option<std::boxed::Box<super::planar_8bit::NativeYuv420>>,
u_scratch: &mut std::vec::Vec<u8>,
v_scratch: &mut std::vec::Vec<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<HsvFrameMut<'_>>,
rgb_scratch: &mut std::vec::Vec<u8>,
y_row: &[u8],
chroma_uv: &[u8],
swap_uv: bool,
chroma_h_phase: f64,
chroma_v_phase: f64,
chroma_v_top: bool,
matrix: KernelMatrix,
full_range: bool,
idx: usize,
w: usize,
h: usize,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
let need_luma = luma.is_some() || luma_u16.is_some();
let need_color = rgb.is_some() || rgba.is_some() || hsv.is_some();
let cw = w / 2;
if !super::planar_8bit::yuv420p_native_preflight_check_only(
native_420,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
idx,
need_luma,
need_color,
)? {
return Ok(());
}
let chroma_row = need_color && idx.is_multiple_of(2);
if chroma_row {
for scratch in [&mut *u_scratch, &mut *v_scratch] {
if scratch.len() < cw {
#[cfg(all(
test,
feature = "std",
feature = "yuv-semi-planar",
feature = "yuv-planar"
))]
if FORCE_DEINTERLEAVE_ALLOC_FAILURE.with(|f| f.take()) {
return Err(MixedSinkerError::Resample(ResampleError::AllocationFailed(
PlanGeometry::new(w, h, plan.out_w(), plan.out_h()),
)));
}
scratch.try_reserve_exact(cw - scratch.len()).map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w,
h,
plan.out_w(),
plan.out_h(),
)))
})?;
scratch.resize(cw, 0);
}
}
let (u_off, v_off) = if swap_uv { (1, 0) } else { (0, 1) };
for (i, pair) in chroma_uv.as_chunks::<2>().0.iter().enumerate() {
u_scratch[i] = pair[u_off];
v_scratch[i] = pair[v_off];
}
}
let (u_half, v_half): (&[u8], &[u8]) = if chroma_row {
(&u_scratch[..cw], &v_scratch[..cw])
} else {
(&[], &[])
};
yuv420p_process_native(
plan,
native_420,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
y_row,
u_half,
v_half,
matrix,
full_range,
idx,
w,
h,
|| {
ResamplePlan::area_chroma_420(
w / 2,
h,
plan.out_w(),
plan.out_h(),
chroma_h_phase,
chroma_v_phase,
chroma_v_top,
)
},
use_simd,
)
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
#[allow(clippy::too_many_arguments)]
fn semi_planar_process_native_non420(
plan: &ResamplePlan,
native_planar: &mut Option<std::boxed::Box<NativePlanarYuv>>,
u_scratch: &mut std::vec::Vec<u8>,
v_scratch: &mut std::vec::Vec<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<HsvFrameMut<'_>>,
rgb_scratch: &mut std::vec::Vec<u8>,
y_row: &[u8],
chroma_uv: &[u8],
chroma_w: usize,
swap_uv: bool,
chroma_h_phase: f64,
matrix: KernelMatrix,
full_range: bool,
idx: usize,
w: usize,
h: usize,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
let need_luma = luma.is_some() || luma_u16.is_some();
let need_color = rgb.is_some() || rgba.is_some() || hsv.is_some();
if !native_planar_preflight_check_only(
native_planar,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
idx,
need_luma,
need_color,
)? {
return Ok(());
}
if need_color {
for scratch in [&mut *u_scratch, &mut *v_scratch] {
if scratch.len() < chroma_w {
scratch
.try_reserve_exact(chroma_w - scratch.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w,
h,
plan.out_w(),
plan.out_h(),
)))
})?;
scratch.resize(chroma_w, 0);
}
}
let (u_off, v_off) = if swap_uv { (1, 0) } else { (0, 1) };
for (i, pair) in chroma_uv.as_chunks::<2>().0.iter().enumerate() {
u_scratch[i] = pair[u_off];
v_scratch[i] = pair[v_off];
}
}
let (u_plane, v_plane): (&[u8], &[u8]) = if need_color {
(&u_scratch[..chroma_w], &v_scratch[..chroma_w])
} else {
(&[], &[])
};
yuv_planar_process_native(
plan,
native_planar,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
y_row,
u_plane,
v_plane,
matrix,
full_range,
idx,
w,
h,
1,
|| ResamplePlan::area_chroma_422(chroma_w, h, plan.out_w(), plan.out_h(), chroma_h_phase, 0.0),
use_simd,
)
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
fn reserve_nv_chroma_half(
u_half: &mut std::vec::Vec<u8>,
v_half: &mut std::vec::Vec<u8>,
width: usize,
height: usize,
) -> Result<(), MixedSinkerError> {
let cw = width / 2;
for scratch in [u_half, v_half] {
if scratch.len() < cw {
scratch.try_reserve_exact(cw - scratch.len()).map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
width, height, width, height,
)))
})?;
scratch.resize(cw, 0);
}
}
Ok(())
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
fn nv_deinterleave_chroma_half(
u_half: &mut [u8],
v_half: &mut [u8],
uv: &[u8],
width: usize,
swap_uv: bool,
) {
let cw = width / 2;
debug_assert!(
u_half.len() >= cw && v_half.len() >= cw,
"half-width chroma scratch must be reserved via reserve_nv_chroma_half first"
);
let (u_off, v_off) = if swap_uv { (1, 0) } else { (0, 1) };
for (i, pair) in uv.as_chunks::<2>().0.iter().take(cw).enumerate() {
u_half[i] = pair[u_off];
v_half[i] = pair[v_off];
}
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
#[allow(clippy::too_many_arguments)]
fn nv_center_upsample_chroma<'s>(
chroma_full: &'s mut [u8],
chroma_prev: &mut [u8],
chroma_prev_row: &mut Option<usize>,
u_half: &mut [u8],
v_half: &mut [u8],
uv: &[u8],
idx: usize,
bottom_v: bool,
center_h: bool,
stage: bool,
width: usize,
swap_uv: bool,
use_simd: bool,
) -> (&'s [u8], &'s [u8]) {
let cw = width / 2;
nv_deinterleave_chroma_half(u_half, v_half, uv, width, swap_uv);
upsample_420_chroma_sited(
chroma_full,
chroma_prev,
chroma_prev_row,
&u_half[..cw],
&v_half[..cw],
idx,
bottom_v,
center_h,
stage,
width,
use_simd,
)
}
#[cfg(all(feature = "yuv-semi-planar", feature = "yuv-planar"))]
#[allow(clippy::too_many_arguments)]
fn nv_yuv444_identity_color_row(
rgb: &mut Option<&mut [u8]>,
rgba: &mut Option<&mut [u8]>,
hsv: &mut Option<HsvFrameMut<'_>>,
rgb_scratch: &mut std::vec::Vec<u8>,
y: &[u8],
u_full: &[u8],
v_full: &[u8],
one_plane_start: usize,
one_plane_end: usize,
w: usize,
h: usize,
matrix: KernelMatrix,
full_range: bool,
use_simd: bool,
) -> Result<(), MixedSinkerError> {
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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 (hh, ss, vv) = hsv.hsv();
yuv_444_to_hsv_row(
y,
u_full,
v_full,
&mut hh[one_plane_start..one_plane_end],
&mut ss[one_plane_start..one_plane_end],
&mut vv[one_plane_start..one_plane_end],
w,
matrix,
full_range,
use_simd,
);
return Ok(());
}
if want_rgba && !need_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)?;
yuv_444_to_rgba_row(y, u_full, v_full, rgba_row, w, matrix, full_range, use_simd);
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,
)?;
yuv_444_to_rgb_row(y, u_full, v_full, rgb_row, w, matrix, full_range, use_simd);
if let Some(hsv) = hsv.as_mut() {
let (hh, ss, vv) = hsv.hsv();
rgb_to_hsv_row(
rgb_row,
&mut hh[one_plane_start..one_plane_end],
&mut ss[one_plane_start..one_plane_end],
&mut vv[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(())
}
impl<'a, R> MixedSinker<'a, Nv12, 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> Nv12Sink for MixedSinker<'_, Nv12, R> {}
impl<R> PixelSink for MixedSinker<'_, Nv12, R> {
type Input<'r> = Nv12Row<'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> {
if self.width & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(
self.width,
)));
}
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.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
#[cfg(feature = "yuv-planar")]
if let Some(native) = self.native_420.as_mut() {
native.reset();
}
#[cfg(feature = "yuv-planar")]
{
self.frozen_native_route = None;
self.frozen_chroma_centered = None;
self.frozen_chroma_bottom_v = None;
self.frozen_chroma_top_v = None;
self.chroma_prev_row = None;
self.chroma_top_pending = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Nv12Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
#[cfg(feature = "yuv-planar")]
let chroma_location = self.chroma_location.clone();
if w & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(w)));
}
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if row.uv_half().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::UvHalf,
idx,
w,
row.uv_half().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
rgb_stream,
luma_stream,
rgb_filter_stream,
luma_filter_stream,
resample_outputs,
#[cfg(feature = "yuv-planar")]
native,
#[cfg(feature = "yuv-planar")]
native_420,
#[cfg(feature = "yuv-planar")]
semi_planar_u_half,
#[cfg(feature = "yuv-planar")]
semi_planar_v_half,
#[cfg(feature = "yuv-planar")]
frozen_native_route,
#[cfg(feature = "yuv-planar")]
frozen_chroma_centered,
#[cfg(feature = "yuv-planar")]
frozen_chroma_bottom_v,
#[cfg(feature = "yuv-planar")]
frozen_chroma_top_v,
#[cfg(feature = "yuv-planar")]
chroma_top_pending,
#[cfg(feature = "yuv-planar")]
chroma_top_y,
#[cfg(feature = "yuv-planar")]
chroma_full,
#[cfg(feature = "yuv-planar")]
chroma_prev,
#[cfg(feature = "yuv-planar")]
chroma_prev_row,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
let convert_rgb = |scratch: &mut [u8]| {
nv12_to_rgb_row(
row.y(),
row.uv_half(),
scratch,
w,
matrix,
full_range,
use_simd,
);
};
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_420_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
let bottom_v = chroma_420_bottom_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let top_v = chroma_420_top_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let chroma_h_phase = if center_sited {
YUV422P_CENTERED_H_PHASE
} else {
0.0
};
#[cfg(feature = "yuv-planar")]
let chroma_v_phase = if bottom_v { 1.0 } else { 0.0 };
#[cfg(feature = "yuv-planar")]
let want_color = rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
let need_output =
luma.is_some() || luma_u16.is_some() || rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& (frozen != center_sited
|| *frozen_chroma_bottom_v != Some(bottom_v)
|| *frozen_chroma_top_v != Some(top_v))
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
if plan.kind().is_filter() {
#[cfg(feature = "yuv-planar")]
{
plan.ensure_single_kernel_filter()?;
if top_v && want_color {
let is_last = idx + 1 == h;
let need_luma = luma.is_some() || luma_u16.is_some();
let cursor = if need_luma {
luma_filter_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_filter_stream.as_ref().map_or(0, |s| s.next_y())
};
let expected_source = cursor + usize::from(chroma_top_pending.is_some());
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected_source),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
reserve_420_chroma_prev(chroma_prev, w, h)?;
if chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
if idx & 1 == 0 {
if let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take() {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
true,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
&chroma_top_y[..w],
w,
plan,
p_idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
&chroma_top_y[..w],
u_full,
v_full,
scratch,
w,
p_matrix,
p_full_range,
use_simd,
);
},
)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
} else if !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, matrix, full_range));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
w,
false,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
if (center_sited || bottom_v) && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_filter_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_filter_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if bottom_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
bottom_v,
center_sited,
false,
w,
false,
use_simd,
);
let r = planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
);
if r.is_ok() && bottom_v {
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
if r.is_ok() && need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return r;
}
}
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
let take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(feature = "yuv-planar"),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if take_native {
let stale_native = idx == 0
&& native_420.as_ref().is_some_and(|join| {
join.has_chroma()
&& (join.chroma_centered() != center_sited
|| join.chroma_bottom() != bottom_v
|| join.chroma_top() != top_v)
&& join.next_y() == 0
});
let prev_native = if stale_native {
native_420.take()
} else {
None
};
let native_result = semi_planar_process_native(
plan,
native_420,
semi_planar_u_half,
semi_planar_v_half,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
row.uv_half(),
false,
chroma_h_phase,
chroma_v_phase,
top_v,
matrix,
full_range,
idx,
w,
h,
use_simd,
);
if stale_native && native_result.is_err() {
*native_420 = prev_native;
}
native_result?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color {
let is_last = idx + 1 == h;
let need_luma = luma.is_some() || luma_u16.is_some();
let cursor = if need_luma {
luma_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_stream.as_ref().map_or(0, |s| s.next_y())
};
let expected_source = cursor + usize::from(chroma_top_pending.is_some());
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected_source),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
reserve_420_chroma_prev(chroma_prev, w, h)?;
if chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
if idx & 1 == 0 {
if let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take() {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
true,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
&chroma_top_y[..w],
w,
plan,
p_idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
&chroma_top_y[..w],
u_full,
v_full,
scratch,
w,
p_matrix,
p_full_range,
use_simd,
);
},
)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
} else if !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, matrix, full_range));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
w,
false,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
if (center_sited || bottom_v) && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if bottom_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
bottom_v,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
if bottom_v {
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
#[cfg(feature = "yuv-planar")]
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let want_color = want_rgb || want_rgba || want_hsv;
let need_output = want_color || luma.is_some() || luma_u16.is_some();
if !need_output {
return Ok(());
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_420_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
let bottom_v = chroma_420_bottom_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let top_v = chroma_420_top_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& (frozen != center_sited
|| *frozen_chroma_bottom_v != Some(bottom_v)
|| *frozen_chroma_top_v != Some(top_v))
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if (center_sited || bottom_v || top_v) && (want_rgb || want_rgba || want_hsv) {
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
}
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,
)?;
}
#[cfg(feature = "yuv-planar")]
if bottom_v || top_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if !want_color {
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
w,
false,
);
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color && chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
if let Some(luma) = luma.as_deref_mut() {
nv_to_luma_row(row.y(), &mut luma[one_plane_start..one_plane_end], w);
}
if let Some(buf) = luma_u16.as_deref_mut() {
crate::row::y_plane_to_luma_u16_row(
row.y(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color {
let is_last = idx + 1 == h;
if idx & 1 == 0
&& let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take()
{
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
true,
center_sited,
false,
w,
false,
use_simd,
);
nv_yuv444_identity_color_row(
rgb,
rgba,
hsv,
rgb_scratch,
&chroma_top_y[..w],
u_full,
v_full,
p_idx * w,
p_idx * w + w,
w,
h,
p_matrix,
p_full_range,
use_simd,
)?;
}
if idx & 1 == 1 && !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, row.matrix(), row.full_range()));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
w,
false,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
nv_yuv444_identity_color_row(
rgb,
rgba,
hsv,
rgb_scratch,
row.y(),
u_full,
v_full,
one_plane_start,
one_plane_end,
w,
h,
row.matrix(),
row.full_range(),
use_simd,
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
return Ok(());
}
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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();
#[cfg(feature = "yuv-planar")]
if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
bottom_v,
center_sited,
true,
w,
false,
use_simd,
);
yuv_444_to_hsv_row(
row.y(),
u_full,
v_full,
&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,
);
return Ok(());
}
nv12_to_hsv_row(
row.y(),
row.uv_half(),
&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,
);
return Ok(());
}
if want_rgba && !need_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)?;
#[cfg(feature = "yuv-planar")]
if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
bottom_v,
center_sited,
true,
w,
false,
use_simd,
);
yuv_444_to_rgba_row(
row.y(),
u_full,
v_full,
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
return Ok(());
}
nv12_to_rgba_row(
row.y(),
row.uv_half(),
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
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,
)?;
#[cfg(feature = "yuv-planar")]
let centered = if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv_half(),
idx,
bottom_v,
center_sited,
true,
w,
false,
use_simd,
);
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
rgb_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
true
} else {
false
};
#[cfg(not(feature = "yuv-planar"))]
let centered = false;
if !centered {
nv12_to_rgb_row(
row.y(),
row.uv_half(),
rgb_row,
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)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
impl<'a, R> MixedSinker<'a, Nv16, 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> Nv16Sink for MixedSinker<'_, Nv16, R> {}
impl<R> PixelSink for MixedSinker<'_, Nv16, R> {
type Input<'r> = Nv16Row<'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> {
if self.width & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(
self.width,
)));
}
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.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
#[cfg(feature = "yuv-planar")]
if let Some(native) = self.native_planar.as_mut() {
native.reset();
}
#[cfg(feature = "yuv-planar")]
{
self.frozen_native_route = None;
self.frozen_chroma_centered = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Nv16Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
if w & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(w)));
}
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if row.uv().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::UvHalf,
idx,
w,
row.uv().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
#[cfg(feature = "yuv-planar")]
let chroma_location = self.chroma_location.clone();
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
rgb_stream,
luma_stream,
rgb_filter_stream,
luma_filter_stream,
resample_outputs,
#[cfg(feature = "yuv-planar")]
native,
#[cfg(feature = "yuv-planar")]
native_planar,
#[cfg(feature = "yuv-planar")]
semi_planar_u_half,
#[cfg(feature = "yuv-planar")]
semi_planar_v_half,
#[cfg(feature = "yuv-planar")]
frozen_native_route,
#[cfg(feature = "yuv-planar")]
frozen_chroma_centered,
#[cfg(feature = "yuv-planar")]
chroma_full,
#[cfg(feature = "yuv-planar")]
chroma_prev,
#[cfg(feature = "yuv-planar")]
chroma_prev_row,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
let convert_rgb = |scratch: &mut [u8]| {
nv12_to_rgb_row(row.y(), row.uv(), scratch, w, matrix, full_range, use_simd);
};
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_422_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
let chroma_h_phase = if center_sited {
YUV422P_CENTERED_H_PHASE
} else {
0.0
};
#[cfg(feature = "yuv-planar")]
let want_color = rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
let need_output =
luma.is_some() || luma_u16.is_some() || rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& frozen != center_sited
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
if plan.kind().is_filter() {
#[cfg(feature = "yuv-planar")]
{
plan.ensure_single_kernel_filter()?;
if center_sited && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_filter_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_filter_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
let r = planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
);
if r.is_ok() && need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
}
return r;
}
}
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
let take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(feature = "yuv-planar"),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if take_native {
let stale_native = idx == 0
&& native_planar.as_ref().is_some_and(|join| {
join.has_chroma() && join.chroma_centered() != center_sited && join.next_y() == 0
});
let prev_native = if stale_native {
native_planar.take()
} else {
None
};
let native_result = semi_planar_process_native_non420(
plan,
native_planar,
semi_planar_u_half,
semi_planar_v_half,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
row.uv(),
w / 2,
false,
chroma_h_phase,
matrix,
full_range,
idx,
w,
h,
use_simd,
);
if stale_native && native_result.is_err() {
*native_planar = prev_native;
}
native_result?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
if center_sited && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
}
return Ok(());
}
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
#[cfg(feature = "yuv-planar")]
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
}
return Ok(());
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let need_output = want_rgb || want_rgba || want_hsv || luma.is_some() || luma_u16.is_some();
if !need_output {
return Ok(());
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_422_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& frozen != center_sited
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if center_sited && (want_rgb || want_rgba || want_hsv) {
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
}
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,
)?;
}
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
}
if let Some(luma) = luma.as_deref_mut() {
nv_to_luma_row(row.y(), &mut luma[one_plane_start..one_plane_end], w);
}
if let Some(buf) = luma_u16.as_deref_mut() {
crate::row::y_plane_to_luma_u16_row(
row.y(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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();
#[cfg(feature = "yuv-planar")]
if center_sited {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
yuv_444_to_hsv_row(
row.y(),
u_full,
v_full,
&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,
);
return Ok(());
}
nv12_to_hsv_row(
row.y(),
row.uv(),
&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,
);
return Ok(());
}
if want_rgba && !need_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)?;
#[cfg(feature = "yuv-planar")]
if center_sited {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
yuv_444_to_rgba_row(
row.y(),
u_full,
v_full,
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
return Ok(());
}
nv12_to_rgba_row(
row.y(),
row.uv(),
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
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,
)?;
#[cfg(feature = "yuv-planar")]
let centered = if center_sited {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.uv(),
idx,
false,
center_sited,
false,
w,
false,
use_simd,
);
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
rgb_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
true
} else {
false
};
#[cfg(not(feature = "yuv-planar"))]
let centered = false;
if !centered {
nv12_to_rgb_row(
row.y(),
row.uv(),
rgb_row,
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)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
impl<'a, R> MixedSinker<'a, Nv21, 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> Nv21Sink for MixedSinker<'_, Nv21, R> {}
impl<R> PixelSink for MixedSinker<'_, Nv21, R> {
type Input<'r> = Nv21Row<'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> {
if self.width & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(
self.width,
)));
}
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.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
#[cfg(feature = "yuv-planar")]
if let Some(native) = self.native_420.as_mut() {
native.reset();
}
#[cfg(feature = "yuv-planar")]
{
self.frozen_native_route = None;
self.frozen_chroma_centered = None;
self.frozen_chroma_bottom_v = None;
self.frozen_chroma_top_v = None;
self.chroma_prev_row = None;
self.chroma_top_pending = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Nv21Row<'_>) -> Result<(), Self::Error> {
let w = self.width;
let h = self.height;
let idx = row.row();
let use_simd = self.simd;
#[cfg(feature = "yuv-planar")]
let chroma_location = self.chroma_location.clone();
if w & 1 != 0 {
return Err(MixedSinkerError::WidthAlignment(WidthAlignment::odd(w)));
}
if row.y().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::Y,
idx,
w,
row.y().len(),
)));
}
if row.vu_half().len() != w {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::VuHalf,
idx,
w,
row.vu_half().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
rgb_stream,
luma_stream,
rgb_filter_stream,
luma_filter_stream,
resample_outputs,
#[cfg(feature = "yuv-planar")]
native,
#[cfg(feature = "yuv-planar")]
native_420,
#[cfg(feature = "yuv-planar")]
semi_planar_u_half,
#[cfg(feature = "yuv-planar")]
semi_planar_v_half,
#[cfg(feature = "yuv-planar")]
frozen_native_route,
#[cfg(feature = "yuv-planar")]
frozen_chroma_centered,
#[cfg(feature = "yuv-planar")]
frozen_chroma_bottom_v,
#[cfg(feature = "yuv-planar")]
frozen_chroma_top_v,
#[cfg(feature = "yuv-planar")]
chroma_top_pending,
#[cfg(feature = "yuv-planar")]
chroma_top_y,
#[cfg(feature = "yuv-planar")]
chroma_full,
#[cfg(feature = "yuv-planar")]
chroma_prev,
#[cfg(feature = "yuv-planar")]
chroma_prev_row,
..
} = self;
if let Some(plan) = plan.as_ref() {
let matrix = row.matrix();
let full_range = row.full_range();
let convert_rgb = |scratch: &mut [u8]| {
nv21_to_rgb_row(
row.y(),
row.vu_half(),
scratch,
w,
matrix,
full_range,
use_simd,
);
};
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_420_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
let bottom_v = chroma_420_bottom_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let top_v = chroma_420_top_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let chroma_h_phase = if center_sited {
YUV422P_CENTERED_H_PHASE
} else {
0.0
};
#[cfg(feature = "yuv-planar")]
let chroma_v_phase = if bottom_v { 1.0 } else { 0.0 };
#[cfg(feature = "yuv-planar")]
let want_color = rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
let need_output =
luma.is_some() || luma_u16.is_some() || rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& (frozen != center_sited
|| *frozen_chroma_bottom_v != Some(bottom_v)
|| *frozen_chroma_top_v != Some(top_v))
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
if plan.kind().is_filter() {
#[cfg(feature = "yuv-planar")]
{
plan.ensure_single_kernel_filter()?;
if top_v && want_color {
let is_last = idx + 1 == h;
let need_luma = luma.is_some() || luma_u16.is_some();
let cursor = if need_luma {
luma_filter_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_filter_stream.as_ref().map_or(0, |s| s.next_y())
};
let expected_source = cursor + usize::from(chroma_top_pending.is_some());
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected_source),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
reserve_420_chroma_prev(chroma_prev, w, h)?;
if chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
if idx & 1 == 0 {
if let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take() {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
true,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
&chroma_top_y[..w],
w,
plan,
p_idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
&chroma_top_y[..w],
u_full,
v_full,
scratch,
w,
p_matrix,
p_full_range,
use_simd,
);
},
)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
false,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
} else if !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, matrix, full_range));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
w,
true,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
false,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
if (center_sited || bottom_v) && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_filter_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_filter_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if bottom_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
bottom_v,
center_sited,
false,
w,
true,
use_simd,
);
let r = planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
);
if r.is_ok() && bottom_v {
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
if r.is_ok() && need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return r;
}
}
planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
let take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(feature = "yuv-planar"),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if take_native {
let stale_native = idx == 0
&& native_420.as_ref().is_some_and(|join| {
join.has_chroma()
&& (join.chroma_centered() != center_sited
|| join.chroma_bottom() != bottom_v
|| join.chroma_top() != top_v)
&& join.next_y() == 0
});
let prev_native = if stale_native {
native_420.take()
} else {
None
};
let native_result = semi_planar_process_native(
plan,
native_420,
semi_planar_u_half,
semi_planar_v_half,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
row.vu_half(),
true,
chroma_h_phase,
chroma_v_phase,
top_v,
matrix,
full_range,
idx,
w,
h,
use_simd,
);
if stale_native && native_result.is_err() {
*native_420 = prev_native;
}
native_result?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color {
let is_last = idx + 1 == h;
let need_luma = luma.is_some() || luma_u16.is_some();
let cursor = if need_luma {
luma_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_stream.as_ref().map_or(0, |s| s.next_y())
};
let expected_source = cursor + usize::from(chroma_top_pending.is_some());
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected_source),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
reserve_420_chroma_prev(chroma_prev, w, h)?;
if chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
if idx & 1 == 0 {
if let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take() {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
true,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
&chroma_top_y[..w],
w,
plan,
p_idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
&chroma_top_y[..w],
u_full,
v_full,
scratch,
w,
p_matrix,
p_full_range,
use_simd,
);
},
)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
false,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
} else if !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, matrix, full_range));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
w,
true,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
false,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
#[cfg(feature = "yuv-planar")]
if (center_sited || bottom_v) && want_color {
let need_luma = luma.is_some() || luma_u16.is_some();
let expected = if need_luma {
luma_stream.as_ref().map_or(0, |s| s.next_y())
} else {
rgb_stream.as_ref().map_or(0, |s| s.next_y())
};
if let core::ops::ControlFlow::Break(()) = super::resample_preflight_check_only(
resample_outputs,
luma,
luma_u16,
rgb,
rgba,
&None,
&None,
&None,
&None,
&None,
&None,
&None,
hsv,
&None,
Some(expected),
idx,
)? {
return Ok(());
}
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if bottom_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
}
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
bottom_v,
center_sited,
false,
w,
true,
use_simd,
);
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
|scratch| {
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
scratch,
w,
matrix,
full_range,
use_simd,
);
},
)?;
if bottom_v {
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(false);
}
#[cfg(feature = "yuv-planar")]
if frozen_chroma_centered.is_none() && need_output {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
return Ok(());
}
let want_rgb = rgb.is_some();
let want_rgba = rgba.is_some();
let want_hsv = hsv.is_some();
let want_color = want_rgb || want_rgba || want_hsv;
let need_output = want_color || luma.is_some() || luma_u16.is_some();
if !need_output {
return Ok(());
}
let one_plane_start = idx * w;
let one_plane_end = one_plane_start + w;
#[cfg(feature = "yuv-planar")]
let center_sited = chroma_420_center_sited_h(&chroma_location);
#[cfg(feature = "yuv-planar")]
let bottom_v = chroma_420_bottom_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
let top_v = chroma_420_top_sited_v(&chroma_location);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_chroma_centered
&& (frozen != center_sited
|| *frozen_chroma_bottom_v != Some(bottom_v)
|| *frozen_chroma_top_v != Some(top_v))
{
return Err(MixedSinkerError::ChromaSitingChanged(
ChromaSitingChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if (center_sited || bottom_v || top_v) && (want_rgb || want_rgba || want_hsv) {
reserve_420_chroma_full(chroma_full, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
}
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,
)?;
}
#[cfg(feature = "yuv-planar")]
if bottom_v || top_v {
reserve_420_chroma_prev(chroma_prev, w, h)?;
reserve_nv_chroma_half(semi_planar_u_half, semi_planar_v_half, w, h)?;
if !want_color {
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
w,
true,
);
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
}
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color && chroma_top_y.len() < w {
chroma_top_y
.try_reserve_exact(w - chroma_top_y.len())
.map_err(|_| {
MixedSinkerError::Resample(ResampleError::AllocationFailed(PlanGeometry::new(
w, h, w, h,
)))
})?;
chroma_top_y.resize(w, 0);
}
#[cfg(feature = "yuv-planar")]
if need_output && frozen_chroma_centered.is_none() {
*frozen_chroma_centered = Some(center_sited);
*frozen_chroma_bottom_v = Some(bottom_v);
*frozen_chroma_top_v = Some(top_v);
}
if let Some(luma) = luma.as_deref_mut() {
nv_to_luma_row(row.y(), &mut luma[one_plane_start..one_plane_end], w);
}
if let Some(buf) = luma_u16.as_deref_mut() {
crate::row::y_plane_to_luma_u16_row(
row.y(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
#[cfg(feature = "yuv-planar")]
if top_v && want_color {
let is_last = idx + 1 == h;
if idx & 1 == 0
&& let Some((p_idx, p_matrix, p_full_range)) = chroma_top_pending.take()
{
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
true,
center_sited,
false,
w,
true,
use_simd,
);
nv_yuv444_identity_color_row(
rgb,
rgba,
hsv,
rgb_scratch,
&chroma_top_y[..w],
u_full,
v_full,
p_idx * w,
p_idx * w + w,
w,
h,
p_matrix,
p_full_range,
use_simd,
)?;
}
if idx & 1 == 1 && !is_last {
chroma_top_y[..w].copy_from_slice(&row.y()[..w]);
*chroma_top_pending = Some((idx, row.matrix(), row.full_range()));
nv_deinterleave_chroma_half(
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
w,
true,
);
} else {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
false,
center_sited,
false,
w,
true,
use_simd,
);
nv_yuv444_identity_color_row(
rgb,
rgba,
hsv,
rgb_scratch,
row.y(),
u_full,
v_full,
one_plane_start,
one_plane_end,
w,
h,
row.matrix(),
row.full_range(),
use_simd,
)?;
}
stage_420_chroma_prev(
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
idx,
w,
);
return Ok(());
}
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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();
#[cfg(feature = "yuv-planar")]
if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
bottom_v,
center_sited,
true,
w,
true,
use_simd,
);
yuv_444_to_hsv_row(
row.y(),
u_full,
v_full,
&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,
);
return Ok(());
}
nv21_to_hsv_row(
row.y(),
row.vu_half(),
&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,
);
return Ok(());
}
if want_rgba && !need_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)?;
#[cfg(feature = "yuv-planar")]
if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
bottom_v,
center_sited,
true,
w,
true,
use_simd,
);
yuv_444_to_rgba_row(
row.y(),
u_full,
v_full,
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
return Ok(());
}
nv21_to_rgba_row(
row.y(),
row.vu_half(),
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
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,
)?;
#[cfg(feature = "yuv-planar")]
let centered = if center_sited || bottom_v {
let (u_full, v_full) = nv_center_upsample_chroma(
chroma_full,
chroma_prev,
chroma_prev_row,
semi_planar_u_half,
semi_planar_v_half,
row.vu_half(),
idx,
bottom_v,
center_sited,
true,
w,
true,
use_simd,
);
yuv_444_to_rgb_row(
row.y(),
u_full,
v_full,
rgb_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
true
} else {
false
};
#[cfg(not(feature = "yuv-planar"))]
let centered = false;
if !centered {
nv21_to_rgb_row(
row.y(),
row.vu_half(),
rgb_row,
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)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
impl<'a, R> MixedSinker<'a, Nv24, 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> Nv24Sink for MixedSinker<'_, Nv24, R> {}
impl<R> PixelSink for MixedSinker<'_, Nv24, R> {
type Input<'r> = Nv24Row<'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.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
#[cfg(feature = "yuv-planar")]
if let Some(native) = self.native_planar.as_mut() {
native.reset();
}
#[cfg(feature = "yuv-planar")]
{
self.frozen_native_route = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Nv24Row<'_>) -> 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(),
)));
}
let uv_expected =
w.checked_mul(2)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 2,
)))?;
if row.uv().len() != uv_expected {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::UvFull,
idx,
uv_expected,
row.uv().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
rgb_stream,
luma_stream,
rgb_filter_stream,
luma_filter_stream,
resample_outputs,
#[cfg(feature = "yuv-planar")]
native,
#[cfg(feature = "yuv-planar")]
native_planar,
#[cfg(feature = "yuv-planar")]
semi_planar_u_half,
#[cfg(feature = "yuv-planar")]
semi_planar_v_half,
#[cfg(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 convert_rgb = |scratch: &mut [u8]| {
nv24_to_rgb_row(row.y(), row.uv(), scratch, w, matrix, full_range, use_simd);
};
if plan.kind().is_filter() {
return planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
);
}
#[cfg(feature = "yuv-planar")]
let need_output =
luma.is_some() || luma_u16.is_some() || rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
let take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(feature = "yuv-planar"),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if take_native {
semi_planar_process_native_non420(
plan,
native_planar,
semi_planar_u_half,
semi_planar_v_half,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
row.uv(),
w,
false,
0.0,
matrix,
full_range,
idx,
w,
h,
use_simd,
)?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
return Ok(());
}
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
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 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(luma) = luma.as_deref_mut() {
nv_to_luma_row(row.y(), &mut luma[one_plane_start..one_plane_end], w);
}
if let Some(buf) = luma_u16.as_deref_mut() {
crate::row::y_plane_to_luma_u16_row(
row.y(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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();
nv24_to_hsv_row(
row.y(),
row.uv(),
&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,
);
return Ok(());
}
if want_rgba && !need_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)?;
nv24_to_rgba_row(
row.y(),
row.uv(),
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
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,
)?;
nv24_to_rgb_row(
row.y(),
row.uv(),
rgb_row,
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)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}
impl<'a, R> MixedSinker<'a, Nv42, 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> Nv42Sink for MixedSinker<'_, Nv42, R> {}
impl<R> PixelSink for MixedSinker<'_, Nv42, R> {
type Input<'r> = Nv42Row<'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.luma_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.rgb_filter_stream.as_mut() {
stream.reset();
}
if let Some(stream) = self.luma_filter_stream.as_mut() {
stream.reset();
}
#[cfg(feature = "yuv-planar")]
if let Some(native) = self.native_planar.as_mut() {
native.reset();
}
#[cfg(feature = "yuv-planar")]
{
self.frozen_native_route = None;
}
self.resample_outputs = None;
Ok(())
}
fn process(&mut self, row: Nv42Row<'_>) -> 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(),
)));
}
let vu_expected =
w.checked_mul(2)
.ok_or(MixedSinkerError::GeometryOverflow(GeometryOverflow::new(
w, h, 2,
)))?;
if row.vu().len() != vu_expected {
return Err(MixedSinkerError::RowShapeMismatch(RowShapeMismatch::new(
RowSlice::VuFull,
idx,
vu_expected,
row.vu().len(),
)));
}
if idx >= self.height {
return Err(MixedSinkerError::RowIndexOutOfRange(
RowIndexOutOfRange::new(idx, self.height),
));
}
let Self {
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
plan,
rgb_stream,
luma_stream,
rgb_filter_stream,
luma_filter_stream,
resample_outputs,
#[cfg(feature = "yuv-planar")]
native,
#[cfg(feature = "yuv-planar")]
native_planar,
#[cfg(feature = "yuv-planar")]
semi_planar_u_half,
#[cfg(feature = "yuv-planar")]
semi_planar_v_half,
#[cfg(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 convert_rgb = |scratch: &mut [u8]| {
nv42_to_rgb_row(row.y(), row.vu(), scratch, w, matrix, full_range, use_simd);
};
if plan.kind().is_filter() {
return planar_dual_filter_resample(
luma_filter_stream,
rgb_filter_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
);
}
#[cfg(feature = "yuv-planar")]
let need_output =
luma.is_some() || luma_u16.is_some() || rgb.is_some() || rgba.is_some() || hsv.is_some();
#[cfg(feature = "yuv-planar")]
let take_native = matches!(
select_insertion_point(
AveragingDomain::Encoded,
InsertionContext {
native_eligible: cfg!(feature = "yuv-planar"),
with_native: *native,
area_plan: true,
},
),
InsertionPoint::NativeCodes
);
#[cfg(feature = "yuv-planar")]
if need_output
&& let Some(frozen) = *frozen_native_route
&& frozen != take_native
{
return Err(MixedSinkerError::NativeRouteChanged(
NativeRouteChanged::new(idx),
));
}
#[cfg(feature = "yuv-planar")]
if take_native {
semi_planar_process_native_non420(
plan,
native_planar,
semi_planar_u_half,
semi_planar_v_half,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
row.vu(),
w,
true,
0.0,
matrix,
full_range,
idx,
w,
h,
use_simd,
)?;
if frozen_native_route.is_none() && need_output {
*frozen_native_route = Some(true);
}
return Ok(());
}
planar_dual_resample(
luma_stream,
rgb_stream,
resample_outputs,
rgb,
rgba,
luma,
luma_u16,
hsv,
rgb_scratch,
row.y(),
w,
plan,
idx,
use_simd,
convert_rgb,
)?;
#[cfg(feature = "yuv-planar")]
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 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(luma) = luma.as_deref_mut() {
nv_to_luma_row(row.y(), &mut luma[one_plane_start..one_plane_end], w);
}
if let Some(buf) = luma_u16.as_deref_mut() {
crate::row::y_plane_to_luma_u16_row(
row.y(),
&mut buf[one_plane_start..one_plane_end],
w,
use_simd,
);
}
let want_hsv_direct = want_hsv && !want_rgb && !want_rgba;
let need_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();
nv42_to_hsv_row(
row.y(),
row.vu(),
&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,
);
return Ok(());
}
if want_rgba && !need_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)?;
nv42_to_rgba_row(
row.y(),
row.vu(),
rgba_row,
w,
row.matrix(),
row.full_range(),
use_simd,
);
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,
)?;
nv42_to_rgb_row(
row.y(),
row.vu(),
rgb_row,
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)?;
expand_rgb_to_rgba_row(rgb_row, rgba_row, w);
}
Ok(())
}
}