Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use cap_rendering::decoder::{AsyncVideoDecoderHandle, spawn_decoder};
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::Instant;
use tokio::runtime::Runtime;
const DEFAULT_DURATION_SECS: f32 = 60.0;
fn get_video_duration(path: &Path) -> f32 {
let output = Command::new("ffprobe")
.args([
"-v",
"error",
"-show_entries",
"format=duration",
"-of",
"default=noprint_wrappers=1:nokey=1",
])
.arg(path)
.output();
match output {
Ok(output) if output.status.success() => {
let duration_str = String::from_utf8_lossy(&output.stdout);
duration_str.trim().parse().unwrap_or(DEFAULT_DURATION_SECS)
}
_ => {
eprintln!(
"Warning: Could not determine video duration via ffprobe, using default {DEFAULT_DURATION_SECS}s"
);
DEFAULT_DURATION_SECS
}
}
}
#[derive(Debug, Clone)]
struct BenchmarkConfig {
video_path: PathBuf,
fps: u32,
iterations: usize,
}
#[derive(Debug, Default)]
struct BenchmarkResults {
decoder_creation_ms: f64,
sequential_decode_times_ms: Vec<f64>,
sequential_fps: f64,
sequential_failures: usize,
seek_times_by_distance: Vec<(f32, f64)>,
seek_failures: usize,
random_access_times_ms: Vec<f64>,
random_access_avg_ms: f64,
random_access_failures: usize,
cache_hits: usize,
cache_misses: usize,
}
impl BenchmarkResults {
fn print_report(&self) {
println!("\n{}", "=".repeat(60));
println!(" VIDEO DECODE BENCHMARK RESULTS");
println!("{}\n", "=".repeat(60));
println!("DECODER CREATION");
println!(
" Time to create decoder: {:.2}ms",
self.decoder_creation_ms
);
println!();
println!("SEQUENTIAL DECODE PERFORMANCE");
if !self.sequential_decode_times_ms.is_empty() || self.sequential_failures > 0 {
let avg: f64 = if self.sequential_decode_times_ms.is_empty() {
0.0
} else {
self.sequential_decode_times_ms.iter().sum::<f64>()
/ self.sequential_decode_times_ms.len() as f64
};
let min = self
.sequential_decode_times_ms
.iter()
.cloned()
.fold(f64::INFINITY, f64::min);
let max = self
.sequential_decode_times_ms
.iter()
.cloned()
.fold(f64::NEG_INFINITY, f64::max);
println!(
" Frames decoded: {}",
self.sequential_decode_times_ms.len()
);
if self.sequential_failures > 0 {
println!(" Frames failed: {}", self.sequential_failures);
}
println!(" Avg decode time: {avg:.2}ms");
println!(" Min decode time: {min:.2}ms");
println!(" Max decode time: {max:.2}ms");
println!(" Effective FPS: {:.1}", self.sequential_fps);
}
println!();
println!("SEEK PERFORMANCE (by distance)");
if !self.seek_times_by_distance.is_empty() || self.seek_failures > 0 {
println!(" {:>10} | {:>12}", "Distance(s)", "Time(ms)");
println!(" {}-+-{}", "-".repeat(10), "-".repeat(12));
for (distance, time) in &self.seek_times_by_distance {
println!(" {distance:>10.1} | {time:>12.2}");
}
if self.seek_failures > 0 {
println!(" Seek failures: {}", self.seek_failures);
}
}
println!();
println!("RANDOM ACCESS PERFORMANCE");
if !self.random_access_times_ms.is_empty() || self.random_access_failures > 0 {
let avg = if self.random_access_times_ms.is_empty() {
0.0
} else {
self.random_access_times_ms.iter().sum::<f64>()
/ self.random_access_times_ms.len() as f64
};
let min = self
.random_access_times_ms
.iter()
.copied()
.fold(f64::INFINITY, f64::min);
let max = self
.random_access_times_ms
.iter()
.copied()
.fold(f64::NEG_INFINITY, f64::max);
println!(" Samples: {}", self.random_access_times_ms.len());
if self.random_access_failures > 0 {
println!(" Failures: {}", self.random_access_failures);
}
println!(" Avg access time: {avg:.2}ms");
println!(" Min access time: {min:.2}ms");
println!(" Max access time: {max:.2}ms");
println!(
" P50: {:.2}ms",
percentile(&self.random_access_times_ms, 50.0)
);
println!(
" P95: {:.2}ms",
percentile(&self.random_access_times_ms, 95.0)
);
println!(
" P99: {:.2}ms",
percentile(&self.random_access_times_ms, 99.0)
);
}
println!();
let total = self.cache_hits + self.cache_misses;
if total > 0 {
println!("CACHE STATISTICS");
println!(
" Hits: {} ({:.1}%)",
self.cache_hits,
100.0 * self.cache_hits as f64 / total as f64
);
println!(
" Misses: {} ({:.1}%)",
self.cache_misses,
100.0 * self.cache_misses as f64 / total as f64
);
}
println!("\n{}\n", "=".repeat(60));
}
}
fn percentile(data: &[f64], p: f64) -> f64 {
let filtered: Vec<f64> = data.iter().copied().filter(|x| !x.is_nan()).collect();
if filtered.is_empty() {
return 0.0;
}
let mut sorted = filtered;
sorted.sort_by(|a, b| {
a.partial_cmp(b)
.expect("NaN values should have been filtered out")
});
let idx = ((p / 100.0) * (sorted.len() - 1) as f64).round() as usize;
sorted[idx.min(sorted.len() - 1)]
}
async fn benchmark_decoder_creation(path: &Path, fps: u32, iterations: usize) -> f64 {
let mut total_ms = 0.0;
for i in 0..iterations {
let start = Instant::now();
let decoder = spawn_decoder("benchmark", path.to_path_buf(), fps, 0.0, false).await;
let elapsed = start.elapsed();
match decoder {
Ok(_) => {
total_ms += elapsed.as_secs_f64() * 1000.0;
}
Err(e) => {
if i == 0 {
eprintln!("Failed to create decoder: {e}");
return -1.0;
}
}
}
}
total_ms / iterations as f64
}
async fn benchmark_sequential_decode(
decoder: &AsyncVideoDecoderHandle,
fps: u32,
frame_count: usize,
start_time: f32,
) -> (Vec<f64>, f64, usize) {
let mut times = Vec::with_capacity(frame_count);
let mut failures = 0;
let overall_start = Instant::now();
for i in 0..frame_count {
let time = start_time + (i as f32 / fps as f32);
let start = Instant::now();
match decoder.get_frame(time).await {
Some(_frame) => {
let elapsed = start.elapsed();
times.push(elapsed.as_secs_f64() * 1000.0);
}
None => {
failures += 1;
eprintln!("Failed to get frame at time {time:.3}s");
}
}
}
let overall_elapsed = overall_start.elapsed();
let successful_frames = frame_count - failures;
let effective_fps = if overall_elapsed.as_secs_f64() > 0.0 {
successful_frames as f64 / overall_elapsed.as_secs_f64()
} else {
0.0
};
(times, effective_fps, failures)
}
async fn benchmark_seek(
decoder: &AsyncVideoDecoderHandle,
_fps: u32,
from_time: f32,
to_time: f32,
) -> Option<f64> {
if decoder.get_frame(from_time).await.is_none() {
eprintln!("Failed to get initial frame at time {from_time:.3}s for seek benchmark");
return None;
}
let start = Instant::now();
match decoder.get_frame(to_time).await {
Some(_frame) => {
let elapsed = start.elapsed();
Some(elapsed.as_secs_f64() * 1000.0)
}
None => {
eprintln!("Failed to get frame at time {to_time:.3}s for seek benchmark");
None
}
}
}
async fn benchmark_random_access(
decoder: &AsyncVideoDecoderHandle,
_fps: u32,
duration_secs: f32,
sample_count: usize,
) -> (Vec<f64>, usize) {
let mut times = Vec::with_capacity(sample_count);
let mut failures = 0;
let golden_ratio = 1.618_034_f32;
let mut position = 0.0_f32;
for _ in 0..sample_count {
position = (position + golden_ratio * duration_secs) % duration_secs;
let start = Instant::now();
match decoder.get_frame(position).await {
Some(_frame) => {
let elapsed = start.elapsed();
times.push(elapsed.as_secs_f64() * 1000.0);
}
None => {
failures += 1;
eprintln!("Failed to get frame at position {position:.3}s during random access");
}
}
}
(times, failures)
}
async fn run_full_benchmark(config: BenchmarkConfig) -> BenchmarkResults {
let mut results = BenchmarkResults::default();
println!(
"Starting benchmark with video: {}",
config.video_path.display()
);
println!("FPS: {}, Iterations: {}", config.fps, config.iterations);
println!();
println!("[1/5] Benchmarking decoder creation...");
results.decoder_creation_ms =
benchmark_decoder_creation(&config.video_path, config.fps, config.iterations).await;
if results.decoder_creation_ms < 0.0 {
eprintln!("Failed to benchmark decoder creation");
return results;
}
println!(" Done: {:.2}ms avg", results.decoder_creation_ms);
println!("[2/5] Creating decoder for remaining tests...");
let decoder = match spawn_decoder(
"benchmark",
config.video_path.clone(),
config.fps,
0.0,
false,
)
.await
{
Ok(d) => d,
Err(e) => {
eprintln!("Failed to create decoder: {e}");
return results;
}
};
println!(" Done");
let video_duration = get_video_duration(&config.video_path);
println!("Detected video duration: {video_duration:.2}s");
println!();
println!("[3/5] Benchmarking sequential decode (100 frames from start)...");
let (seq_times, seq_fps, seq_failures) =
benchmark_sequential_decode(&decoder, config.fps, 100, 0.0).await;
results.sequential_decode_times_ms = seq_times;
results.sequential_fps = seq_fps;
results.sequential_failures = seq_failures;
println!(" Done: {seq_fps:.1} effective FPS");
if seq_failures > 0 {
println!(" Warning: {seq_failures} frames failed to decode");
}
println!("[4/5] Benchmarking seek performance...");
let seek_distances: Vec<f32> = vec![0.5, 1.0, 2.0, 5.0, 10.0, 30.0]
.into_iter()
.filter(|&d| d <= video_duration)
.collect();
for distance in seek_distances {
match benchmark_seek(&decoder, config.fps, 0.0, distance).await {
Some(seek_time) => {
results.seek_times_by_distance.push((distance, seek_time));
println!(" {distance:.1}s seek: {seek_time:.2}ms");
}
None => {
results.seek_failures += 1;
println!(" {distance:.1}s seek: FAILED");
}
}
}
println!("[5/5] Benchmarking random access (50 samples)...");
let (random_times, random_failures) =
benchmark_random_access(&decoder, config.fps, video_duration, 50).await;
results.random_access_times_ms = random_times;
results.random_access_failures = random_failures;
results.random_access_avg_ms = if results.random_access_times_ms.is_empty() {
0.0
} else {
results.random_access_times_ms.iter().sum::<f64>()
/ results.random_access_times_ms.len() as f64
};
println!(" Done: {:.2}ms avg", results.random_access_avg_ms);
if random_failures > 0 {
println!(" Warning: {random_failures} random accesses failed");
}
results
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let video_path = args
.iter()
.position(|a| a == "--video")
.and_then(|i| args.get(i + 1))
.map(PathBuf::from)
.expect("Usage: decode-benchmark --video <path> [--fps <fps>] [--iterations <n>]");
let fps = args
.iter()
.position(|a| a == "--fps")
.and_then(|i| args.get(i + 1))
.and_then(|s| s.parse().ok())
.unwrap_or(30);
let iterations = args
.iter()
.position(|a| a == "--iterations")
.and_then(|i| args.get(i + 1))
.and_then(|s| s.parse().ok())
.unwrap_or(100);
let config = BenchmarkConfig {
video_path,
fps,
iterations,
};
let rt = Runtime::new().expect("Failed to create Tokio runtime");
let results = rt.block_on(run_full_benchmark(config));
results.print_report();
}