Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use ffmpeg::{
codec as avcodec,
format::{self as avformat, context::input::PacketIter},
frame as avframe,
sys::{AVHWDeviceType, EAGAIN},
util as avutil,
};
use ffmpeg_hw_device::{CodecContextExt, HwDevice};
use std::path::{Path, PathBuf};
use std::sync::{Arc, OnceLock};
use tracing::*;
#[derive(Debug, Clone)]
pub struct HwDecoderCapabilities {
pub max_width: u32,
pub max_height: u32,
pub supports_hw_decode: bool,
}
impl Default for HwDecoderCapabilities {
fn default() -> Self {
Self {
max_width: 8192,
max_height: 8192,
supports_hw_decode: true,
}
}
}
static HW_CAPABILITIES: OnceLock<HwDecoderCapabilities> = OnceLock::new();
#[cfg(target_os = "windows")]
fn query_d3d11_video_decoder_capabilities() -> HwDecoderCapabilities {
use windows::{
Win32::{
Foundation::HMODULE,
Graphics::{
Direct3D::D3D_DRIVER_TYPE_UNKNOWN,
Direct3D11::{
D3D11_CREATE_DEVICE_VIDEO_SUPPORT, D3D11_DECODER_PROFILE_H264_VLD_NOFGT,
D3D11_DECODER_PROFILE_HEVC_VLD_MAIN, D3D11_SDK_VERSION,
D3D11_VIDEO_DECODER_DESC, D3D11CreateDevice, ID3D11VideoDevice,
},
Dxgi::Common::DXGI_FORMAT_NV12,
},
},
core::Interface,
};
let result: Result<HwDecoderCapabilities, String> = (|| {
let selected = cap_d3d_adapter::select_capture_adapter(None)?;
let mut device = None;
unsafe {
D3D11CreateDevice(
Some(&selected.adapter),
D3D_DRIVER_TYPE_UNKNOWN,
HMODULE::default(),
D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
None,
D3D11_SDK_VERSION,
Some(&mut device),
None,
None,
)
.map_err(|e| {
format!(
"D3D11CreateDevice failed on '{}': {e:?}",
selected.description
)
})?;
}
let device = device.ok_or("D3D11CreateDevice returned null")?;
let video_device: ID3D11VideoDevice = device
.cast()
.map_err(|e| format!("Failed to get ID3D11VideoDevice: {e:?}"))?;
let profiles = [
D3D11_DECODER_PROFILE_H264_VLD_NOFGT,
D3D11_DECODER_PROFILE_HEVC_VLD_MAIN,
];
let mut max_width = 4096u32;
let mut max_height = 4096u32;
let mut supports_hw = false;
for profile in &profiles {
let desc = D3D11_VIDEO_DECODER_DESC {
Guid: *profile,
SampleWidth: 8192,
SampleHeight: 8192,
OutputFormat: DXGI_FORMAT_NV12,
};
if let Ok(config_count) = unsafe { video_device.GetVideoDecoderConfigCount(&desc) } {
if config_count > 0 {
supports_hw = true;
max_width = max_width.max(8192);
max_height = max_height.max(8192);
}
} else {
let desc_4k = D3D11_VIDEO_DECODER_DESC {
Guid: *profile,
SampleWidth: 4096,
SampleHeight: 4096,
OutputFormat: DXGI_FORMAT_NV12,
};
if let Ok(config_count) =
unsafe { video_device.GetVideoDecoderConfigCount(&desc_4k) }
&& config_count > 0
{
supports_hw = true;
}
}
}
Ok(HwDecoderCapabilities {
max_width,
max_height,
supports_hw_decode: supports_hw,
})
})();
match result {
Ok(caps) => {
info!(
"D3D11 video decoder capabilities: {}x{}, hw_decode={}",
caps.max_width, caps.max_height, caps.supports_hw_decode
);
caps
}
Err(e) => {
warn!("Failed to query D3D11 video decoder capabilities: {e}, using defaults");
HwDecoderCapabilities::default()
}
}
}
#[cfg(not(target_os = "windows"))]
fn query_d3d11_video_decoder_capabilities() -> HwDecoderCapabilities {
HwDecoderCapabilities::default()
}
pub fn get_hw_decoder_capabilities() -> &'static HwDecoderCapabilities {
HW_CAPABILITIES.get_or_init(query_d3d11_video_decoder_capabilities)
}
fn configure_software_threading(decoder: &mut avcodec::decoder::Decoder, width: u32, height: u32) {
let pixel_count = (width as u64) * (height as u64);
let cpu_count = num_cpus::get();
// Frame threads refill their pipeline after every seek, so each extra
// thread adds seek latency. Measured on a 3024x1964 recording, export
// throughput stops improving at 4 threads while editor seeks keep slowing;
// only 3840x2160 and larger sources still gain random-access speed up to 8.
let thread_count = if pixel_count >= 3840 * 2160 {
cpu_count.clamp(2, 8) as i32
} else {
cpu_count.clamp(2, 4) as i32
};
let thread_type = ffmpeg::sys::FF_THREAD_FRAME | ffmpeg::sys::FF_THREAD_SLICE;
unsafe {
let codec_ctx = decoder.as_mut_ptr();
if !codec_ctx.is_null() {
(*codec_ctx).thread_count = thread_count;
(*codec_ctx).thread_type = thread_type;
}
}
info!(
"Software decode configured: {width}x{height}, thread_count={thread_count}, thread_type=frame+slice, cpus={cpu_count}"
);
}
pub struct FFmpegDecoder {
input: DecoderInput,
// Declared before `hw_device` so the codec context, whose get_format
// callback writes to the device's fallback flag, is freed first.
decoder: avcodec::decoder::Video,
stream_index: usize,
hw_device: Option<HwDevice>,
start_time: i64,
}
enum DecoderInput {
File(avformat::context::Input),
Segmented(cap_enc_ffmpeg::SegmentedInput),
#[cfg(feature = "scripted")]
Scripted(crate::scripted::Demuxer),
}
impl DecoderInput {
fn input(&self) -> &avformat::context::Input {
match self {
Self::File(input) => input,
Self::Segmented(input) => input.input(),
#[cfg(feature = "scripted")]
Self::Scripted(_) => unreachable!("scripted media has no container"),
}
}
fn seek(&mut self, position: i64) -> Result<(), ffmpeg::Error> {
match self {
Self::File(input) => input.seek(position, ..position),
Self::Segmented(input) => input.seek(position),
#[cfg(feature = "scripted")]
Self::Scripted(demuxer) => demuxer.seek(position),
}
}
fn packets(&mut self) -> DecoderPackets<'_> {
match self {
Self::File(input) => DecoderPackets::File(input.packets()),
Self::Segmented(input) => DecoderPackets::Segmented(input),
#[cfg(feature = "scripted")]
Self::Scripted(demuxer) => DecoderPackets::Scripted(demuxer),
}
}
}
enum DecoderPackets<'a> {
File(PacketIter<'a>),
Segmented(&'a mut cap_enc_ffmpeg::SegmentedInput),
#[cfg(feature = "scripted")]
Scripted(&'a mut crate::scripted::Demuxer),
}
impl Iterator for DecoderPackets<'_> {
type Item = Result<(usize, ffmpeg::Packet), ffmpeg::Error>;
fn next(&mut self) -> Option<Self::Item> {
match self {
Self::File(packets) => packets
.next()
.map(|(stream, packet)| Ok((stream.index(), packet))),
Self::Segmented(input) => {
let mut packet = ffmpeg::Packet::empty();
match input.read_packet(&mut packet) {
Ok(()) => Some(Ok((packet.stream(), packet))),
Err(ffmpeg::Error::Eof) => None,
Err(error) => Some(Err(error)),
}
}
#[cfg(feature = "scripted")]
Self::Scripted(_) => None,
}
}
}
pub fn open_fragmented_input(
dir_path: &std::path::Path,
) -> Result<cap_enc_ffmpeg::SegmentedInput, String> {
let init_segment = dir_path.join("init.mp4");
if !init_segment.exists() {
return Err(format!(
"init.mp4 not found in fragmented directory: {}",
dir_path.display()
));
}
let mut fragments = std::fs::read_dir(dir_path)
.map_err(|error| format!("read fragmented directory / {error}"))?
.map(|entry| entry.map(|entry| entry.path()))
.collect::<Result<Vec<_>, _>>()
.map_err(|error| format!("read fragmented directory / {error}"))?;
// exFAT stores macOS metadata in `._name` AppleDouble sidecars, which also
// end in .m4s and would sort ahead of the real fragments.
fragments.retain(|path| {
path.extension().is_some_and(|extension| extension == "m4s")
&& !path
.file_name()
.is_some_and(|name| name.as_encoded_bytes().starts_with(b"._"))
});
fragments.sort();
if fragments.is_empty() {
return Err(format!(
"no .m4s segments found in fragmented directory: {}",
dir_path.display()
));
}
cap_enc_ffmpeg::SegmentedInput::open(
std::iter::once(init_segment.as_path()).chain(fragments.iter().map(PathBuf::as_path)),
)
.map_err(|error| format!("open fragmented video / {error}"))
}
impl FFmpegDecoder {
pub fn new(
path: impl Into<PathBuf>,
hw_device_type: Option<AVHWDeviceType>,
) -> Result<Self, String> {
let path = path.into();
#[cfg(feature = "scripted")]
if let Some(state) = crate::scripted::lookup(&path) {
let demuxer = crate::scripted::Demuxer::new(state);
return Ok(FFmpegDecoder {
decoder: demuxer.open_decoder()?,
start_time: demuxer.start_time(),
input: DecoderInput::Scripted(demuxer),
stream_index: 0,
hw_device: None,
});
}
let input = if path.is_dir() {
DecoderInput::Segmented(open_fragmented_input(&path)?)
} else {
DecoderInput::File(
ffmpeg::format::input(&path).map_err(|e| format!("open file / {e}"))?,
)
};
Self::from_input(input, hw_device_type, get_hw_decoder_capabilities())
}
pub fn new_relocatable<'a>(
source: &cap_enc_ffmpeg::RelocatableSource,
paths: impl IntoIterator<Item = &'a Path>,
hw_device_type: Option<AVHWDeviceType>,
) -> Result<Self, String> {
let input = cap_enc_ffmpeg::SegmentedInput::open_relocatable(source, paths)
.map_err(|error| format!("open relocatable video / {error}"))?;
Self::from_input(
DecoderInput::Segmented(input),
hw_device_type,
get_hw_decoder_capabilities(),
)
}
pub fn new_relocatable_interruptible<'a>(
source: &cap_enc_ffmpeg::RelocatableSource,
paths: impl IntoIterator<Item = &'a Path>,
hw_device_type: Option<AVHWDeviceType>,
interrupt: Arc<dyn Fn() -> bool + Send + Sync>,
) -> Result<Self, String> {
let input = cap_enc_ffmpeg::SegmentedInput::open_relocatable_interruptible(
source, paths, interrupt,
)
.map_err(|error| format!("open relocatable video / {error}"))?;
Self::from_input(
DecoderInput::Segmented(input),
hw_device_type,
get_hw_decoder_capabilities(),
)
}
fn from_input(
input: DecoderInput,
hw_device_type: Option<AVHWDeviceType>,
hw_caps: &HwDecoderCapabilities,
) -> Result<Self, String> {
let input_stream = input
.input()
.streams()
.best(avutil::media::Type::Video)
.ok_or_else(|| "no video stream".to_string())?;
let start_time = input_stream.start_time();
let stream_index = input_stream.index();
let (width, height) = unsafe {
let parameters = input_stream.parameters().as_ptr();
(
(*parameters).width.max(0) as u32,
(*parameters).height.max(0) as u32,
)
};
// avcodec_open2, which `.video()` calls, reads the thread settings, so
// software threading must be configured on the unopened decoder.
let open = |software_threading: bool| -> Result<avcodec::decoder::Video, String> {
let mut decoder = avcodec::Context::from_parameters(input_stream.parameters())
.map_err(|e| format!("decoder context / {e}"))?
.decoder();
if software_threading {
configure_software_threading(&mut decoder, width, height);
}
let mut decoder = decoder
.video()
.map_err(|e| format!("video decoder / {e}"))?;
decoder.set_time_base(input_stream.time_base());
Ok(decoder)
};
let exceeds_hw_limits =
width > hw_caps.max_width || height > hw_caps.max_height || !hw_caps.supports_hw_decode;
let (decoder, hw_device) = match hw_device_type {
Some(_) if exceeds_hw_limits => {
warn!(
"Video dimensions {width}x{height} exceed hardware decoder limits ({}x{}), using software decode",
hw_caps.max_width, hw_caps.max_height
);
(open(true)?, None)
}
Some(hw_device_type) => {
let mut decoder = open(false)?;
match decoder.try_use_hw_device(hw_device_type) {
Ok(device) => {
info!(
"Using hardware acceleration for {width}x{height} video (device: {:?})",
hw_device_type
);
(decoder, Some(device))
}
Err(error) => {
warn!(
"Failed to enable hardware decoder: {error:?}, falling back to optimized software decode"
);
(open(true)?, None)
}
}
}
None => (open(true)?, None),
};
Ok(FFmpegDecoder {
input,
decoder,
stream_index,
hw_device,
start_time,
})
}
pub fn reset(&mut self, requested_time: f32) -> Result<(), ffmpeg::Error> {
use ffmpeg::rescale;
// avformat rounds the target to the stream's tick, so a request just
// before a keyframe landed on that keyframe, past the request. The
// reader decodes forward to the request from wherever the seek lands.
const SEEK_MARGIN_US: i64 = 2_000;
let timestamp_us =
((f64::from(requested_time) * 1_000_000.0) as i64 - SEEK_MARGIN_US).max(0);
let position = rescale::Rescale::rescale(×tamp_us, (1, 1_000_000), rescale::TIME_BASE);
self.decoder.flush();
self.input.seek(position)
}
pub fn frames(&mut self) -> FramesIter<'_> {
FramesIter {
packets: self.input.packets(),
decoder: &mut self.decoder,
stream_index: self.stream_index,
hw_device: self.hw_device.as_mut(),
eof_sent: false,
}
}
pub fn decoder(&self) -> &avcodec::decoder::Video {
&self.decoder
}
pub fn start_time(&self) -> i64 {
self.start_time
}
/// Whether frames come from the hardware decoder. False once FFmpeg has
/// fallen back to software because the hardware setup failed, which is
/// only known after the first packet is decoded.
pub fn is_hardware_accelerated(&self) -> bool {
self.hw_device
.as_ref()
.is_some_and(|device| !device.is_software_fallback())
}
}
unsafe impl Send for FFmpegDecoder {}
pub struct FramesIter<'a> {
decoder: &'a mut avcodec::decoder::Video,
packets: DecoderPackets<'a>,
stream_index: usize,
hw_device: Option<&'a mut HwDevice>,
eof_sent: bool,
}
impl FramesIter<'_> {
pub fn decoder(&self) -> &avcodec::decoder::Video {
self.decoder
}
/// [`FFmpegDecoder::is_hardware_accelerated`] while frames are read.
pub fn is_hardware_accelerated(&self) -> bool {
self.hw_device
.as_ref()
.is_some_and(|device| !device.is_software_fallback())
}
}
impl<'a> Iterator for FramesIter<'a> {
type Item = Result<avframe::Video, avutil::error::Error>;
fn next(&mut self) -> Option<Self::Item> {
#[cfg(feature = "scripted")]
if let DecoderPackets::Scripted(demuxer) = &mut self.packets {
return demuxer.next_frame().map(Ok);
}
let mut frame = avframe::Video::empty();
loop {
match self.decoder.receive_frame(&mut frame) {
Ok(()) => {
return match &self.hw_device {
Some(hw_device) => {
let hw_result = hw_device.get_hwframe(&frame);
Some(Ok(hw_result.unwrap_or(frame)))
}
None => Some(Ok(frame)),
};
}
Err(ffmpeg::Error::Eof) => {
return None;
}
Err(ffmpeg::Error::Other { errno }) if errno == EAGAIN => {}
Err(e) => return Some(Err(e)),
}
// Frame threads hold up to thread_count - 1 decoded frames; only
// an end-of-stream signal drains them at the end of the input.
let (stream_index, packet) = match self.packets.next() {
Some(Ok(packet)) => packet,
Some(Err(error)) => return Some(Err(error)),
None if self.eof_sent => return None,
None => {
self.eof_sent = true;
match self.decoder.send_eof() {
Ok(()) => continue,
Err(ffmpeg::Error::Eof) => return None,
Err(e) => return Some(Err(e)),
}
}
};
if stream_index != self.stream_index {
continue;
};
match self.decoder.send_packet(&packet) {
Ok(_) => {}
Err(ffmpeg::Error::Eof) => return None,
Err(ffmpeg::Error::Other { errno }) if errno == EAGAIN => {}
Err(e) => return Some(Err(e)),
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use cap_enc_ffmpeg::segmented_stream::{SegmentedVideoEncoder, SegmentedVideoEncoderConfig};
use std::{fs::File, time::Duration};
fn encode_segments(directory: &std::path::Path) {
ffmpeg::init().unwrap();
let mut encoder = SegmentedVideoEncoder::init(
directory.to_path_buf(),
cap_media_info::VideoInfo {
pixel_format: cap_media_info::Pixel::NV12,
width: 160,
height: 120,
time_base: ffmpeg::Rational(1, 1_000_000),
frame_rate: ffmpeg::Rational(30, 1),
},
SegmentedVideoEncoderConfig::default(),
)
.unwrap();
for index in 0..120 {
let mut frame = avframe::Video::new(avformat::Pixel::NV12, 160, 120);
frame.data_mut(0).fill(32 + (index % 192) as u8);
frame.data_mut(1).fill(128);
encoder
.queue_frame(frame, Duration::from_micros(index * 1_000_000 / 30))
.unwrap();
}
encoder.finish().unwrap();
assert!(encoder.completed_segments().len() >= 2);
}
fn frame_data(frame: avframe::Video) -> (Option<i64>, Vec<u8>) {
assert_eq!(frame.format(), avformat::Pixel::YUV420P);
let mut bytes = Vec::new();
for plane in 0..frame.planes() {
for row in frame
.data(plane)
.chunks(frame.stride(plane))
.take(frame.plane_height(plane) as usize)
{
bytes.extend_from_slice(&row[..frame.plane_width(plane) as usize]);
}
}
(frame.timestamp().or_else(|| frame.pts()), bytes)
}
fn frames(decoder: &mut FFmpegDecoder) -> Vec<(Option<i64>, Vec<u8>)> {
decoder
.frames()
.map(|frame| frame_data(frame.unwrap()))
.collect()
}
#[test]
fn fragmented_decoder_matches_combined_file_for_full_playback_and_seeks() {
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("segments");
encode_segments(&source);
let combined = directory.path().join("combined.mp4");
let mut output = File::create(&combined).unwrap();
std::io::copy(
&mut File::open(source.join("init.mp4")).unwrap(),
&mut output,
)
.unwrap();
let mut paths = std::fs::read_dir(&source)
.unwrap()
.map(|entry| entry.unwrap().path())
.filter(|path| path.extension().is_some_and(|extension| extension == "m4s"))
.collect::<Vec<_>>();
paths.sort();
for path in paths {
std::io::copy(&mut File::open(path).unwrap(), &mut output).unwrap();
}
drop(output);
let mut reference = FFmpegDecoder::new(combined, None).unwrap();
let mut candidate = FFmpegDecoder::new(source, None).unwrap();
assert_eq!(reference.start_time(), candidate.start_time());
let expected = frames(&mut reference);
assert!(!expected.is_empty());
assert_eq!(frames(&mut candidate), expected);
for time in [1.5, 0.0, 3.0, 0.5] {
reference.reset(time).unwrap();
candidate.reset(time).unwrap();
let expected = frames(&mut reference);
assert!(!expected.is_empty());
assert_eq!(frames(&mut candidate), expected);
}
}
#[test]
fn fragmented_decoder_skips_apple_double_sidecars() {
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("segments");
encode_segments(&source);
let expected = frames(&mut FFmpegDecoder::new(&source, None).unwrap());
let fragments = std::fs::read_dir(&source)
.unwrap()
.map(|entry| entry.unwrap().file_name())
.filter(|name| name.to_string_lossy().ends_with(".m4s"))
.collect::<Vec<_>>();
for name in fragments {
let sidecar = format!("._{}", name.to_string_lossy());
std::fs::write(source.join(sidecar), b"\x00\x05\x16\x07").unwrap();
}
assert_eq!(
frames(&mut FFmpegDecoder::new(&source, None).unwrap()),
expected
);
}
#[test]
fn software_decoder_opens_with_frame_threads() {
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("segments");
encode_segments(&source);
// MediaCodec never exists on desktop, so with hardware-capable limits
// it exercises the failed hardware fallback.
for hw_device_type in [None, Some(AVHWDeviceType::AV_HWDEVICE_TYPE_MEDIACODEC)] {
let input = DecoderInput::Segmented(open_fragmented_input(&source).unwrap());
let decoder =
FFmpegDecoder::from_input(input, hw_device_type, &HwDecoderCapabilities::default())
.unwrap();
assert!(decoder.hw_device.is_none());
let context = unsafe { &*decoder.decoder.as_ptr() };
assert!(context.thread_count >= 2);
assert_ne!(context.active_thread_type & ffmpeg::sys::FF_THREAD_FRAME, 0);
}
}
#[test]
fn threaded_decoder_drains_every_frame_at_end_of_input() {
let directory = tempfile::tempdir().unwrap();
let source = directory.path().join("segments");
encode_segments(&source);
let mut decoder = FFmpegDecoder::new(&source, None).unwrap();
assert_eq!(frames(&mut decoder).len(), 120);
decoder.reset(0.0).unwrap();
assert_eq!(frames(&mut decoder).len(), 120);
}
#[test]
fn relocatable_decoder_preserves_live_frames_and_seeks_after_publication() {
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
let retained = directory.path().join("retained");
encode_segments(&original);
let mut paths = std::fs::read_dir(&original)
.unwrap()
.map(|entry| entry.unwrap().file_name().into())
.filter(|path: &PathBuf| path.extension().is_some_and(|extension| extension == "m4s"))
.collect::<Vec<PathBuf>>();
paths.sort();
paths.insert(0, PathBuf::from("init.mp4"));
let mut reference = FFmpegDecoder::new(&original, None).unwrap();
let expected = frames(&mut reference);
let mut seek_reference = Vec::new();
for time in [1.5, 0.0, 3.0, 0.5] {
reference.reset(time).unwrap();
seek_reference.push(frames(&mut reference));
}
let expected_start = reference.start_time();
drop(reference);
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let mut candidate =
FFmpegDecoder::new_relocatable(&source, paths.iter().map(PathBuf::as_path), None)
.unwrap();
assert_eq!(candidate.start_time(), expected_start);
let mut actual = Vec::new();
for (index, count) in [1, 17, 23, 19].into_iter().enumerate() {
actual.extend(
candidate
.frames()
.take(count)
.map(|frame| frame_data(frame.unwrap())),
);
assert!(
source
.relocate(directory.path().join("missing/target"))
.is_err()
);
source
.relocate(if index % 2 == 0 {
retained.clone()
} else {
original.clone()
})
.unwrap();
}
actual.extend(frames(&mut candidate));
assert_eq!(actual, expected);
for (time, expected) in [1.5, 0.0, 3.0, 0.5].into_iter().zip(seek_reference) {
source.relocate(retained.clone()).unwrap();
candidate.reset(time).unwrap();
source.relocate(original.clone()).unwrap();
assert_eq!(frames(&mut candidate), expected);
}
}
#[test]
fn interruptible_video_rejects_cancel_before_registering_missing_sources() {
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
std::fs::create_dir(&original).unwrap();
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let interrupt: Arc<dyn Fn() -> bool + Send + Sync> = Arc::new(|| true);
let owner = Arc::downgrade(&interrupt);
let error = FFmpegDecoder::new_relocatable_interruptible(
&source,
[Path::new("missing.mp4")],
None,
interrupt,
)
.err()
.unwrap();
assert!(error.contains("cancelled"));
assert!(owner.upgrade().is_none());
std::fs::rename(&original, directory.path().join("retained")).unwrap();
}
#[test]
fn interruptible_video_stops_partial_registration_and_releases_ownership() {
use std::{
cell::Cell,
sync::atomic::{AtomicBool, Ordering},
};
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
std::fs::create_dir(&original).unwrap();
std::fs::write(original.join("part.m4s"), b"not parsed before cancellation").unwrap();
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let cancelled = Arc::new(AtomicBool::new(false));
let callback_cancelled = cancelled.clone();
let interrupt: Arc<dyn Fn() -> bool + Send + Sync> =
Arc::new(move || callback_cancelled.load(Ordering::Acquire));
let owner = Arc::downgrade(&interrupt);
let visited = Cell::new(0);
let paths = vec![PathBuf::from("part.m4s"); 512];
let inputs = paths.iter().enumerate().map(|(index, path)| {
visited.set(index + 1);
if index == 64 {
cancelled.store(true, Ordering::Release);
}
path.as_path()
});
let error = FFmpegDecoder::new_relocatable_interruptible(&source, inputs, None, interrupt)
.err()
.unwrap();
assert!(error.contains("cancelled"));
assert!(visited.get() > 64 && visited.get() < paths.len());
assert!(owner.upgrade().is_none());
std::fs::rename(&original, directory.path().join("retained")).unwrap();
}
#[test]
fn interruptible_video_retains_sticky_callback_until_decoder_drop() {
use std::sync::atomic::{AtomicBool, Ordering};
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
encode_segments(&original);
let mut paths = std::fs::read_dir(&original)
.unwrap()
.map(|entry| PathBuf::from(entry.unwrap().file_name()))
.filter(|path| path.extension().is_some_and(|extension| extension == "m4s"))
.collect::<Vec<_>>();
paths.sort();
paths.insert(0, PathBuf::from("init.mp4"));
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let cancelled = Arc::new(AtomicBool::new(false));
let callback_cancelled = cancelled.clone();
let interrupt: Arc<dyn Fn() -> bool + Send + Sync> =
Arc::new(move || callback_cancelled.load(Ordering::Acquire));
let owner = Arc::downgrade(&interrupt);
let mut decoder = FFmpegDecoder::new_relocatable_interruptible(
&source,
paths.iter().map(PathBuf::as_path),
None,
interrupt,
)
.unwrap();
assert!(owner.upgrade().is_some());
assert!(decoder.frames().next().unwrap().is_ok());
cancelled.store(true, Ordering::Release);
assert_eq!(decoder.reset(0.0), Err(ffmpeg::Error::Exit));
cancelled.store(false, Ordering::Release);
assert_eq!(decoder.reset(0.0), Err(ffmpeg::Error::Exit));
assert!(matches!(
decoder.frames().next(),
Some(Err(ffmpeg::Error::Exit))
));
drop(decoder);
assert!(owner.upgrade().is_none());
std::fs::rename(&original, directory.path().join("retained")).unwrap();
}
#[test]
fn interruptible_video_releases_callback_when_input_open_fails() {
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
std::fs::create_dir(&original).unwrap();
std::fs::write(original.join("broken.mp4"), b"invalid video input").unwrap();
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let interrupt: Arc<dyn Fn() -> bool + Send + Sync> = Arc::new(|| false);
let owner = Arc::downgrade(&interrupt);
assert!(
FFmpegDecoder::new_relocatable_interruptible(
&source,
[Path::new("broken.mp4")],
None,
interrupt,
)
.is_err()
);
assert!(owner.upgrade().is_none());
std::fs::rename(&original, directory.path().join("retained")).unwrap();
}
#[test]
fn interruptible_video_releases_callback_when_video_setup_fails() {
let directory = tempfile::tempdir().unwrap();
let original = directory.path().join("original");
std::fs::create_dir(&original).unwrap();
let data_length = 24_000_u32;
let mut wave = Vec::new();
wave.extend_from_slice(b"RIFF");
wave.extend_from_slice(&(36 + data_length).to_le_bytes());
wave.extend_from_slice(b"WAVEfmt ");
wave.extend_from_slice(&16_u32.to_le_bytes());
wave.extend_from_slice(&1_u16.to_le_bytes());
wave.extend_from_slice(&1_u16.to_le_bytes());
wave.extend_from_slice(&48_000_u32.to_le_bytes());
wave.extend_from_slice(&96_000_u32.to_le_bytes());
wave.extend_from_slice(&2_u16.to_le_bytes());
wave.extend_from_slice(&16_u16.to_le_bytes());
wave.extend_from_slice(b"data");
wave.extend_from_slice(&data_length.to_le_bytes());
wave.resize(wave.len() + data_length as usize, 0);
std::fs::write(original.join("audio.wav"), &wave).unwrap();
let source = cap_enc_ffmpeg::RelocatableSource::new(original.clone()).unwrap();
let interrupt: Arc<dyn Fn() -> bool + Send + Sync> = Arc::new(|| false);
let owner = Arc::downgrade(&interrupt);
let error = FFmpegDecoder::new_relocatable_interruptible(
&source,
[Path::new("audio.wav")],
None,
interrupt,
)
.err()
.unwrap();
assert_eq!(error, "no video stream");
assert!(owner.upgrade().is_none());
std::fs::rename(&original, directory.path().join("retained")).unwrap();
}
#[test]
fn fragmented_input_rejects_missing_init_and_empty_segments() {
let directory = tempfile::tempdir().unwrap();
assert!(open_fragmented_input(directory.path()).is_err());
std::fs::write(directory.path().join("init.mp4"), b"invalid").unwrap();
assert!(open_fragmented_input(directory.path()).is_err());
std::fs::create_dir(directory.path().join("segment_001.m4s")).unwrap();
assert!(open_fragmented_input(directory.path()).is_err());
}
}