Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use super::*;
use cap_enc_ffmpeg::{
RelocatableSource,
h264::DEFAULT_KEYFRAME_INTERVAL_SECS,
segmented_stream::{SegmentedVideoEncoder, SegmentedVideoEncoderConfig},
};
use cap_project::{ClipConfiguration, ClipOffsets, CursorMeta, TimelineConfiguration};
use cap_rendering::{
ManagedVideoTrackInput, RecordingSegmentDecoders, RenderedFrame, SegmentVideoPaths,
};
use std::{
io::Cursor,
path::{Path, PathBuf},
sync::{
Mutex,
atomic::{AtomicBool, Ordering},
},
time::Duration,
};
struct SourceLease {
location: Arc<Mutex<PathBuf>>,
after_close: PathBuf,
released: Arc<AtomicBool>,
rename_succeeded: Arc<AtomicBool>,
}
impl Drop for SourceLease {
fn drop(&mut self) {
let location = self.location.lock().unwrap();
self.rename_succeeded.store(
std::fs::rename(location.as_path(), &self.after_close).is_ok(),
Ordering::Release,
);
self.released.store(true, Ordering::Release);
}
}
struct Fixture {
directory: tempfile::TempDir,
source: RelocatableSource,
location: Arc<Mutex<PathBuf>>,
released: Arc<AtomicBool>,
rename_succeeded: Arc<AtomicBool>,
metadata: RecordingMeta,
reference_metadata: RecordingMeta,
display: Vec<PathBuf>,
camera: Vec<PathBuf>,
project: ProjectConfiguration,
cursor: Arc<CursorEvents>,
assets: FrozenRecordedCursorAssets,
}
fn encode_track(
root: &Path,
track: &str,
width: u32,
height: u32,
fps: u32,
mut noise: u32,
) -> Vec<PathBuf> {
let directory = root.join(track);
let mut encoder = SegmentedVideoEncoder::init(
directory.clone(),
cap_media_info::VideoInfo {
pixel_format: cap_media_info::Pixel::NV12,
width,
height,
time_base: ffmpeg::Rational(1, 1_000_000),
frame_rate: ffmpeg::Rational(fps as i32, 1),
},
SegmentedVideoEncoderConfig {
segment_duration: Duration::from_secs(1),
bpp: 4.0,
..Default::default()
},
)
.unwrap();
let frame_count = u64::from(fps) * u64::from(DEFAULT_KEYFRAME_INTERVAL_SECS) * 3;
for index in 0..frame_count {
let mut frame = ffmpeg::frame::Video::new(ffmpeg::format::Pixel::NV12, width, height);
for byte in frame.data_mut(0) {
noise ^= noise << 13;
noise ^= noise >> 17;
noise ^= noise << 5;
*byte = (noise % 220 + 16) as u8;
}
frame.data_mut(1).fill(128);
encoder
.queue_frame(
frame,
Duration::from_micros(index * 1_000_000 / u64::from(fps)),
)
.unwrap();
}
encoder.finish().unwrap();
let mut paths = std::fs::read_dir(&directory)
.unwrap()
.map(|entry| entry.unwrap().path())
.filter(|path| path.extension().is_some_and(|extension| extension == "m4s"))
.map(|path| PathBuf::from(track).join(path.file_name().unwrap()))
.collect::<Vec<_>>();
paths.sort();
assert!(paths.len() >= 3);
paths.insert(0, PathBuf::from(track).join("init.mp4"));
paths
}
fn finalize_track(root: &Path, paths: &[PathBuf], output: &Path) {
cap_enc_ffmpeg::remux::concatenate_m4s_segments_with_init(
&root.join(&paths[0]),
&paths[1..]
.iter()
.map(|path| root.join(path))
.collect::<Vec<_>>(),
output,
)
.unwrap();
assert!(cap_enc_ffmpeg::remux::probe_video_can_decode(output).unwrap());
}
fn fixture(svg: bool) -> Fixture {
ffmpeg::init().unwrap();
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
let reference = directory.path().join("reference");
std::fs::create_dir(&original).unwrap();
std::fs::create_dir(&reference).unwrap();
let display = encode_track(&original, "display", 160, 120, 30, 123456789);
let camera = encode_track(&original, "camera", 80, 80, 24, 987654321);
finalize_track(&original, &display, &reference.join("display.mp4"));
finalize_track(&original, &camera, &reference.join("camera.mp4"));
let mut image = image::RgbaImage::new(16, 24);
for (x, y, pixel) in image.enumerate_pixels_mut() {
*pixel = image::Rgba([255, (x * 13) as u8, (y * 9) as u8, 220]);
}
let mut png = Cursor::new(Vec::new());
image.write_to(&mut png, image::ImageFormat::Png).unwrap();
let bytes: Arc<[u8]> = png.into_inner().into();
std::fs::write(reference.join("cursor.png"), &bytes).unwrap();
let cursor_meta: CursorMeta = serde_json::from_value(serde_json::json!({
"imagePath": "cursor.png",
"hotspot": {"x": 0.25, "y": 0.125},
"shape": svg.then_some("MacOS|Arrow")
}))
.unwrap();
let mut metadata: RecordingMeta = serde_json::from_value(serde_json::json!({
"platform": "MacOS", "pretty_name": "Preparing preview native test", "sharing": null,
"segments": [{
"display": {"path": "display", "fps": 30, "start_time": 0.0},
"camera": {"path": "camera", "fps": 24, "start_time": 0.125},
"mic": {"path": "mic.aac", "start_time": 0.25}
}],
"cursors": {"arrow": cursor_meta},
"status": {"status": "NeedsRemux"}
}))
.unwrap();
metadata.project_path = original.clone();
let mut reference_metadata = metadata.clone();
reference_metadata.project_path = reference;
let cap_project::RecordingMetaInner::Studio(studio) = &mut reference_metadata.inner else {
panic!("Studio metadata expected");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Indexed metadata expected");
};
inner.segments[0].display.path = "display.mp4".into();
inner.segments[0].camera.as_mut().unwrap().path = "camera.mp4".into();
inner.status = Some(cap_project::StudioRecordingStatus::Complete);
let mut project = ProjectConfiguration {
timeline: Some(
serde_json::from_value::<TimelineConfiguration>(serde_json::json!({
"segments": [{"recordingSegment": 0, "timescale": 1.0, "start": 0.0, "end": 3.25}],
"zoomSegments": [{"start": 0.3, "end": 2.7, "amount": 1.6, "mode": "auto"}]
}))
.unwrap(),
),
clips: vec![ClipConfiguration {
index: 0,
offsets: ClipOffsets {
camera: 0.25,
mic: 0.03125,
system_audio: 0.0,
},
offsets_auto_calculated: true,
}],
..Default::default()
};
project.cursor.use_svg = svg;
project.cursor.hide_when_idle = false;
project.cursor.size = 150;
project.cursor.motion_blur = 0.0;
project.background.padding = 8.0;
project.background.shadow = 0.0;
project.camera.hide = false;
project.camera.size = 30.0;
project.camera.shadow = 0.0;
let cursor = Arc::new(CursorEvents {
moves: [
(0.0, 0.1, 0.15),
(300.0, 0.2, 0.3),
(600.0, 0.7, 0.25),
(1100.0, 0.8, 0.7),
(1800.0, 0.4, 0.6),
(2600.0, 0.2, 0.3),
(3500.0, 0.8, 0.8),
]
.into_iter()
.map(|(time_ms, x, y)| cap_project::CursorMoveEvent {
active_modifiers: Vec::new(),
cursor_id: "arrow".into(),
time_ms,
x,
y,
})
.collect(),
clicks: Vec::new(),
});
let assets = FrozenRecordedCursorAssets::new([("arrow".into(), cursor_meta, bytes)]).unwrap();
let location = Arc::new(Mutex::new(original.clone()));
let released = Arc::new(AtomicBool::new(false));
let rename_succeeded = Arc::new(AtomicBool::new(false));
let source = RelocatableSource::new_with_owner(
original,
Arc::new(SourceLease {
location: location.clone(),
after_close: directory.path().join("released-after-native-join"),
released: released.clone(),
rename_succeeded: rename_succeeded.clone(),
}),
)
.unwrap();
Fixture {
directory,
source,
location,
released,
rename_succeeded,
metadata,
reference_metadata,
display,
camera,
project,
cursor,
assets,
}
}
impl Fixture {
fn input(&self) -> PreparingPreviewInput {
let metadata = self.metadata.studio_meta().unwrap();
PreparingPreviewInput {
recording_meta: self.metadata.clone(),
project: self.project.clone(),
segments: (0..self.project.clips.len())
.map(|index| PreparingPreviewSegment {
video: ManagedSegmentVideoInput::new(
index,
metadata,
ManagedVideoTrackInput::new(self.source.clone(), self.display.clone())
.unwrap(),
Some(
ManagedVideoTrackInput::new(self.source.clone(), self.camera.clone())
.unwrap(),
),
)
.unwrap(),
cursor: self.cursor.clone(),
})
.collect(),
cursor_assets: self.assets.clone(),
}
}
fn relocate(&self, name: &str) {
let destination = self.directory.path().join(name);
self.source.relocate(destination.clone()).unwrap();
*self.location.lock().unwrap() = destination;
}
}
fn visible_rgba(frame: &RenderedFrame) -> Vec<u8> {
let row_bytes = (frame.width as usize).checked_mul(4).unwrap();
let stride = frame.padded_bytes_per_row as usize;
let rows = frame.height as usize;
assert!(row_bytes > 0 && rows > 0);
assert!(stride >= row_bytes);
assert_eq!(frame.data.len(), stride.checked_mul(rows).unwrap());
frame
.data
.chunks_exact(frame.padded_bytes_per_row as usize)
.take(frame.height as usize)
.flat_map(|row| row[..frame.width as usize * 4].iter().copied())
.collect()
}
async fn ordinary_composed_frames(
fixture: &Fixture,
frame_numbers: &[u32],
force_ffmpeg: bool,
) -> Vec<(RenderedFrame, FrameLayout)> {
let metadata = &fixture.reference_metadata;
let studio = metadata.studio_meta().unwrap();
let mut decoders = Vec::new();
for index in 0..fixture.project.clips.len() {
decoders.push(
RecordingSegmentDecoders::new(
metadata,
studio,
SegmentVideoPaths {
display: metadata.project_path.join("display.mp4"),
camera: Some(metadata.project_path.join("camera.mp4")),
},
index,
force_ffmpeg,
)
.await
.unwrap(),
);
}
#[cfg(target_os = "macos")]
if !force_ffmpeg {
for decoder in &decoders {
assert_eq!(
decoder.screen_decoder_status().decoder_type,
cap_rendering::decoder::DecoderType::AVAssetReader,
);
assert_eq!(
decoder.camera_decoder_status().unwrap().decoder_type,
cap_rendering::decoder::DecoderType::AVAssetReader,
);
}
}
let duration = fixture.project.timeline.as_ref().unwrap().duration();
let constants = RenderVideoConstants::new_with_options(
RenderOptions {
screen_size: XY::new(160, 120),
camera_size: Some(XY::new(80, 80)),
preserve_screen_alpha: false,
},
metadata.clone(),
studio.clone(),
)
.await
.unwrap();
let mut layers = RendererLayers::new_with_options(
&constants.device,
&constants.queue,
constants.is_software_adapter,
);
layers.preload_cursor_assets(
&constants,
fixture.project.cursor.use_svg,
fixture.project.cursor.cursor_type(),
);
let mut renderer = FrameRenderer::new(&constants);
let mut cache = PreviewCursorCache::default();
let mut result = Vec::new();
let mut cursor_positions = Vec::new();
let mut zoom_amounts = Vec::new();
for &frame_number in frame_numbers {
let time = f64::from(frame_number) / 30.0;
let (segment_time, segment) = fixture.project.get_segment_time(time).unwrap();
let frames = decoders[segment.recording_clip as usize]
.get_frames_initial(
segment_time as f32,
true,
true,
fixture.project.clips[segment.recording_clip as usize].offsets,
)
.await
.unwrap();
let timeline = cache.get(segment.recording_clip, &fixture.cursor, &fixture.project);
let mut zoom = ZoomTransformTimeline::from_project_for_clip(
&fixture.project,
&fixture.cursor,
duration,
constants.options.screen_size,
segment.recording_clip,
);
zoom.ensure_precomputed_until((frame_number as f32 + 1.0) / 30.0);
let uniforms = match timeline {
Some(timeline) => ProjectUniforms::new_with_precomputed_cursor(
&constants,
&Arc::new(fixture.project.clone()),
frame_number,
30,
XY::new(320, 240),
&fixture.cursor,
&frames,
duration,
&zoom,
&timeline,
),
None => ProjectUniforms::new(
&constants,
&Arc::new(fixture.project.clone()),
frame_number,
30,
XY::new(320, 240),
&fixture.cursor,
&frames,
duration,
&zoom,
),
};
zoom_amounts.push(uniforms.zoom.display_amount());
cursor_positions.push(
uniforms
.prev_cursor
.as_ref()
.expect("The recorded cursor must have a preceding sample")
.position
.coord,
);
let layout = uniforms.frame_layout();
assert!(layout.camera.is_some());
result.push((
renderer
.render_immediate(frames, uniforms, &fixture.cursor, true, &mut layers)
.await
.unwrap(),
layout,
));
}
assert!(cursor_positions.windows(2).any(|pair| pair[0] != pair[1]));
assert!(
zoom_amounts
.iter()
.any(|amount| (amount - 1.0).abs() > 0.01)
);
drop(decoders);
result
}
async fn composed_parity(fixture: Fixture, frames: &[u32]) {
composed_parity_with_reference(fixture, frames, true, EditorFrameFormat::Rgba).await;
}
#[tokio::test]
async fn native_preparing_playback_seeks_match_ordinary_and_handoff_joins_sources() {
let mut fixture = fixture(false);
for metadata in [&mut fixture.metadata, &mut fixture.reference_metadata] {
let cap_project::RecordingMetaInner::Studio(studio) = &mut metadata.inner else {
panic!("Studio metadata expected");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Indexed metadata expected");
};
inner.segments[0].mic = None;
}
let expected = ordinary_composed_frames(&fixture, &[0, 45], true).await;
let (frames, mut received) = tokio::sync::mpsc::unbounded_channel();
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
vec![crate::PreparingAudioSegmentInput {
mic: None,
system_audio: None,
timing_repair: Default::default(),
}],
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {}))),
Box::new(move |request, output, layout| {
let EditorFrameOutput::Rgba(frame) = output else {
panic!("Expected RGBA frame");
};
let _ = frames.send((request, frame, layout));
}),
)
.unwrap();
let controller = session.controller();
let stop = session.stop_handle();
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
loop {
if updates.borrow_and_update().progress.preview_available {
break;
}
updates.changed().await.unwrap();
}
})
.await
.unwrap();
assert_eq!(updates.borrow().progress.playable_until, 3.25);
for (index, (expected, expected_layout)) in expected.into_iter().enumerate() {
if index == 1 {
fixture.relocate("retained-during-playback");
tokio::time::timeout(Duration::from_secs(15), controller.seek(1.5))
.await
.unwrap()
.unwrap();
}
let (request, actual, layout) =
tokio::time::timeout(Duration::from_secs(15), received.recv())
.await
.unwrap()
.unwrap();
assert_eq!(request.frame_number, if index == 0 { 0 } else { 45 });
assert_eq!(layout, expected_layout);
assert_eq!(visible_rgba(&actual), visible_rgba(&expected));
}
let seeks = [0.3, 1.0, 2.0, 1.1, 1.5].map(|time| controller.seek(time));
let results = tokio::time::timeout(Duration::from_secs(15), futures::future::join_all(seeks))
.await
.unwrap();
assert!(results.last().unwrap().is_ok());
let mut last_seek_frame = None;
while let Ok((request, _, _)) = received.try_recv() {
last_seek_frame = Some(request.frame_number);
}
assert_eq!(last_seek_frame, Some(45));
controller.set_playing(true).await.unwrap();
let (request, _, _) = tokio::time::timeout(Duration::from_secs(15), received.recv())
.await
.unwrap()
.unwrap();
assert!(request.frame_number >= 45);
controller.set_playing(false).await.unwrap();
let paused = updates.borrow().clone();
assert!(!paused.playback.playing);
tokio::time::sleep(Duration::from_millis(80)).await;
assert_eq!(
updates.borrow().playback.playhead_seconds,
paused.playback.playhead_seconds
);
controller.set_playing(true).await.unwrap();
drop(fixture.source);
let exit = tokio::time::timeout(Duration::from_secs(15), stop.stop_and_wait())
.await
.unwrap();
assert!(exit.error.is_none(), "{:?}", exit.error);
assert_eq!(
exit.snapshot.progress.phase,
crate::PreparingEditorPhase::Handoff
);
assert!(exit.snapshot.playback.playing);
assert!(exit.snapshot.playback.playhead_seconds >= 1.5);
assert!(exit.snapshot.playback.playhead_seconds < 3.25);
let preview = exit.preview.unwrap();
assert_eq!(preview.reason, PreparingPreviewError::Cancelled);
assert_eq!(preview.workers.len(), 1);
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
}
#[tokio::test]
async fn native_preparing_image_does_not_enable_playback_with_unavailable_declared_audio() {
let fixture = fixture(false);
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
vec![crate::PreparingAudioSegmentInput {
mic: None,
system_audio: None,
timing_repair: Default::default(),
}],
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {}))),
Box::new(|_, _, _| {}),
)
.unwrap();
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
loop {
if updates.borrow_and_update().progress.preview_available {
break;
}
updates.changed().await.unwrap();
}
})
.await
.unwrap();
assert_eq!(updates.borrow().progress.playable_until, 0.0);
assert!(session.controller().seek(0.0).await.is_err());
assert!(session.controller().set_playing(true).await.is_err());
let stop = session.stop_handle();
drop(fixture.source);
drop(session);
let exit = tokio::time::timeout(Duration::from_secs(15), stop.stop_and_wait())
.await
.unwrap();
assert!(exit.error.is_none(), "{:?}", exit.error);
assert!(!exit.snapshot.playback.playing);
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
}
#[tokio::test]
async fn native_preparing_playback_audio_matches_completed_pcm_and_releases_its_source() {
use cap_audio::AudioSampleSource;
use std::io::Write;
use std::sync::atomic::AtomicUsize;
let mut fixture = fixture(false);
let expected_metadata = fixture.metadata.clone();
let cap_project::RecordingMetaInner::Studio(studio) = &mut fixture.metadata.inner else {
panic!("Studio metadata expected");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Indexed metadata expected");
};
inner.segments[0].mic.as_mut().unwrap().gap_summary = Some(cap_project::AudioGapSummary {
total_overlap_trimmed_ms: 0,
startup_overlap_trimmed_ms: 0,
overlap_dropped_frames: 0,
startup_overlap_drops: 0,
});
let path = fixture.metadata.project_path.join("mic.aac");
let sample_count = 4 * 48_000_u32;
let mut file = std::fs::File::create(&path).unwrap();
file.write_all(b"RIFF").unwrap();
file.write_all(&(sample_count * 2 + 36).to_le_bytes())
.unwrap();
file.write_all(b"WAVEfmt ").unwrap();
file.write_all(&16_u32.to_le_bytes()).unwrap();
file.write_all(&1_u16.to_le_bytes()).unwrap();
file.write_all(&1_u16.to_le_bytes()).unwrap();
file.write_all(&48_000_u32.to_le_bytes()).unwrap();
file.write_all(&96_000_u32.to_le_bytes()).unwrap();
file.write_all(&2_u16.to_le_bytes()).unwrap();
file.write_all(&16_u16.to_le_bytes()).unwrap();
file.write_all(b"data").unwrap();
file.write_all(&(sample_count * 2).to_le_bytes()).unwrap();
for sample in 0..sample_count {
let value = ((sample % 10_000) as i16 + 1_000).to_le_bytes();
file.write_all(&value).unwrap();
}
drop(file);
let expected = cap_audio::AudioData::from_file(&path).unwrap();
let nonzero = Arc::new(AtomicUsize::new(0));
let tapped = nonzero.clone();
let output = Arc::new(crate::AudioOutput::new_headless(Box::new(
move |samples, _| {
tapped.fetch_add(
samples.iter().filter(|sample| **sample != 0.0).count(),
Ordering::Relaxed,
);
},
)));
let session = crate::PreparingPlaybackSession::spawn_with_expected_metadata(
fixture.input(),
vec![crate::PreparingAudioSegmentInput {
mic: Some(
cap_audio::ManagedAudioInput::new(fixture.source.clone(), PathBuf::from("mic.aac"))
.unwrap(),
),
system_audio: None,
timing_repair: Default::default(),
}],
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
output,
Box::new(|_, _, _| {}),
expected_metadata.clone(),
)
.unwrap();
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
loop {
let ready = {
let state = updates.borrow_and_update();
state.progress.preview_available && state.progress.playable_until == 3.25
};
if ready {
break;
}
updates.changed().await.unwrap();
}
})
.await
.unwrap();
session.controller().seek(1.5).await.unwrap();
session.controller().set_playing(true).await.unwrap();
tokio::time::timeout(Duration::from_secs(15), async {
loop {
if updates.borrow_and_update().playback.playhead_seconds > 1.6 {
break;
}
updates.changed().await.unwrap();
}
})
.await
.unwrap();
assert!(nonzero.load(Ordering::Relaxed) > 0);
let stop = session.stop_handle();
let metadata = expected_metadata;
drop(fixture.source);
let exit = stop.stop_and_wait().await;
assert!(exit.error.is_none(), "{:?}", exit.error);
let retained_exit = exit.clone();
let cached = exit
.take_completed_audio()
.unwrap()
.into_matching(&metadata, metadata.studio_meta().unwrap())
.unwrap();
assert!(retained_exit.take_completed_audio().is_none());
let actual = cached[0].mic.as_ref().unwrap();
assert_eq!(actual.sample_count(), expected.sample_count());
assert_eq!(actual.channels(), expected.channels());
assert!(
actual
.sample_slices()
.flatten()
.zip(expected.samples())
.all(|(actual, expected)| actual.to_bits() == expected.to_bits())
);
assert!(actual.sample(expected.samples().len()).is_none());
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_preparing_audio_decode_failure_never_admits_playback() {
let fixture = fixture(false);
std::fs::write(
fixture.metadata.project_path.join("mic.aac"),
b"invalid audio",
)
.unwrap();
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
vec![crate::PreparingAudioSegmentInput {
mic: Some(
cap_audio::ManagedAudioInput::new(fixture.source.clone(), PathBuf::from("mic.aac"))
.unwrap(),
),
system_audio: None,
timing_repair: Default::default(),
}],
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {}))),
Box::new(|_, _, _| {}),
)
.unwrap();
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(15), async {
loop {
let state = updates.borrow_and_update().clone();
assert_eq!(state.progress.playable_until, 0.0);
if state.progress.phase == crate::PreparingEditorPhase::Unavailable {
break;
}
updates.changed().await.unwrap();
}
})
.await
.unwrap();
assert!(session.controller().set_playing(true).await.is_err());
drop(fixture.source);
let exit = session.stop_handle().stop_and_wait().await;
assert!(exit.error.is_some());
assert!(!exit.cleanup_failed);
assert_eq!(exit.snapshot.progress.playable_until, 0.0);
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
}
async fn composed_parity_with_reference(
fixture: Fixture,
frames: &[u32],
force_ffmpeg: bool,
frame_format: EditorFrameFormat,
) {
let svg = fixture.project.cursor.use_svg;
assert!(!fixture.metadata.project_path.join("cursor.png").exists());
let expected = ordinary_composed_frames(&fixture, frames, force_ffmpeg).await;
let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
let mut preview = PreparingPreview::spawn(
fixture.input(),
PreparingPreviewOptions {
use_hardware_decoding: true,
frame_format,
shared_device: None,
},
Box::new(move |request, output, layout| {
let frame = match output {
EditorFrameOutput::Rgba(frame) => {
assert_eq!(frame_format, EditorFrameFormat::Rgba);
frame
}
#[cfg(target_os = "macos")]
EditorFrameOutput::Surface(frame) => {
assert_eq!(frame_format, EditorFrameFormat::BgraSurface);
surface_rgba(frame)
}
EditorFrameOutput::Nv12(_) => panic!("Unexpected NV12 output"),
};
sender.send((request, frame, layout)).unwrap();
}),
)
.unwrap();
let stop = preview.stop_handle();
let ready = tokio::time::timeout(Duration::from_secs(30), preview.wait_ready())
.await
.unwrap()
.unwrap();
assert_eq!(ready.screen_size, XY::new(160, 120));
assert_eq!(ready.camera_size, Some(XY::new(80, 80)));
for (index, (frame_number, (expected, expected_layout))) in
frames.iter().copied().zip(expected).enumerate()
{
if index == 1 {
fixture.relocate("retained");
}
if index == 2 {
fixture.relocate("original");
}
let sequence = preview
.request_frame(frame_number, 30, XY::new(320, 240))
.unwrap();
let (request, actual, layout) =
tokio::time::timeout(Duration::from_secs(15), receiver.recv())
.await
.unwrap()
.unwrap();
assert_eq!(request.sequence, sequence);
assert_eq!(actual.frame_number, frame_number);
assert_eq!(layout, expected_layout);
assert_eq!(
(actual.width, actual.height),
(expected.width, expected.height)
);
assert_eq!(
visible_rgba(&actual),
visible_rgba(&expected),
"Composed frame differs: svg={svg}, frame={frame_number}"
);
assert!(!fixture.released.load(Ordering::Acquire));
}
assert!(fixture.assets.first_error().is_none());
drop(fixture.source);
let second_stop = preview.stop_handle();
let (first, second) = tokio::join!(stop.stop_and_wait(), second_stop.stop_and_wait());
assert_eq!(first.reason, PreparingPreviewError::Cancelled);
assert_eq!(second.reason, PreparingPreviewError::Cancelled);
assert_eq!(first.workers.len(), fixture.project.clips.len().min(2));
assert!(
first
.workers
.iter()
.all(|worker| worker.display.is_some() && worker.camera.is_some())
);
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
assert!(
fixture
.directory
.path()
.join("released-after-native-join")
.is_dir()
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_preparing_png_cursor_zoom_camera_and_relocation_match_finalized_render() {
composed_parity(fixture(false), &[0, 45, 12, 90]).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_preparing_svg_cursor_zoom_camera_and_relocation_match_finalized_render() {
composed_parity(fixture(true), &[0, 45, 12, 90]).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_recorded_keyboard_without_overlay_matches_finalized_render() {
let mut fixture = fixture(false);
let keyboard = cap_project::KeyboardEvents {
presses: vec![cap_project::KeyPressEvent {
key: "A".into(),
key_code: "KeyA".into(),
time_ms: 0.0,
down: true,
}],
};
for metadata in [&mut fixture.metadata, &mut fixture.reference_metadata] {
let path = metadata.project_path.join("keyboard.bin");
keyboard.write_to_file(&path).unwrap();
let cap_project::RecordingMetaInner::Studio(studio) = &mut metadata.inner else {
panic!("Studio metadata expected");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Indexed metadata expected");
};
inner.segments[0].keyboard = Some("keyboard.bin".into());
let segment = inner.segments[0].clone();
assert_eq!(segment.keyboard_events(metadata).presses, keyboard.presses);
}
let before = serde_json::to_value(&fixture.project).unwrap();
cap_project::synchronize_legacy_keyboard(&fixture.reference_metadata, &mut fixture.project);
assert_eq!(serde_json::to_value(&fixture.project).unwrap(), before);
assert!(fixture.project.keyboard.is_none());
assert!(
fixture
.project
.timeline
.as_ref()
.unwrap()
.keyboard_segments
.is_empty()
);
composed_parity(fixture, &[0, 45, 12, 90]).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_three_clip_eviction_reopen_and_boundaries_match_finalized_render() {
let mut fixture = fixture(false);
for metadata in [&mut fixture.metadata, &mut fixture.reference_metadata] {
let cap_project::RecordingMetaInner::Studio(studio) = &mut metadata.inner else {
panic!("Studio metadata expected");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Indexed metadata expected");
};
inner.segments.resize(3, inner.segments[0].clone());
}
fixture.project.timeline = Some(
serde_json::from_value(serde_json::json!({
"segments": (0..3).map(|index| serde_json::json!({
"recordingSegment": index, "timescale": 1.0, "start": 0.0, "end": 3.0
})).collect::<Vec<_>>(),
"zoomSegments": (0..3).map(|index| serde_json::json!({
"start": f64::from(index) * 3.0 + 0.3,
"end": f64::from(index) * 3.0 + 2.7,
"amount": 1.6, "mode": "auto"
})).collect::<Vec<_>>()
}))
.unwrap(),
);
fixture.project.clips = (0..3)
.map(|index| ClipConfiguration {
index,
offsets: ClipOffsets {
camera: 0.25 + index as f32 * 0.125,
mic: 0.03125,
system_audio: 0.0,
},
offsets_auto_calculated: true,
})
.collect();
composed_parity(fixture, &[0, 90, 180, 12, 89, 90, 179, 180, 269, 0]).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_callback_panic_joins_workers_and_releases_source_owner() {
let fixture = fixture(false);
let (sender, receiver) = tokio::sync::oneshot::channel();
let mut sender = Some(sender);
let mut preview = PreparingPreview::spawn(
fixture.input(),
PreparingPreviewOptions {
use_hardware_decoding: true,
frame_format: EditorFrameFormat::Rgba,
shared_device: None,
},
Box::new(move |_, _, _| {
sender.take().unwrap().send(()).unwrap();
panic!("Native preparing callback failure");
}),
)
.unwrap();
let stop = preview.stop_handle();
tokio::time::timeout(Duration::from_secs(30), preview.wait_ready())
.await
.unwrap()
.unwrap();
drop(fixture.source);
assert!(!fixture.released.load(Ordering::Acquire));
preview.request_frame(0, 30, XY::new(320, 240)).unwrap();
tokio::time::timeout(Duration::from_secs(15), receiver)
.await
.unwrap()
.unwrap();
let exit = tokio::time::timeout(Duration::from_secs(15), stop.stop_and_wait())
.await
.unwrap();
assert_eq!(exit.reason, PreparingPreviewError::Panicked);
assert_eq!(exit.workers.len(), 1);
assert!(exit.workers[0].display.is_some() && exit.workers[0].camera.is_some());
assert!(fixture.released.load(Ordering::Acquire));
assert!(fixture.rename_succeeded.load(Ordering::Acquire));
}
#[cfg(target_os = "macos")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_preparing_matches_default_avasset_editor_decoder() {
composed_parity_with_reference(
fixture(false),
&[0, 45, 12, 90],
false,
EditorFrameFormat::Rgba,
)
.await;
composed_parity_with_reference(
fixture(true),
&[0, 45, 12, 90],
false,
EditorFrameFormat::Rgba,
)
.await;
}
#[cfg(target_os = "macos")]
fn surface_rgba(frame: cap_rendering::SurfaceFrame) -> RenderedFrame {
use std::ffi::c_void;
unsafe extern "C" {
fn CVPixelBufferLockBaseAddress(buffer: *const c_void, flags: u64) -> i32;
fn CVPixelBufferUnlockBaseAddress(buffer: *const c_void, flags: u64) -> i32;
fn CVPixelBufferGetBaseAddress(buffer: *const c_void) -> *const u8;
fn CVPixelBufferGetBytesPerRow(buffer: *const c_void) -> usize;
fn CVPixelBufferGetDataSize(buffer: *const c_void) -> usize;
fn CVPixelBufferGetWidth(buffer: *const c_void) -> usize;
fn CVPixelBufferGetHeight(buffer: *const c_void) -> usize;
fn CVPixelBufferGetPixelFormatType(buffer: *const c_void) -> u32;
}
struct LockedBuffer(*const c_void);
impl Drop for LockedBuffer {
fn drop(&mut self) {
unsafe {
CVPixelBufferUnlockBaseAddress(self.0, 1);
}
}
}
let buffer = std::ptr::from_ref(frame.pixel_buffer.as_ref()).cast::<c_void>();
assert_eq!(unsafe { CVPixelBufferLockBaseAddress(buffer, 1) }, 0);
let lock = LockedBuffer(buffer);
let width = unsafe { CVPixelBufferGetWidth(buffer) };
let height = unsafe { CVPixelBufferGetHeight(buffer) };
let stride = unsafe { CVPixelBufferGetBytesPerRow(buffer) };
let data_size = unsafe { CVPixelBufferGetDataSize(buffer) };
assert_eq!(
unsafe { CVPixelBufferGetPixelFormatType(buffer) },
u32::from_be_bytes(*b"BGRA")
);
assert_eq!(width, frame.width as usize);
assert_eq!(height, frame.height as usize);
let row_bytes = width.checked_mul(4).unwrap();
let buffer_bytes = stride.checked_mul(height).unwrap();
assert!(row_bytes > 0 && height > 0 && stride >= row_bytes);
assert!(data_size >= buffer_bytes);
let address = unsafe { CVPixelBufferGetBaseAddress(buffer) };
assert!(!address.is_null());
let pixels = unsafe { std::slice::from_raw_parts(address, buffer_bytes) };
let mut rgba = Vec::with_capacity(row_bytes.checked_mul(height).unwrap());
for row in pixels.chunks_exact(stride) {
for pixel in row[..row_bytes].chunks_exact(4) {
rgba.extend_from_slice(&[pixel[2], pixel[1], pixel[0], pixel[3]]);
}
}
drop(lock);
RenderedFrame {
data: Arc::new(rgba),
width: frame.width,
height: frame.height,
padded_bytes_per_row: row_bytes.try_into().unwrap(),
frame_number: frame.frame_number,
target_time_ns: frame.target_time_ns,
}
}
#[cfg(target_os = "macos")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_preparing_bgra_surface_matches_default_avasset_editor_frame() {
composed_parity_with_reference(
fixture(false),
&[0, 45, 12, 90],
false,
EditorFrameFormat::BgraSurface,
)
.await;
}
fn handoff_fixture() -> Fixture {
use std::io::Write;
let mut fixture = fixture(false);
let root = fixture.metadata.project_path.clone();
for track in ["display", "camera"] {
std::fs::copy(
fixture
.reference_metadata
.project_path
.join(format!("{track}.mp4")),
root.join(format!("{track}.mp4")),
)
.unwrap();
}
std::fs::copy(
fixture.reference_metadata.project_path.join("cursor.png"),
root.join("cursor.png"),
)
.unwrap();
let cap_project::RecordingMetaInner::Studio(studio) = &mut fixture.metadata.inner else {
panic!("Expected Studio metadata");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Expected indexed metadata");
};
inner.segments[0].display.path = "display.mp4".into();
inner.segments[0].camera.as_mut().unwrap().path = "camera.mp4".into();
inner.segments.resize(3, inner.segments[0].clone());
fixture.metadata.save_for_project().unwrap();
let segment = fixture.project.timeline.as_ref().unwrap().segments[0].clone();
fixture.project.timeline.as_mut().unwrap().segments = (0..3)
.map(|index| cap_project::TimelineSegment {
recording_clip: index,
end: 5.5,
..segment.clone()
})
.collect();
let clip = fixture.project.clips[0].clone();
fixture.project.clips = (0..3)
.map(|index| ClipConfiguration {
index,
..clip.clone()
})
.collect();
fixture.project.write(&root).unwrap();
let sample_count = 8 * 48_000_u32;
let mut file = std::fs::File::create(root.join("mic.aac")).unwrap();
file.write_all(b"RIFF").unwrap();
file.write_all(&(sample_count * 2 + 36).to_le_bytes())
.unwrap();
file.write_all(b"WAVEfmt ").unwrap();
file.write_all(&16_u32.to_le_bytes()).unwrap();
file.write_all(&1_u16.to_le_bytes()).unwrap();
file.write_all(&1_u16.to_le_bytes()).unwrap();
file.write_all(&48_000_u32.to_le_bytes()).unwrap();
file.write_all(&96_000_u32.to_le_bytes()).unwrap();
file.write_all(&2_u16.to_le_bytes()).unwrap();
file.write_all(&16_u16.to_le_bytes()).unwrap();
file.write_all(b"data").unwrap();
file.write_all(&(sample_count * 2).to_le_bytes()).unwrap();
for sample in 0..sample_count {
file.write_all(&((sample % 10_000) as i16 + 1_000).to_le_bytes())
.unwrap();
}
drop(file);
fixture
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_handoff_reuses_pcm_preserves_audio_across_candidate_disposal_and_joins_before_restart()
{
use std::sync::atomic::AtomicUsize;
let fixture = handoff_fixture();
let entry = fixture.metadata.project_path.join("editor-entry");
std::fs::create_dir(&entry).unwrap();
let root = entry.join("..");
assert_ne!(root, fixture.metadata.project_path);
let nonzero = Arc::new(AtomicUsize::new(0));
let tapped = nonzero.clone();
let output = Arc::new(crate::AudioOutput::new_headless(Box::new(
move |samples, _| {
tapped.fetch_add(
samples.iter().filter(|sample| **sample != 0.0).count(),
Ordering::Relaxed,
);
},
)));
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
(0..3)
.map(|_| crate::PreparingAudioSegmentInput {
mic: Some(
cap_audio::ManagedAudioInput::new(
fixture.source.clone(),
PathBuf::from("mic.aac"),
)
.unwrap(),
),
system_audio: None,
timing_repair: Default::default(),
})
.collect(),
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
output.clone(),
Box::new(|_, _, _| {}),
)
.unwrap();
let handoff = session.handoff_handle();
let cache = tokio::time::timeout(Duration::from_secs(30), handoff.take_completed_audio())
.await
.unwrap()
.unwrap();
let expected = cache
.clone()
.into_matching(&fixture.metadata, fixture.metadata.studio_meta().unwrap())
.unwrap()[0]
.mic
.clone()
.unwrap();
let candidate = crate::EditorInstance::new_with_startup_inputs(
root.clone(),
|_| {},
Box::new(|_, _| {}),
None,
crate::EditorFrameFormat::Rgba,
output,
crate::EditorStartupInputs {
recordings: None,
completed_audio: Some(cache),
},
)
.await
.unwrap();
let actual = candidate.segment_medias[0]
.audio
.get()
.await
.unwrap()
.unwrap();
assert!(Arc::ptr_eq(&expected, &actual));
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
while !updates.borrow_and_update().progress.preview_available {
updates.changed().await.unwrap();
}
})
.await
.unwrap();
session.controller().seek(0.5).await.unwrap();
session.controller().set_playing(true).await.unwrap();
candidate.install_preparing_handoff(&handoff).await.unwrap();
let obsolete = candidate.preparing_adoption().unwrap();
session.controller().seek(0.5).await.unwrap();
assert!(obsolete.invalidated());
candidate.dispose().await;
candidate.dispose().await;
let before = nonzero.load(Ordering::Relaxed);
tokio::time::timeout(Duration::from_secs(5), async {
while nonzero.load(Ordering::Relaxed) <= before {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
let (frames, mut received) = tokio::sync::watch::channel(None);
let next = candidate
.recreate_preparing_candidate(
|_| {},
Box::new(move |output, _| {
let frame = match output {
crate::EditorFrameOutput::Rgba(frame) => frame.frame_number,
crate::EditorFrameOutput::Nv12(frame) => frame.frame_number,
#[cfg(target_os = "macos")]
crate::EditorFrameOutput::Surface(frame) => frame.frame_number,
};
frames.send_replace(Some(frame));
}),
crate::EditorFrameFormat::Rgba,
)
.await
.unwrap();
assert!(Arc::ptr_eq(&candidate.segment_medias, &next.segment_medias));
candidate.dispose().await;
assert!(!obsolete.try_commit(15, 30));
assert!(
next.start_preparing_handoff(30, XY::new(320, 240))
.await
.unwrap()
);
tokio::time::timeout(Duration::from_secs(30), async {
loop {
if received
.borrow_and_update()
.is_some_and(|frame| next.commit_preparing_frame(frame, 30))
{
break;
}
received.changed().await.unwrap();
}
})
.await
.unwrap();
assert!(handoff.committed());
assert_eq!(
next.install_preparing_handoff(&handoff).await.unwrap_err(),
"Editor already has a preparing candidate"
);
assert!(handoff.committed());
let before = nonzero.load(Ordering::Relaxed);
tokio::time::timeout(Duration::from_secs(5), async {
while nonzero.load(Ordering::Relaxed) <= before {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.unwrap();
let ordinary = next
.start_playback_with_handle(30, XY::new(320, 240), Some(30))
.await
.unwrap();
let exit = session.stop_handle().stop_and_wait().await;
assert!(!exit.cleanup_failed, "{:?}", exit.error);
assert!(next.preparing_adoption().is_none());
assert!(Arc::ptr_eq(
&expected,
&next.segment_medias[0].audio.get().await.unwrap().unwrap()
));
ordinary.stop();
next.dispose().await;
drop(ordinary);
drop(next);
drop(candidate);
drop(obsolete);
drop(handoff);
drop(session);
drop(fixture.source);
assert!(fixture.released.load(Ordering::Acquire));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_silent_handoff_opens_and_renders_through_an_equivalent_editor_path() {
for count in [1, 2] {
let mut fixture = handoff_fixture();
let segments = crate::completed_audio::tests::segments_mut(&mut fixture.metadata);
segments.truncate(count);
for segment in segments {
segment.mic = None;
segment.system_audio = None;
segment.camera = None;
}
fixture.project.clips.truncate(count);
fixture
.project
.timeline
.as_mut()
.unwrap()
.segments
.truncate(count);
fixture.metadata.save_for_project().unwrap();
fixture
.project
.write(&fixture.metadata.project_path)
.unwrap();
let metadata = fixture.metadata.studio_meta().unwrap();
let input = PreparingPreviewInput {
recording_meta: fixture.metadata.clone(),
project: fixture.project.clone(),
segments: (0..count)
.map(|index| PreparingPreviewSegment {
video: ManagedSegmentVideoInput::new(
index,
metadata,
ManagedVideoTrackInput::new(
fixture.source.clone(),
fixture.display.clone(),
)
.unwrap(),
None,
)
.unwrap(),
cursor: fixture.cursor.clone(),
})
.collect(),
cursor_assets: fixture.assets.clone(),
};
let output = Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {})));
let session = crate::PreparingPlaybackSession::spawn(
input,
(0..count)
.map(|_| crate::PreparingAudioSegmentInput {
mic: None,
system_audio: None,
timing_repair: Default::default(),
})
.collect(),
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
output.clone(),
Box::new(|_, _, _| {}),
)
.unwrap();
let handoff = session.handoff_handle();
let completed_audio =
tokio::time::timeout(Duration::from_secs(30), handoff.take_completed_audio())
.await
.unwrap()
.unwrap();
let entry = fixture.metadata.project_path.join("editor-entry");
std::fs::create_dir(&entry).unwrap();
let (frames, mut received) = watch::channel(None);
let candidate = crate::EditorInstance::new_with_startup_inputs(
entry.join(".."),
|_| {},
Box::new(move |output, _| {
let frame = match output {
crate::EditorFrameOutput::Rgba(frame) => frame.frame_number,
crate::EditorFrameOutput::Nv12(frame) => frame.frame_number,
#[cfg(target_os = "macos")]
crate::EditorFrameOutput::Surface(frame) => frame.frame_number,
};
frames.send_replace(Some(frame));
}),
None,
crate::EditorFrameFormat::Rgba,
output,
crate::EditorStartupInputs {
recordings: None,
completed_audio: Some(completed_audio),
},
)
.await
.unwrap();
assert_eq!(candidate.segment_medias.len(), count);
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
while !updates.borrow_and_update().progress.preview_available {
updates.changed().await.unwrap();
}
})
.await
.unwrap();
candidate.install_preparing_handoff(&handoff).await.unwrap();
candidate
.preview_tx
.send(Some((0, 30, XY::new(320, 240))))
.unwrap();
tokio::time::timeout(Duration::from_secs(30), async {
loop {
if received
.borrow_and_update()
.is_some_and(|frame| candidate.commit_preparing_frame(frame, 30))
{
break;
}
received.changed().await.unwrap();
}
})
.await
.unwrap();
assert!(handoff.committed());
candidate.dispose().await;
let exit = handoff.stop_and_wait().await;
assert!(!exit.cleanup_failed, "{:?}", exit.error);
drop(candidate);
drop(handoff);
drop(session);
drop(fixture.source);
assert!(fixture.released.load(Ordering::Acquire));
}
}
async fn failed_handoff_installation_retires_native_candidate(cancelled: bool) {
use futures::FutureExt;
let fixture = handoff_fixture();
let output = Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {})));
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
(0..3)
.map(|_| crate::PreparingAudioSegmentInput {
mic: Some(
cap_audio::ManagedAudioInput::new(
fixture.source.clone(),
PathBuf::from("mic.aac"),
)
.unwrap(),
),
system_audio: None,
timing_repair: Default::default(),
})
.collect(),
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
output.clone(),
Box::new(|_, _, _| {}),
)
.unwrap();
let handoff = session.handoff_handle();
let cache = tokio::time::timeout(Duration::from_secs(30), handoff.take_completed_audio())
.await
.unwrap()
.unwrap();
let candidate = crate::EditorInstance::new_with_startup_inputs(
fixture.metadata.project_path.clone(),
|_| {},
Box::new(|_, _| {}),
None,
crate::EditorFrameFormat::Rgba,
output,
crate::EditorStartupInputs {
recordings: None,
completed_audio: if cancelled { Some(cache) } else { None },
},
)
.await
.unwrap();
let retained = Arc::downgrade(&candidate);
assert!(candidate.state.lock().await.preview_task.is_some());
if cancelled {
handoff.cancel();
}
let error = tokio::time::timeout(
Duration::from_secs(30),
candidate.install_preparing_handoff(&handoff),
)
.await
.unwrap()
.unwrap_err();
assert_eq!(
error,
if cancelled {
"Preparing playback cannot retry adoption"
} else {
"Preparing audio does not match this editor's completed sources or output"
}
);
assert!(candidate.state.lock().await.preview_task.is_none());
let stop = session.stop_handle();
let exit = stop
.stop_and_wait()
.now_or_never()
.expect("Failed installation returned before managed workers joined");
assert!(!exit.cleanup_failed, "{:?}", exit.error);
drop(exit);
drop(candidate);
assert!(retained.upgrade().is_none());
drop(stop);
drop(handoff);
drop(session);
drop(fixture.source);
assert!(fixture.released.load(Ordering::Acquire));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_cancelled_handoff_installation_joins_and_releases_the_candidate() {
failed_handoff_installation_retires_native_candidate(true).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_rejected_audio_handoff_installation_joins_and_releases_the_candidate() {
failed_handoff_installation_retires_native_candidate(false).await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn native_studio_sound_releases_preparing_audio_and_preserves_transport() {
for initially_enabled in [false, true] {
let mut fixture = handoff_fixture();
let cap_project::RecordingMetaInner::Studio(studio) = &mut fixture.metadata.inner else {
panic!("Expected Studio metadata");
};
let cap_project::StudioRecordingMeta::MultipleSegments { inner } = studio.as_mut() else {
panic!("Expected indexed metadata");
};
for segment in &mut inner.segments {
segment.display.path = "display".into();
segment.camera.as_mut().unwrap().path = "camera".into();
}
fixture.metadata.save_for_project().unwrap();
let output = Arc::new(crate::AudioOutput::new_headless(Box::new(|_, _| {})));
let session = crate::PreparingPlaybackSession::spawn(
fixture.input(),
(0..3)
.map(|_| crate::PreparingAudioSegmentInput {
mic: Some(
cap_audio::ManagedAudioInput::new(
fixture.source.clone(),
PathBuf::from("mic.aac"),
)
.unwrap(),
),
system_audio: None,
timing_repair: Default::default(),
})
.collect(),
crate::PreparingPlaybackOptions {
preview: PreparingPreviewOptions::default(),
fps: 30,
resolution: XY::new(320, 240),
},
output.clone(),
Box::new(|_, _, _| {}),
)
.unwrap();
let handoff = session.handoff_handle();
let cache = tokio::time::timeout(Duration::from_secs(30), handoff.take_completed_audio())
.await
.unwrap()
.unwrap();
let (frames, mut received) = tokio::sync::watch::channel(None);
let candidate = crate::EditorInstance::new_with_startup_inputs(
fixture.metadata.project_path.clone(),
|_| {},
Box::new(move |output, _| {
let frame = match output {
crate::EditorFrameOutput::Rgba(frame) => frame.frame_number,
crate::EditorFrameOutput::Nv12(frame) => frame.frame_number,
#[cfg(target_os = "macos")]
crate::EditorFrameOutput::Surface(frame) => frame.frame_number,
};
frames.send_replace(Some(frame));
}),
None,
crate::EditorFrameFormat::Rgba,
output,
crate::EditorStartupInputs {
recordings: None,
completed_audio: Some(cache),
},
)
.await
.unwrap();
candidate
.project_config
.0
.send_modify(|project| project.audio.improve = initially_enabled);
let mut updates = session.updates();
tokio::time::timeout(Duration::from_secs(30), async {
while !updates.borrow_and_update().progress.preview_available {
updates.changed().await.unwrap();
}
})
.await
.unwrap();
candidate
.preview_tx
.send(Some((0, 30, XY::new(320, 240))))
.unwrap();
tokio::time::timeout(Duration::from_secs(30), async {
while received.borrow_and_update().is_none() {
received.changed().await.unwrap();
}
})
.await
.unwrap();
session.controller().seek(0.5).await.unwrap();
session.controller().set_playing(true).await.unwrap();
candidate.install_preparing_handoff(&handoff).await.unwrap();
assert!(
candidate
.start_preparing_handoff(30, XY::new(320, 240))
.await
.unwrap()
);
tokio::time::timeout(Duration::from_secs(30), async {
loop {
if received
.borrow_and_update()
.is_some_and(|frame| candidate.commit_preparing_frame(frame, 30))
{
break;
}
received.changed().await.unwrap();
}
})
.await
.expect("Prepared editor did not present a handoff frame");
let external_handle = candidate.state.lock().await.playback_task.clone().unwrap();
candidate
.project_config
.0
.send_modify(|project| project.audio.improve = true);
tokio::time::timeout(Duration::from_secs(10), async {
while candidate.preparing_adoption().is_some() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
while !external_handle.seek(18) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
while candidate.state.lock().await.playhead_position < 18 {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let mut active = candidate.playback_watch();
assert!(*active.borrow_and_update());
external_handle.stop();
tokio::time::timeout(Duration::from_secs(5), async {
while *active.borrow_and_update() {
active.changed().await.unwrap();
}
})
.await
.unwrap();
candidate.dispose().await;
}
}