Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use anyhow::Context;
use cidre::{arc, cf, cv, define_obj_type, ns, objc, vn, vt};
use std::sync::mpsc;
use std::thread;
use crate::mask_refinement::MaskRefiner;
/// Largest frame handed to Vision. Its balanced person segmentation runs a
/// fixed-size network, and on webcam footage a 960x540 input produces the
/// same mask as the full 1080p frame while halving the readback.
pub const MAX_INPUT_DIMENSIONS: (u32, u32) = (960, 540);
unsafe extern "C" {
fn CVPixelBufferGetBaseAddress(pixel_buffer: &cv::PixelBuf) -> *mut u8;
fn CVPixelBufferGetBytesPerRow(pixel_buffer: &cv::PixelBuf) -> usize;
}
/// A BGRA camera frame handed to Vision without a CPU copy. CF objects have
/// atomic refcounts, so the retain can cross to the segmentation thread.
/// Callers usually own these in a small reuse ring, so the segmentation
/// thread first copies the frame into its own buffer with a hardware pixel
/// transfer and releases this one before any Vision work: a slow
/// segmentation can never read a slot the ring has already rewritten.
pub struct SharedPixelBuffer(pub arc::R<cv::PixelBuf>);
unsafe impl Send for SharedPixelBuffer {}
pub type VisionMask<'a> = (&'a [u8], (u32, u32));
/// Apple Vision person segmentation (`VNGeneratePersonSegmentationRequest`).
///
/// Runs on the Neural Engine and is far more accurate than the bundled ONNX
/// selfie model: it keeps desks, chairs, pillows and background people out
/// of the mask. Segmentation is asynchronous: a frame is submitted, the
/// caller keeps rendering with the previous mask, and the finished mask is
/// collected on a later frame. The thread also owns the autorelease pool
/// every Vision call needs, the stateful request's temporal smoothing, and
/// the mask cleanup, so none of that CPU work lands on the render thread.
pub struct VisionSegmenter {
requests: Option<mpsc::Sender<Message>>,
results: mpsc::Receiver<VisionJob>,
idle: Option<VisionJob>,
in_flight: bool,
generation: u64,
worker: Option<thread::JoinHandle<()>>,
}
enum Message {
Segment(VisionJob),
Reset,
}
enum VisionInput {
None,
Pixels,
PixelBuffer(SharedPixelBuffer),
}
struct VisionJob {
input: VisionInput,
bgra: Vec<u8>,
dimensions: (u32, u32),
generation: u64,
mask: Vec<u8>,
mask_dimensions: (u32, u32),
result: Result<(), String>,
}
impl VisionJob {
fn new() -> Self {
Self {
input: VisionInput::None,
bgra: Vec::new(),
dimensions: (0, 0),
generation: 0,
mask: Vec::new(),
mask_dimensions: (0, 0),
result: Ok(()),
}
}
}
define_obj_type!(
#[doc(alias = "VNGeneratePersonInstanceMaskRequest")]
PersonInstanceMaskRequest(vn::Request)
);
define_obj_type!(
#[doc(alias = "VNInstanceMaskObservation")]
InstanceMaskObservation(vn::Observation)
);
impl PersonInstanceMaskRequest {
/// macOS 14+. Looked up at runtime so older systems fall back to plain
/// person segmentation.
fn new() -> Option<arc::R<Self>> {
let class =
unsafe { objc::objc_getClass(c"VNGeneratePersonInstanceMaskRequest".as_ptr().cast()) }?;
let class: &objc::Class<Self> = unsafe { std::mem::transmute(class) };
Some(unsafe { class.new() })
}
#[objc::msg_send(results)]
fn results(&self) -> Option<arc::R<ns::Array<InstanceMaskObservation>>>;
}
impl InstanceMaskObservation {
/// One byte per sample: 0 is background, 1..n the person instances.
#[objc::msg_send(instanceMask)]
fn instance_mask(&self) -> &cv::PixelBuf;
/// Returns a +1 buffer (`CF_RETURNS_RETAINED`): one per call.
#[objc::msg_send(generateMaskForInstances:error:)]
unsafe fn generate_mask_err<'ear>(
&self,
instances: &ns::IndexSet,
error: *mut Option<&'ear ns::Error>,
) -> Option<arc::Retained<cv::PixelBuf>>;
}
/// Person instance masks separate everyone in frame, so only the presenter
/// is kept: people walking behind, other passengers and their chairs never
/// enter the cutout. They are also cheaper than balanced segmentation (~7ms
/// against ~10ms). Plain segmentation is the macOS 12-13 fallback.
enum Request {
Instances(arc::R<PersonInstanceMaskRequest>),
Segmentation(arc::R<vn::GenPersonSegmentationRequest>),
}
impl Request {
fn new() -> Self {
if std::env::var("CAP_CAMERA_SEGMENTATION").as_deref() != Ok("vision-segmentation")
&& let Some(request) = PersonInstanceMaskRequest::new()
{
return Self::Instances(request);
}
Self::Segmentation(create_request())
}
fn as_request(&self) -> &vn::Request {
match self {
Self::Instances(request) => request.as_ref(),
Self::Segmentation(request) => request.as_ref(),
}
}
}
struct Session {
handler: arc::R<vn::SequenceRequestHandler>,
request: Request,
input: Option<arc::R<cv::PixelBuf>>,
transfer: Option<arc::R<vt::PixelTransferSession>>,
cleanup: Cleanup,
instance_areas: Vec<usize>,
repeat: RepeatedFrame,
}
/// The pixels and raw mask of the last frame Vision analysed. A camera
/// frame held across several output frames arrives again byte for byte;
/// person instance masks keep no state between frames, so the mask is
/// reused instead of running Vision again. The cleanup still runs, so the
/// temporal smoothing advances exactly as it did.
#[derive(Default)]
struct RepeatedFrame {
pixels: Vec<u8>,
dimensions: (u32, u32),
mask: Vec<f32>,
mask_dimensions: Option<(u32, u32)>,
}
/// Drops Vision's low-confidence blobs (pillows, chair backs) that are
/// detached from the person, and settles still regions over time while
/// following motion immediately.
#[derive(Default)]
struct Cleanup {
refiner: Option<((u32, u32), MaskRefiner)>,
mask: Vec<f32>,
previous: Vec<f32>,
motion: Vec<u8>,
motion_columns: Vec<usize>,
}
fn create_request() -> arc::R<vn::GenPersonSegmentationRequest> {
let mut request = vn::GenPersonSegmentationRequest::new();
// Fast (256x192) loses arms and keeps pillows even after the guided
// filter; accurate costs 50ms+ a frame. Balanced is the only level that
// holds up at camera rate.
request.set_quality_level(vn::GenPersonSegmentationRequestQualityLevel::Balanced);
request
}
impl Session {
fn new() -> Self {
Self {
handler: vn::SequenceRequestHandler::new(),
request: Request::new(),
input: None,
transfer: None,
cleanup: Cleanup::default(),
instance_areas: Vec::new(),
repeat: RepeatedFrame::default(),
}
}
fn reset(&mut self) {
self.handler = vn::SequenceRequestHandler::new();
self.request = Request::new();
self.cleanup.previous.clear();
self.repeat.mask_dimensions = None;
}
fn segment(&mut self, job: &mut VisionJob) -> Result<(), String> {
let cached = self.repeat.mask_dimensions.take();
let mut repeated = None;
let mut from_pixels = false;
let input = match std::mem::replace(&mut job.input, VisionInput::None) {
VisionInput::PixelBuffer(buffer) => {
let (width, height) =
input_dimensions(buffer.0.width() as u32, buffer.0.height() as u32);
let (width, height) = (width as usize, height as usize);
let transfer = match &mut self.transfer {
Some(transfer) => transfer,
slot => {
let mut transfer = vt::PixelTransferSession::new()
.map_err(|error| format!("pixel transfer session: {error:?}"))?;
transfer
.set_realtime(true)
.map_err(|error| format!("pixel transfer realtime: {error:?}"))?;
slot.insert(transfer)
}
};
let input = match &mut self.input {
Some(input) if input.width() == width && input.height() == height => input,
slot => slot.insert(create_input(width, height)?),
};
transfer
.transfer(&buffer.0, input)
.map_err(|error| format!("copy segmentation frame: {error:?}"))?;
input.clone()
}
VisionInput::Pixels => {
let (width, height) = (job.dimensions.0 as usize, job.dimensions.1 as usize);
if job.bgra.len() < width * height * 4 || width == 0 || height == 0 {
return Err("invalid segmentation input".into());
}
let input = match &mut self.input {
Some(input) if input.width() == width && input.height() == height => input,
slot => slot.insert(create_input(width, height)?),
};
from_pixels = true;
repeated = cached.filter(|_| {
self.repeat.dimensions == job.dimensions && self.repeat.pixels == job.bgra
});
if repeated.is_none() {
write_bgra(input, &job.bgra, width, height)?;
}
input.clone()
}
VisionInput::None => return Err("missing segmentation input".into()),
};
let reusable = if let Some(dimensions) = repeated {
self.cleanup.mask.clone_from(&self.repeat.mask);
job.mask_dimensions = dimensions;
repeated
} else {
self.analyse(&input, job)?;
(from_pixels && matches!(self.request, Request::Instances(_))).then(|| {
self.repeat.mask.clone_from(&self.cleanup.mask);
std::mem::swap(&mut self.repeat.pixels, &mut job.bgra);
self.repeat.dimensions = job.dimensions;
job.mask_dimensions
})
};
self.cleanup.motion_frame(&input, job.mask_dimensions)?;
self.cleanup.finish(job.mask_dimensions, &mut job.mask);
self.repeat.mask_dimensions = reusable;
Ok(())
}
fn analyse(&mut self, input: &cv::PixelBuf, job: &mut VisionJob) -> Result<(), String> {
let requests = ns::Array::<vn::Request>::from_slice(&[self.request.as_request()]);
self.handler
.perform_on_cv_pixel_buf(&requests, input)
.map_err(|error| format!("Vision person segmentation failed: {error:?}"))?;
match &self.request {
Request::Segmentation(request) => {
let results = request.results().ok_or("Vision returned no segmentation")?;
let observation = results.first().ok_or("Vision returned no segmentation")?;
read_mask(
observation.pixel_buffer(),
&mut self.cleanup.mask,
&mut job.mask_dimensions,
)?;
}
Request::Instances(request) => {
let observation = request
.results()
.and_then(|results| results.first().map(|observation| observation.retained()));
match observation {
Some(observation) => primary_person_mask(
&observation,
&mut self.instance_areas,
&mut self.cleanup.mask,
&mut job.mask_dimensions,
)?,
None => {
// Nobody in frame: an empty mask at the last size.
if job.mask_dimensions == (0, 0) {
job.mask_dimensions = (512, 384);
}
let (width, height) = job.mask_dimensions;
self.cleanup.mask.clear();
self.cleanup.mask.resize((width * height) as usize, 0.0);
}
}
}
}
Ok(())
}
}
impl Cleanup {
/// Samples the analysed frame on the mask's grid, which is what the
/// motion-adaptive smoothing compares between frames.
fn motion_frame(
&mut self,
frame: &cv::PixelBuf,
(width, height): (u32, u32),
) -> Result<(), String> {
let (source_width, source_height) = (frame.width(), frame.height());
let (width, height) = (width as usize, height as usize);
self.motion_columns.clear();
self.motion_columns
.extend((0..width).map(|x| x * source_width / width * 4));
let columns = &self.motion_columns;
let motion = &mut self.motion;
motion.clear();
motion.resize(width * height * 4, 0);
with_locked_base(
&mut frame.retained(),
cv::pixel_buffer::LockFlags::READ_ONLY,
|base, stride| {
if stride < source_width * 4 {
return Err("segmentation frame is not addressable".into());
}
for (y, output) in motion.chunks_exact_mut(width * 4).enumerate() {
let row = unsafe {
std::slice::from_raw_parts(
base.add(y * source_height / height * stride),
source_width * 4,
)
};
for (pixel, &column) in output.chunks_exact_mut(4).zip(columns) {
pixel.copy_from_slice(&row[column..column + 4]);
}
}
Ok(())
},
)
}
fn finish(&mut self, dimensions: (u32, u32), output: &mut Vec<u8>) {
let (refiner, resized) = match &mut self.refiner {
Some((current, refiner)) if *current == dimensions => (refiner, false),
slot => (
&mut slot
.insert((
dimensions,
MaskRefiner::new(dimensions.0 as usize, dimensions.1 as usize),
))
.1,
true,
),
};
// Pockets up to 0.75% of the frame: logos, glare, jewellery.
let max_hole = self.mask.len() * 3 / 400;
refiner.fill_holes(&mut self.mask, max_hole);
let smooth = !resized && self.previous.len() == self.mask.len();
refiner.refine(&mut self.mask, &self.previous, &mut self.motion, smooth);
self.previous.clear();
self.previous.extend_from_slice(&self.mask);
output.clear();
output.extend(self.mask.iter().map(|value| (value * 255.0).round() as u8));
}
}
fn create_input(width: usize, height: usize) -> Result<arc::R<cv::PixelBuf>, String> {
let properties = cf::Dictionary::new();
let attributes = cf::Dictionary::with_keys_values(
&[cv::pixel_buffer::keys::io_surf_props().as_ref()],
&[properties.as_ref()],
)
.ok_or("segmentation input attributes")?;
cv::PixelBuf::new(width, height, cv::PixelFormat::_32_BGRA, Some(&attributes))
.map_err(|error| format!("segmentation input buffer: {error:?}"))
}
fn write_bgra(
buffer: &mut cv::PixelBuf,
bgra: &[u8],
width: usize,
height: usize,
) -> Result<(), String> {
let row = width * 4;
with_locked_base(
buffer,
cv::pixel_buffer::LockFlags::DEFAULT,
|base, stride| {
if stride < row {
return Err("segmentation input is not addressable".into());
}
for (y, source) in bgra.chunks_exact(row).take(height).enumerate() {
unsafe {
std::ptr::copy_nonoverlapping(source.as_ptr(), base.add(y * stride), row)
};
}
Ok(())
},
)
}
/// The soft mask of the largest person, which for a camera bubble is the
/// presenter.
fn primary_person_mask(
observation: &InstanceMaskObservation,
areas: &mut Vec<usize>,
output: &mut Vec<f32>,
dimensions: &mut (u32, u32),
) -> Result<(), String> {
let labels = observation.instance_mask();
let (width, height) = (labels.width(), labels.height());
let mut lanes = [[0; 256]; 4];
with_locked_base(
&mut labels.retained(),
cv::pixel_buffer::LockFlags::READ_ONLY,
|base, stride| {
if stride < width {
return Err("Vision instance mask is not addressable".into());
}
for y in 0..height {
let row = unsafe { std::slice::from_raw_parts(base.add(y * stride), width) };
count_labels(row, &mut lanes);
}
Ok(())
},
)?;
areas.clear();
areas
.extend((0..256).map(|label| lanes.iter().map(|lane| lane[label] as usize).sum::<usize>()));
let Some(primary) = (1..areas.len())
.filter(|&label| areas[label] > 0)
.max_by_key(|&label| areas[label])
else {
output.clear();
output.resize(width * height, 0.0);
*dimensions = (width as u32, height as u32);
return Ok(());
};
let instances = ns::IndexSet::with_index(primary);
let mut error = None;
let mask = unsafe { observation.generate_mask_err(&instances, &mut error) }
.ok_or_else(|| format!("Vision instance mask failed: {error:?}"))?;
read_mask(&mask, output, dimensions)
}
/// Tallies every label in `row`. Nearly every sample repeats its
/// neighbour's label, so a single table would chain each increment on the
/// previous store to the same counter; four interleaved tables keep four
/// independent chains in flight.
fn count_labels(row: &[u8], lanes: &mut [[u32; 256]; 4]) {
let chunks = row.chunks_exact(4);
let tail = chunks.remainder();
for chunk in chunks {
lanes[0][usize::from(chunk[0])] += 1;
lanes[1][usize::from(chunk[1])] += 1;
lanes[2][usize::from(chunk[2])] += 1;
lanes[3][usize::from(chunk[3])] += 1;
}
for &label in tail {
lanes[0][usize::from(label)] += 1;
}
}
fn read_mask(
mask: &cv::PixelBuf,
output: &mut Vec<f32>,
dimensions: &mut (u32, u32),
) -> Result<(), String> {
let format = mask.pixel_format();
let bytes_per_sample = if format == cv::PixelFormat::ONE_COMPONENT_8 {
1
} else if format == cv::PixelFormat::ONE_COMPONENT_F32 {
4
} else {
return Err(format!("unexpected Vision mask format {format:?}"));
};
let (width, height) = (mask.width(), mask.height());
output.clear();
with_locked_base(
&mut mask.retained(),
cv::pixel_buffer::LockFlags::READ_ONLY,
|base, stride| {
if stride < width * bytes_per_sample {
return Err("Vision mask is not addressable".into());
}
for y in 0..height {
let row = unsafe { base.add(y * stride) };
if bytes_per_sample == 1 {
let row = unsafe { std::slice::from_raw_parts(row, width) };
output.extend(row.iter().map(|&value| f32::from(value) / 255.0));
} else {
let row = unsafe { std::slice::from_raw_parts(row.cast::<f32>(), width) };
output.extend(row.iter().map(|value| value.clamp(0.0, 1.0)));
}
}
Ok(())
},
)?;
*dimensions = (width as u32, height as u32);
Ok(())
}
fn with_locked_base<R>(
buffer: &mut cv::PixelBuf,
flags: cv::pixel_buffer::LockFlags,
body: impl FnOnce(*mut u8, usize) -> Result<R, String>,
) -> Result<R, String> {
unsafe {
buffer
.lock_base_addr(flags)
.result()
.map_err(|error| format!("lock pixel buffer: {error:?}"))?;
let base = CVPixelBufferGetBaseAddress(buffer);
let stride = CVPixelBufferGetBytesPerRow(buffer);
let result = if base.is_null() {
Err("pixel buffer has no base address".into())
} else {
body(base, stride)
};
let _ = buffer.unlock_lock_base_addr(flags);
result
}
}
impl VisionSegmenter {
pub fn new() -> anyhow::Result<Self> {
let (ready_tx, ready_rx) = mpsc::channel::<Result<(), String>>();
let (requests, request_rx) = mpsc::channel::<Message>();
let (result_tx, results) = mpsc::channel::<VisionJob>();
let worker = thread::Builder::new()
.name("cap-vision-segmentation".into())
.spawn(move || {
// A frame is waiting on every mask: keep this thread on the
// performance cores rather than letting it drift to the
// efficiency cores at default QoS.
unsafe {
libc::pthread_set_qos_class_self_np(
libc::qos_class_t::QOS_CLASS_USER_INTERACTIVE,
0,
);
}
// Probe once so an unavailable request fails construction and
// the caller falls back to ONNX instead of failing every frame.
let mut session = Session::new();
let mut probe = VisionJob::new();
probe.input = VisionInput::Pixels;
probe.bgra = vec![0; 64 * 64 * 4];
probe.dimensions = (64, 64);
if let Err(error) = objc::ar_pool(|| session.segment(&mut probe)) {
let _ = ready_tx.send(Err(error));
return;
}
session.reset();
let _ = ready_tx.send(Ok(()));
while let Ok(message) = request_rx.recv() {
match message {
Message::Reset => session.reset(),
Message::Segment(mut job) => {
job.result = objc::ar_pool(|| session.segment(&mut job));
job.input = VisionInput::None;
if result_tx.send(job).is_err() {
break;
}
}
}
}
})
.context("Failed to start the Vision segmentation thread")?;
match ready_rx.recv() {
Ok(Ok(())) => {
tracing::info!("Camera background segmentation: Apple Vision person segmentation");
Ok(Self {
requests: Some(requests),
results,
idle: Some(VisionJob::new()),
in_flight: false,
generation: 0,
worker: Some(worker),
})
}
Ok(Err(error)) => {
let _ = worker.join();
Err(anyhow::anyhow!(error))
}
Err(_) => {
let _ = worker.join();
Err(anyhow::anyhow!(
"Vision segmentation thread exited during startup"
))
}
}
}
/// Clears temporal state so a seek or a new camera does not blend into
/// the previous scene. A mask still in flight is discarded on arrival.
pub fn reset(&mut self) {
self.generation = self.generation.wrapping_add(1);
if let Some(requests) = &self.requests {
let _ = requests.send(Message::Reset);
}
}
pub fn is_busy(&self) -> bool {
self.in_flight
}
pub fn submit_pixels(&mut self, bgra: &[u8], dimensions: (u32, u32)) -> anyhow::Result<()> {
let mut job = self.take_idle()?;
job.bgra.clear();
job.bgra.extend_from_slice(bgra);
job.dimensions = dimensions;
job.input = VisionInput::Pixels;
self.send(job)
}
pub fn submit_pixel_buffer(&mut self, buffer: SharedPixelBuffer) -> anyhow::Result<()> {
let mut job = self.take_idle()?;
job.dimensions = (buffer.0.width() as u32, buffer.0.height() as u32);
job.input = VisionInput::PixelBuffer(buffer);
self.send(job)
}
/// The finished mask and its dimensions, if one has arrived. `wait`
/// blocks until the in-flight frame completes.
pub fn collect(&mut self, wait: bool) -> Option<anyhow::Result<VisionMask<'_>>> {
if !self.in_flight {
return None;
}
let job = if wait {
match self.results.recv() {
Ok(job) => job,
Err(_) => {
self.in_flight = false;
return Some(Err(anyhow::anyhow!("Vision segmentation thread stopped")));
}
}
} else {
match self.results.try_recv() {
Ok(job) => job,
Err(mpsc::TryRecvError::Empty) => return None,
Err(mpsc::TryRecvError::Disconnected) => {
self.in_flight = false;
return Some(Err(anyhow::anyhow!("Vision segmentation thread stopped")));
}
}
};
self.in_flight = false;
let stale = job.generation != self.generation;
let job = self.idle.insert(job);
if stale {
return None;
}
Some(match std::mem::replace(&mut job.result, Ok(())) {
Ok(()) => Ok((&job.mask, job.mask_dimensions)),
Err(error) => Err(anyhow::anyhow!(error)),
})
}
fn take_idle(&mut self) -> anyhow::Result<VisionJob> {
anyhow::ensure!(!self.in_flight, "Vision segmentation is busy");
Ok(self.idle.take().unwrap_or_else(VisionJob::new))
}
fn send(&mut self, mut job: VisionJob) -> anyhow::Result<()> {
job.generation = self.generation;
self.requests
.as_ref()
.context("Vision segmentation thread stopped")?
.send(Message::Segment(job))
.map_err(|_| anyhow::anyhow!("Vision segmentation thread stopped"))?;
self.in_flight = true;
Ok(())
}
}
impl Drop for VisionSegmenter {
fn drop(&mut self) {
self.requests = None;
if let Some(worker) = self.worker.take() {
let _ = worker.join();
}
}
}
pub fn input_dimensions(width: u32, height: u32) -> (u32, u32) {
let (max_width, max_height) = MAX_INPUT_DIMENSIONS;
let (long, short) = if width >= height {
(max_width, max_height)
} else {
(max_height, max_width)
};
let scale = (f64::from(long) / f64::from(width.max(1)))
.min(f64::from(short) / f64::from(height.max(1)))
.min(1.0);
(
((f64::from(width) * scale).round() as u32).max(1),
((f64::from(height) * scale).round() as u32).max(1),
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn input_is_bounded_and_keeps_aspect() {
assert_eq!(input_dimensions(1920, 1080), (960, 540));
assert_eq!(input_dimensions(3840, 2160), (960, 540));
assert_eq!(input_dimensions(1080, 1920), (540, 960));
assert_eq!(input_dimensions(640, 480), (640, 480));
assert_eq!(input_dimensions(1440, 1080), (720, 540));
}
#[test]
fn label_tallies_match_a_plain_count() {
let mut state = 0x2545_f491_u32;
let mut row = Vec::new();
while row.len() < 517 * 3 {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
let label = [0, 0, 1, 2, 255][(state % 5) as usize];
row.extend(std::iter::repeat_n(label, (state >> 8) as usize % 40 + 1));
}
for width in [1, 3, 4, 5, 512, 517] {
let mut lanes = [[0; 256]; 4];
let mut expected = [0usize; 256];
for chunk in row.chunks(width) {
count_labels(chunk, &mut lanes);
for &label in chunk {
expected[usize::from(label)] += 1;
}
}
for (label, &expected) in expected.iter().enumerate() {
let total: usize = lanes.iter().map(|lane| lane[label] as usize).sum();
assert_eq!(total, expected, "width {width} label {label}");
}
}
}
#[test]
#[ignore = "requires macOS Vision"]
fn segments_asynchronously_and_discards_masks_from_before_a_reset() {
let mut segmenter = VisionSegmenter::new().unwrap();
let frame = vec![128; 320 * 180 * 4];
segmenter.submit_pixels(&frame, (320, 180)).unwrap();
assert!(segmenter.is_busy());
assert!(segmenter.submit_pixels(&frame, (320, 180)).is_err());
let (mask, (width, height)) = segmenter.collect(true).unwrap().unwrap();
assert_eq!(mask.len(), (width * height) as usize);
assert!(!segmenter.is_busy());
segmenter.submit_pixels(&frame, (320, 180)).unwrap();
segmenter.reset();
assert!(segmenter.collect(true).is_none());
assert!(!segmenter.is_busy());
}
}