Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

29.0 KB
Raw Blame
use cap_project::{
    ProjectConfiguration, RecordingMeta, RecordingMetaInner, StudioRecordingMeta,
    TimelineConfiguration, TimelineSegment, XY,
};
use cap_rendering::{
    FrameRenderer, ProjectRecordingsMeta, ProjectUniforms, RenderVideoConstants, RendererLayers,
    ZoomTransformTimeline, decoder::spawn_decoder,
};
use std::{
    path::{Path, PathBuf},
    sync::Arc,
    time::Instant,
};

fn percentile(data: &[f64], p: f64) -> f64 {
    if data.is_empty() {
        return 0.0;
    }
    let mut sorted: Vec<f64> = data.iter().copied().filter(|x| !x.is_nan()).collect();
    if sorted.is_empty() {
        return 0.0;
    }
    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let idx = ((p / 100.0) * (sorted.len() - 1) as f64).round() as usize;
    sorted[idx.min(sorted.len() - 1)]
}

fn print_stats(label: &str, times_ms: &[f64]) {
    if times_ms.is_empty() {
        println!("  {label}: no data");
        return;
    }
    let avg = times_ms.iter().sum::<f64>() / times_ms.len() as f64;
    let min = times_ms.iter().copied().fold(f64::INFINITY, f64::min);
    let max = times_ms.iter().copied().fold(f64::NEG_INFINITY, f64::max);
    let p50 = percentile(times_ms, 50.0);
    let p95 = percentile(times_ms, 95.0);
    let p99 = percentile(times_ms, 99.0);

    println!("  {label}:");
    println!("    avg={avg:.2}ms  min={min:.2}ms  max={max:.2}ms");
    println!("    p50={p50:.2}ms  p95={p95:.2}ms  p99={p99:.2}ms");
}

#[derive(Default)]
struct PipelineTimings {
    decode_ms: Vec<f64>,
    render_ms: Vec<f64>,
    total_ms: Vec<f64>,
    keyframe_decode_ms: Vec<(f64, f64)>,
    decode_failures: usize,
    render_failures: usize,
    frames_rendered: usize,
}

impl PipelineTimings {
    fn print_report(&self, label: &str) {
        println!("\n{}", "=".repeat(60));
        println!("  {label}");
        println!("{}", "=".repeat(60));

        println!("  Frames rendered: {}", self.frames_rendered);
        if self.decode_failures > 0 {
            println!("  Decode failures: {}", self.decode_failures);
        }
        if self.render_failures > 0 {
            println!("  Render failures: {}", self.render_failures);
        }

        if !self.total_ms.is_empty() {
            let total_time: f64 = self.total_ms.iter().sum();
            let effective_fps = self.frames_rendered as f64 / (total_time / 1000.0);
            println!("  Effective FPS: {effective_fps:.1}");
            println!(
                "  Total time: {total_time:.0}ms for {} frames",
                self.frames_rendered
            );
        }

        println!();
        print_stats("Decode", &self.decode_ms);
        print_stats("GPU Render+Readback", &self.render_ms);
        print_stats("Total (decode+render)", &self.total_ms);
        print_keyframe_distance_report(&self.keyframe_decode_ms);
    }
}

fn print_keyframe_distance_report(samples: &[(f64, f64)]) {
    if samples.is_empty() {
        return;
    }

    let distances_ms: Vec<f64> = samples
        .iter()
        .map(|(distance, _)| distance * 1000.0)
        .collect();
    println!();
    print_stats("Distance after previous keyframe", &distances_ms);

    let avg_distance =
        samples.iter().map(|(distance, _)| *distance).sum::<f64>() / samples.len() as f64;
    let avg_decode = samples.iter().map(|(_, decode)| *decode).sum::<f64>() / samples.len() as f64;
    let covariance = samples
        .iter()
        .map(|(distance, decode)| (distance - avg_distance) * (decode - avg_decode))
        .sum::<f64>();
    let distance_variance = samples
        .iter()
        .map(|(distance, _)| (distance - avg_distance).powi(2))
        .sum::<f64>();
    let decode_variance = samples
        .iter()
        .map(|(_, decode)| (decode - avg_decode).powi(2))
        .sum::<f64>();
    if distance_variance > 0.0 && decode_variance > 0.0 {
        let correlation = covariance / (distance_variance.sqrt() * decode_variance.sqrt());
        println!("  Decode/keyframe-distance correlation: {correlation:.2}");
    }

    const BUCKETS: [(f64, f64, &str); 4] = [
        (0.0, 0.25, "0-250ms"),
        (0.25, 0.5, "250-500ms"),
        (0.5, 0.75, "500-750ms"),
        (0.75, f64::INFINITY, "750ms+"),
    ];

    println!("  Decode by distance after previous keyframe:");
    for (min, max, label) in BUCKETS {
        let values: Vec<f64> = samples
            .iter()
            .filter_map(|(distance, decode)| {
                (*distance >= min && *distance < max).then_some(*decode)
            })
            .collect();
        if values.is_empty() {
            println!("    {label}: no samples");
        } else {
            let avg = values.iter().sum::<f64>() / values.len() as f64;
            println!(
                "    {label}: count={} avg={avg:.2}ms p95={:.2}ms",
                values.len(),
                percentile(&values, 95.0)
            );
        }
    }
}

struct VideoKeyframeStats {
    keyframes: Vec<(u32, f64)>,
    fps: f64,
    duration_secs: f64,
}

impl VideoKeyframeStats {
    fn build(path: &Path) -> Result<Self, String> {
        let mut input = ffmpeg::format::input(path)
            .map_err(|e| format!("Failed to open video for keyframe scan: {e}"))?;

        let (stream_index, time_base, fps, duration_secs) = {
            let video_stream = input
                .streams()
                .best(ffmpeg::media::Type::Video)
                .ok_or("No video stream found")?;

            let stream_index = video_stream.index();
            let time_base = video_stream.time_base();
            let rate = video_stream.avg_frame_rate();
            let fps = if rate.denominator() == 0 {
                30.0
            } else {
                rate.numerator() as f64 / rate.denominator() as f64
            };
            let duration = video_stream.duration();
            let duration_secs = if duration > 0 {
                duration as f64 * time_base.numerator() as f64 / time_base.denominator() as f64
            } else {
                0.0
            };

            (stream_index, time_base, fps, duration_secs)
        };

        let mut keyframes = Vec::new();
        for (stream, packet) in input.packets() {
            if stream.index() != stream_index || !packet.is_key() {
                continue;
            }

            let pts = packet.pts().unwrap_or(0);
            let time_secs =
                pts as f64 * time_base.numerator() as f64 / time_base.denominator() as f64;
            let frame_number = (time_secs * fps).round() as u32;
            keyframes.push((frame_number, time_secs));
        }

        Ok(Self {
            keyframes,
            fps,
            duration_secs,
        })
    }

    fn print_summary(&self, label: &str) {
        let intervals: Vec<f64> = self
            .keyframes
            .windows(2)
            .map(|pair| pair[1].1 - pair[0].1)
            .collect();
        let avg_interval = if intervals.is_empty() {
            0.0
        } else {
            intervals.iter().sum::<f64>() / intervals.len() as f64
        };
        let max_interval = intervals.iter().copied().fold(0.0, f64::max);

        println!(
            "  Keyframes ({label}): count={} fps={:.2} duration={:.2}s avg_interval={avg_interval:.3}s max_interval={max_interval:.3}s",
            self.keyframes.len(),
            self.fps,
            self.duration_secs,
        );
    }

    fn distance_after_previous_keyframe(&self, time_secs: f64) -> Option<f64> {
        if self.keyframes.is_empty() {
            return None;
        }

        let target_frame = (time_secs * self.fps).round() as u32;
        let pos = self
            .keyframes
            .binary_search_by_key(&target_frame, |(frame, _)| *frame);
        let index = match pos {
            Ok(i) => i,
            Err(0) => return None,
            Err(i) => i - 1,
        };

        Some((time_secs - self.keyframes[index].1).max(0.0))
    }
}

async fn load_recording(
    recording_path: &Path,
) -> Result<
    (
        RecordingMeta,
        Box<StudioRecordingMeta>,
        ProjectConfiguration,
        Arc<ProjectRecordingsMeta>,
    ),
    String,
> {
    let recording_meta = RecordingMeta::load_for_project(recording_path)
        .map_err(|e| format!("Failed to load recording meta: {e}"))?;

    let RecordingMetaInner::Studio(meta) = &recording_meta.inner else {
        return Err("Not a studio recording".to_string());
    };
    let meta = meta.clone();

    let mut project = recording_meta.project_config();

    if project.timeline.is_none() {
        let timeline_segments = match meta.as_ref() {
            StudioRecordingMeta::SingleSegment { segment } => {
                let display_path = recording_meta.path(&segment.display.path);
                let duration = match cap_rendering::Video::new(&display_path, 0.0) {
                    Ok(v) => v.duration,
                    Err(_) => 5.0,
                };
                vec![TimelineSegment {
                    recording_clip: 0,
                    start: 0.0,
                    end: duration,
                    timescale: 1.0,
                    name: None,
                    speed_audio_mode: None,
                    hide_cursor: None,
                    volume: None,
                }]
            }
            StudioRecordingMeta::MultipleSegments { inner } => inner
                .segments
                .iter()
                .enumerate()
                .filter_map(|(i, segment)| {
                    let display_path = recording_meta.path(&segment.display.path);
                    let duration = match cap_rendering::Video::new(&display_path, 0.0) {
                        Ok(v) => v.duration,
                        Err(_) => 5.0,
                    };
                    if duration <= 0.0 {
                        return None;
                    }
                    Some(TimelineSegment {
                        recording_clip: i as u32,
                        start: 0.0,
                        end: duration,
                        timescale: 1.0,
                        name: None,
                        speed_audio_mode: None,
                        hide_cursor: None,
                        volume: None,
                    })
                })
                .collect(),
        };

        if !timeline_segments.is_empty() {
            project.timeline = Some(TimelineConfiguration {
                segments: timeline_segments,
                transitions: Vec::new(),
                zoom_segments: Vec::new(),
                scene_segments: Vec::new(),
                style_segments: Vec::new(),
                image_segments: Vec::new(),
                mask_segments: Vec::new(),
                text_segments: Vec::new(),
                caption_segments: Vec::new(),
                keyboard_segments: Vec::new(),
                audio_segments: Vec::new(),
                camera3d_segments: Vec::new(),
            });
        }
    }

    let recordings = Arc::new(
        ProjectRecordingsMeta::new(&recording_meta.project_path, meta.as_ref())
            .map_err(|e| format!("Failed to create recordings meta: {e}"))?,
    );

    Ok((recording_meta, meta, project, recordings))
}

async fn run_decode_only_benchmark(
    recording_meta: &RecordingMeta,
    meta: &StudioRecordingMeta,
    project: &ProjectConfiguration,
    fps: u32,
    frame_count: usize,
    force_ffmpeg: bool,
) -> PipelineTimings {
    let mut timings = PipelineTimings::default();

    let display_path = match meta {
        StudioRecordingMeta::SingleSegment { segment } => {
            recording_meta.path(&segment.display.path)
        }
        StudioRecordingMeta::MultipleSegments { inner } => {
            recording_meta.path(&inner.segments[0].display.path)
        }
    };

    let display_fps = match meta {
        StudioRecordingMeta::SingleSegment { segment } => segment.display.fps,
        StudioRecordingMeta::MultipleSegments { inner } => inner.segments[0].display.fps,
    };

    let decoder = match spawn_decoder(
        "benchmark-screen",
        display_path,
        display_fps,
        0.0,
        force_ffmpeg,
    )
    .await
    {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Failed to create decoder: {e}");
            return timings;
        }
    };

    println!("  Decoder type: {}", decoder.decoder_type());
    println!(
        "  Hardware accelerated: {}",
        decoder.is_hardware_accelerated()
    );
    let (w, h) = decoder.video_dimensions();
    println!("  Video dimensions: {w}x{h}");

    let duration = project
        .timeline
        .as_ref()
        .map(|t| t.duration())
        .unwrap_or(10.0);
    let max_frames = ((duration * fps as f64).ceil() as usize).min(frame_count);

    println!("  Decoding {max_frames} frames at {fps}fps...");

    for i in 0..max_frames {
        let time = i as f32 / fps as f32;
        let start = Instant::now();
        match decoder.get_frame(time).await {
            Some(_frame) => {
                let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0;
                timings.decode_ms.push(elapsed_ms);
                timings.total_ms.push(elapsed_ms);
                timings.frames_rendered += 1;
            }
            None => {
                timings.decode_failures += 1;
            }
        }
    }

    timings
}

struct PipelineBenchmarkConfig {
    fps: u32,
    frame_count: usize,
    resolution_base: XY<u32>,
    force_ffmpeg: bool,
}

async fn run_full_pipeline_benchmark(
    recording_meta: &RecordingMeta,
    meta: &StudioRecordingMeta,
    project: &ProjectConfiguration,
    recordings: &ProjectRecordingsMeta,
    config: PipelineBenchmarkConfig,
) -> PipelineTimings {
    let project = &Arc::new(project.clone());
    let PipelineBenchmarkConfig {
        fps,
        frame_count,
        resolution_base,
        force_ffmpeg,
    } = config;
    let mut timings = PipelineTimings::default();

    let render_constants = match RenderVideoConstants::new(
        &recordings.segments,
        recording_meta.clone(),
        (*meta).clone(),
    )
    .await
    {
        Ok(rc) => Arc::new(rc),
        Err(e) => {
            eprintln!("Failed to create render constants: {e}");
            return timings;
        }
    };

    println!(
        "  GPU adapter: {} (software={})",
        render_constants.adapter_name(),
        render_constants.is_software_adapter
    );

    let segments = match cap_editor::create_segments(recording_meta, meta, force_ffmpeg).await {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Failed to create segments: {e}");
            return timings;
        }
    };

    if segments.is_empty() {
        eprintln!("No segments found");
        return timings;
    }

    let mut frame_renderer = FrameRenderer::new(&render_constants);
    let mut layers = RendererLayers::new_with_options(
        &render_constants.device,
        &render_constants.queue,
        render_constants.is_software_adapter,
    );

    let first_segment = &segments[0];
    let (screen_w, screen_h) = first_segment.decoders.screen_video_dimensions();
    let camera_dims = first_segment.decoders.camera_video_dimensions();
    layers.prepare_for_video_dimensions(
        &render_constants.device,
        screen_w,
        screen_h,
        camera_dims.map(|(w, _)| w),
        camera_dims.map(|(_, h)| h),
    );

    let duration = project
        .timeline
        .as_ref()
        .map(|t| t.duration())
        .unwrap_or(10.0);
    let max_frames = ((duration * fps as f64).ceil() as usize).min(frame_count);

    println!(
        "  Rendering {max_frames} frames at {fps}fps, resolution base: {}x{}...",
        resolution_base.x, resolution_base.y
    );

    let mut zoom_timelines: Vec<ZoomTransformTimeline> = segments
        .iter()
        .map(|segment_media| {
            ZoomTransformTimeline::from_project(
                project,
                &segment_media.cursor,
                duration,
                render_constants.options.screen_size,
            )
        })
        .collect();

    for i in 0..max_frames {
        let frame_time = i as f64 / fps as f64;

        let Some((segment_time, segment)) = project.get_segment_time(frame_time) else {
            break;
        };

        let segment_media = match segments.get(segment.recording_clip as usize) {
            Some(sm) => sm,
            None => {
                timings.decode_failures += 1;
                continue;
            }
        };

        let clip_offsets = project
            .clips
            .iter()
            .find(|v| v.index == segment.recording_clip)
            .map(|v| v.offsets)
            .unwrap_or_default();

        let decode_start = Instant::now();
        let segment_frames_opt = if i == 0 {
            segment_media
                .decoders
                .get_frames_initial(
                    segment_time as f32,
                    !project.camera.hide,
                    true,
                    clip_offsets,
                )
                .await
        } else {
            segment_media
                .decoders
                .get_frames(
                    segment_time as f32,
                    !project.camera.hide,
                    true,
                    clip_offsets,
                )
                .await
        };
        let decode_elapsed_ms = decode_start.elapsed().as_secs_f64() * 1000.0;

        let Some(segment_frames) = segment_frames_opt else {
            timings.decode_failures += 1;
            continue;
        };

        timings.decode_ms.push(decode_elapsed_ms);

        let clip_index = segment.recording_clip as usize;
        let zoom_timeline = &mut zoom_timelines[clip_index];
        zoom_timeline.ensure_precomputed_until((i as f32 + 1.0) / fps as f32);

        let uniforms = ProjectUniforms::new(
            &render_constants,
            project,
            i as u32,
            fps,
            resolution_base,
            &segment_media.cursor,
            &segment_frames,
            duration,
            zoom_timeline,
        );

        let render_start = Instant::now();
        match frame_renderer
            .render_immediate(
                segment_frames,
                uniforms,
                &segment_media.cursor,
                true,
                &mut layers,
            )
            .await
        {
            Ok(_frame) => {
                let render_elapsed_ms = render_start.elapsed().as_secs_f64() * 1000.0;
                timings.render_ms.push(render_elapsed_ms);
                timings.total_ms.push(decode_elapsed_ms + render_elapsed_ms);
                timings.frames_rendered += 1;
            }
            Err(e) => {
                timings.render_failures += 1;
                if timings.render_failures <= 3 {
                    eprintln!("  Render failed at frame {i}: {e}");
                }
            }
        }

        if (i + 1) % 100 == 0 {
            println!("    Progress: {}/{max_frames} frames", i + 1);
        }
    }

    timings
}

async fn run_scrubbing_benchmark(
    recording_meta: &RecordingMeta,
    meta: &StudioRecordingMeta,
    project: &ProjectConfiguration,
    recordings: &ProjectRecordingsMeta,
    fps: u32,
    resolution_base: XY<u32>,
    force_ffmpeg: bool,
) -> PipelineTimings {
    let project = &Arc::new(project.clone());
    let mut timings = PipelineTimings::default();

    let render_constants = match RenderVideoConstants::new(
        &recordings.segments,
        recording_meta.clone(),
        (*meta).clone(),
    )
    .await
    {
        Ok(rc) => Arc::new(rc),
        Err(e) => {
            eprintln!("Failed to create render constants: {e}");
            return timings;
        }
    };

    let segments = match cap_editor::create_segments(recording_meta, meta, force_ffmpeg).await {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Failed to create segments: {e}");
            return timings;
        }
    };

    if segments.is_empty() {
        eprintln!("No segments found");
        return timings;
    }

    let display_paths: Vec<PathBuf> = match meta {
        StudioRecordingMeta::SingleSegment { segment } => {
            vec![recording_meta.path(&segment.display.path)]
        }
        StudioRecordingMeta::MultipleSegments { inner } => inner
            .segments
            .iter()
            .map(|segment| recording_meta.path(&segment.display.path))
            .collect(),
    };
    let keyframe_stats: Vec<Option<VideoKeyframeStats>> = display_paths
        .iter()
        .enumerate()
        .map(|(index, path)| match VideoKeyframeStats::build(path) {
            Ok(stats) => {
                stats.print_summary(&format!("segment {index}"));
                Some(stats)
            }
            Err(e) => {
                eprintln!("  Failed to scan keyframes for {}: {e}", path.display());
                None
            }
        })
        .collect();

    let mut frame_renderer = FrameRenderer::new(&render_constants);
    let mut layers = RendererLayers::new_with_options(
        &render_constants.device,
        &render_constants.queue,
        render_constants.is_software_adapter,
    );

    let first_segment = &segments[0];
    let (screen_w, screen_h) = first_segment.decoders.screen_video_dimensions();
    let camera_dims = first_segment.decoders.camera_video_dimensions();
    layers.prepare_for_video_dimensions(
        &render_constants.device,
        screen_w,
        screen_h,
        camera_dims.map(|(w, _)| w),
        camera_dims.map(|(_, h)| h),
    );

    let duration = project
        .timeline
        .as_ref()
        .map(|t| t.duration())
        .unwrap_or(10.0);

    let mut zoom_timelines: Vec<ZoomTransformTimeline> = segments
        .iter()
        .map(|segment_media| {
            ZoomTransformTimeline::from_project(
                project,
                &segment_media.cursor,
                duration,
                render_constants.options.screen_size,
            )
        })
        .collect();

    let scrub_positions: Vec<f64> = {
        let golden_ratio = 1.618_034;
        let mut positions = Vec::with_capacity(50);
        let mut pos = 0.0;
        for _ in 0..50 {
            pos = (pos + golden_ratio * duration) % duration;
            positions.push(pos);
        }
        positions
    };

    println!(
        "  Scrubbing to {} random positions...",
        scrub_positions.len()
    );

    for (i, &scrub_time) in scrub_positions.iter().enumerate() {
        let Some((segment_time, segment)) = project.get_segment_time(scrub_time) else {
            continue;
        };

        let segment_media = match segments.get(segment.recording_clip as usize) {
            Some(sm) => sm,
            None => continue,
        };

        let clip_offsets = project
            .clips
            .iter()
            .find(|v| v.index == segment.recording_clip)
            .map(|v| v.offsets)
            .unwrap_or_default();

        let decode_start = Instant::now();
        let segment_frames_opt = segment_media
            .decoders
            .get_frames_initial(
                segment_time as f32,
                !project.camera.hide,
                true,
                clip_offsets,
            )
            .await;
        let decode_elapsed_ms = decode_start.elapsed().as_secs_f64() * 1000.0;

        let Some(segment_frames) = segment_frames_opt else {
            timings.decode_failures += 1;
            continue;
        };

        timings.decode_ms.push(decode_elapsed_ms);
        if let Some(distance) = keyframe_stats
            .get(segment.recording_clip as usize)
            .and_then(|stats| stats.as_ref())
            .and_then(|stats| stats.distance_after_previous_keyframe(segment_time))
        {
            timings
                .keyframe_decode_ms
                .push((distance, decode_elapsed_ms));
        }

        let frame_number = (scrub_time * fps as f64).round() as u32;

        let clip_index = segment.recording_clip as usize;
        let zoom_timeline = &mut zoom_timelines[clip_index];
        zoom_timeline.ensure_precomputed_until((frame_number as f32 + 1.0) / fps as f32);

        let uniforms = ProjectUniforms::new(
            &render_constants,
            project,
            frame_number,
            fps,
            resolution_base,
            &segment_media.cursor,
            &segment_frames,
            duration,
            zoom_timeline,
        );

        let render_start = Instant::now();
        match frame_renderer
            .render_immediate(
                segment_frames,
                uniforms,
                &segment_media.cursor,
                true,
                &mut layers,
            )
            .await
        {
            Ok(_frame) => {
                let render_elapsed_ms = render_start.elapsed().as_secs_f64() * 1000.0;
                timings.render_ms.push(render_elapsed_ms);
                timings.total_ms.push(decode_elapsed_ms + render_elapsed_ms);
                timings.frames_rendered += 1;
            }
            Err(e) => {
                timings.render_failures += 1;
                if timings.render_failures <= 3 {
                    eprintln!("  Render failed at scrub {i}: {e}");
                }
            }
        }
    }

    timings
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive(tracing::Level::WARN.into()),
        )
        .init();

    ffmpeg::init().expect("Failed to initialize FFmpeg");

    let args: Vec<String> = std::env::args().collect();

    let recording_path = args
        .iter()
        .position(|a| a == "--recording-path")
        .and_then(|i| args.get(i + 1))
        .map(PathBuf::from)
        .expect("Usage: playback-pipeline-benchmark --recording-path <path> [--fps <fps>] [--frames <count>]");

    let fps = args
        .iter()
        .position(|a| a == "--fps")
        .and_then(|i| args.get(i + 1))
        .and_then(|s| s.parse().ok())
        .unwrap_or(60);

    let frame_count = args
        .iter()
        .position(|a| a == "--frames")
        .and_then(|i| args.get(i + 1))
        .and_then(|s| s.parse().ok())
        .unwrap_or(300);
    let force_ffmpeg = args.iter().any(|arg| arg == "--force-ffmpeg");
    // The editor holds a 1ms timer resolution while playing; this measures under the same condition.
    let timer_1ms = args.iter().any(|arg| arg == "--timer-1ms");
    #[cfg(target_os = "windows")]
    if timer_1ms {
        unsafe { windows::Win32::Media::timeBeginPeriod(1) };
    }

    println!("{}", "=".repeat(60));
    println!("  CAP PLAYBACK PIPELINE BENCHMARK");
    println!("{}", "=".repeat(60));
    println!();
    println!("Recording: {}", recording_path.display());
    println!("Target FPS: {fps}");
    println!("Max frames: {frame_count}");
    println!("Force FFmpeg: {force_ffmpeg}");
    println!("1ms timer: {timer_1ms}");
    println!();

    let (recording_meta, meta, project, recordings) = match load_recording(&recording_path).await {
        Ok(r) => r,
        Err(e) => {
            eprintln!("Failed to load recording: {e}");
            std::process::exit(1);
        }
    };

    let duration = project
        .timeline
        .as_ref()
        .map(|t| t.duration())
        .unwrap_or(0.0);
    println!("Recording duration: {duration:.2}s");

    let resolutions = [
        (XY::new(1920, 1080), "Full (1920x1080)"),
        (XY::new(1248, 702), "Half (1248x702)"),
        (XY::new(480, 270), "Quarter (480x270)"),
    ];

    println!("\n--- DECODE-ONLY BENCHMARK ---");
    let decode_timings = run_decode_only_benchmark(
        &recording_meta,
        meta.as_ref(),
        &project,
        fps,
        frame_count,
        force_ffmpeg,
    )
    .await;
    decode_timings.print_report("DECODE-ONLY");

    for (resolution_base, label) in &resolutions {
        println!("\n--- FULL PIPELINE: {label} ---");
        let pipeline_timings = run_full_pipeline_benchmark(
            &recording_meta,
            meta.as_ref(),
            &project,
            &recordings,
            PipelineBenchmarkConfig {
                fps,
                frame_count,
                resolution_base: *resolution_base,
                force_ffmpeg,
            },
        )
        .await;
        pipeline_timings.print_report(&format!("FULL PIPELINE - {label}"));
    }

    println!("\n--- SCRUBBING BENCHMARK (Half resolution) ---");
    let scrub_timings = run_scrubbing_benchmark(
        &recording_meta,
        meta.as_ref(),
        &project,
        &recordings,
        fps,
        XY::new(1248, 702),
        force_ffmpeg,
    )
    .await;
    scrub_timings.print_report("SCRUBBING (Half resolution)");

    println!("\n{}", "=".repeat(60));
    println!("  BENCHMARK COMPLETE");
    println!("{}", "=".repeat(60));

    let target_frame_time_ms = 1000.0 / fps as f64;
    println!("\nTarget frame time at {fps}fps: {target_frame_time_ms:.2}ms");

    if !decode_timings.decode_ms.is_empty() {
        let decode_p95 = percentile(&decode_timings.decode_ms, 95.0);
        let decode_budget_pct = decode_p95 / target_frame_time_ms * 100.0;
        println!("Decode p95 ({decode_p95:.2}ms) uses {decode_budget_pct:.0}% of frame budget");
    }

    for (_resolution_base, label) in &resolutions {
        println!("\n{label}:");
        println!("  Frame budget: {target_frame_time_ms:.2}ms");
    }
}