svg_to_video/

lib.rs

#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]

use std::{
    fs,
    io::{Write as _, stdout},
    path::{Path, PathBuf},
    process::{Child, Command, Stdio},
    sync::Arc,
    thread,
    time::Duration,
};

use anyhow::{Context as _, Result};
use atomic_progress::Progress;
use headless_chrome::{Browser, LaunchOptions, Tab};

// ============================================================================
// Codec Domain Logic
// ============================================================================

/// Supported output codecs for the video encoding pipeline.
/// All codecs are configured for mathematically lossless or visually lossless output.
#[derive(clap::ValueEnum, Clone, Debug, Eq, PartialEq)]
pub enum Codec {
    /// Apple `ProRes` 422 HQ (Optimized for NLEs like `DaVinci` Resolve)
    Prores,
    /// FFV1 (Mathematically lossless, ultimate archive format)
    Ffv1,
    /// H.264 Lossless (Large file size, mathematically perfect)
    H264,
    /// HEVC / H.265 Lossless (Better lossless compression than H.264)
    H265,
    /// VP9 Lossless (Google's open-source lossless format)
    Vp9,
    /// AV1 Lossless (Next-gen open-source, mathematically perfect)
    Av1,
}

impl Codec {
    /// Returns the exact `FFmpeg` flags required to encode this codec in a lossless manner.
    #[must_use]
    pub fn ffmpeg_args(&self) -> Vec<&'static str> {
        match self {
            Self::Prores => vec![
                "-c:v",
                "prores_ks",
                "-profile:v",
                "3",
                "-vendor",
                "apl0",
                "-pix_fmt",
                "yuv422p10le",
            ],
            Self::Ffv1 => vec![
                "-c:v", "ffv1", "-level", "3", "-g", "1", "-pix_fmt", "yuv444p",
            ],
            Self::H264 => vec![
                "-c:v",
                "libx264",
                "-preset",
                "ultrafast",
                "-crf",
                "0",
                "-pix_fmt",
                "yuv444p",
            ],
            Self::H265 => vec![
                "-c:v",
                "libx265",
                "-preset",
                "ultrafast",
                "-x265-params",
                "lossless=1",
                "-pix_fmt",
                "yuv444p",
            ],
            Self::Vp9 => vec![
                "-c:v",
                "libvpx-vp9",
                "-lossless",
                "1",
                "-pix_fmt",
                "yuv444p",
            ],
            Self::Av1 => vec![
                "-c:v",
                "libaom-av1",
                "-crf",
                "0",
                "-cpu-used",
                "8",
                "-pix_fmt",
                "yuv444p",
            ],
        }
    }

    /// Warns the user if the chosen file extension does not match the recommended container.
    pub fn validate_extension(&self, output_path: &Path) {
        let ext = output_path
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("")
            .to_lowercase();

        match self {
            Self::Prores if ext != "mov" => {
                eprintln!("⚠️ Warning: ProRes usually requires a .mov container.");
            }
            Self::Ffv1 if ext != "mkv" => {
                eprintln!("⚠️ Warning: FFV1 requires an .mkv container.");
            }
            Self::H264 | Self::H265 if ext != "mp4" && ext != "mkv" => {
                eprintln!("⚠️ Warning: H.264/H.265 usually expect .mp4 or .mkv.");
            }
            Self::Vp9 | Self::Av1 if ext != "webm" && ext != "mkv" => {
                eprintln!("⚠️ Warning: VP9/AV1 usually expect .webm or .mkv.");
            }
            _ => {} // Valid combination
        }
    }
}

// ============================================================================
// Internal Helpers
// ============================================================================

/// Reads the SVG content and wraps it in a perfectly sized HTML document.
///
/// Returns the path to the temporary file created on disk.
pub fn prepare_html_wrapper(input_svg: &Path, width: u32, height: u32) -> Result<PathBuf> {
    let svg_content = fs::read_to_string(input_svg)
        .with_context(|| format!("Failed to read input SVG at {}", input_svg.display()))?;

    let html = format!(
        r"<!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ margin: 0; padding: 0; width: {width}px; height: {height}px; background-color: #ffffff; display: flex; justify-content: center; align-items: center; overflow: hidden; }}
                svg {{ width: 100% !important; height: 100% !important; object-fit: contain !important; }}
            </style>
        </head>
        <body>{svg_content}</body>
        </html>"
    );

    let temp_dir = std::env::temp_dir();
    let temp_html_path = temp_dir.join(format!("svg_wrapper_{}.html", std::process::id()));
    fs::write(&temp_html_path, &html)?;

    Ok(temp_html_path)
}

/// Spawns a background thread to render a CLI progress bar dynamically.
///
/// Returns the `JoinHandle` of the spawned thread to allow graceful termination.
#[must_use]
pub fn spawn_progress_monitor(progress: Progress) -> thread::JoinHandle<()> {
    thread::spawn(move || {
        while !progress.is_finished() {
            let snap = progress.snapshot();
            let pct = if snap.total > 0 {
                #[allow(clippy::cast_precision_loss)]
                {
                    (snap.position as f64 / snap.total as f64) * 100.0
                }
            } else {
                0.0
            };

            let filled = (pct / 5.0) as usize;
            let bar = "█".repeat(filled) + &"░".repeat(20usize.saturating_sub(filled));

            print!(
                "\r{} |{}| {:>5.1}% | Frame {}/{}",
                snap.name, bar, pct, snap.position, snap.total
            );
            let _ = stdout().flush();

            thread::sleep(Duration::from_millis(100));
        }
        println!(
            "\r{} |{}| 100.0% | Done!                    ",
            progress.get_name(),
            "█".repeat(20)
        );
    })
}

/// Initializes an instance of Headless Chrome, enforces a consistent color profile,
/// and navigates a new tab to the provided local HTML wrapper file.
pub fn launch_browser(html_path: &Path, width: u32, height: u32) -> Result<(Browser, Arc<Tab>)> {
    let browser = Browser::new(LaunchOptions {
        headless: true,
        sandbox: false,
        window_size: Some((width, height)),
        args: vec![
            &std::ffi::OsString::from("--disable-dev-shm-usage"),
            &std::ffi::OsString::from("--disable-gpu"),
            &std::ffi::OsString::from("--force-color-profile=srgb"),
        ],
        ..Default::default()
    })
    .context("Failed to launch Headless Chrome")?;

    let tab = browser.new_tab()?;
    let file_url = format!("file://{}", html_path.display());
    tab.navigate_to(&file_url)?;
    tab.wait_until_navigated()?;

    Ok((browser, tab))
}

/// Spawns the underlying `FFmpeg` process configured to accept continuous PNG streams
/// via `stdin` and writes the output directly to the specified destination.
pub fn spawn_ffmpeg_pipeline(fps: u64, codec: &Codec, output: &Path) -> Result<Child> {
    let fps_string = fps.to_string();
    let mut ffmpeg_args = vec![
        "-y",
        "-f",
        "image2pipe",
        "-vcodec",
        "png",
        "-r",
        &fps_string,
        "-i",
        "-",
    ];

    ffmpeg_args.extend(codec.ffmpeg_args());

    let output_str = output.to_string_lossy();
    ffmpeg_args.push(&output_str);

    Command::new("ffmpeg")
        .args(&ffmpeg_args)
        .stdin(Stdio::piped())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .context("Failed to spawn FFmpeg. Ensure it is installed and in your PATH.")
}

/// Executes the core capture loop: pauses animations, advances timing precisely via JS,
/// triggers a screenshot, and pipes the resulting PNG binary directly into `FFmpeg`.
pub fn capture_frames(
    tab: &Tab,
    stdin: &mut std::process::ChildStdin,
    total_frames: u64,
    frame_duration_ms: f64,
    progress: &Progress,
) -> Result<()> {
    for frame in 0..total_frames {
        #[allow(clippy::cast_precision_loss)]
        let current_time_ms = (frame as f64) * frame_duration_ms;
        let current_time_sec = current_time_ms / 1000.0;

        let eval_script = format!(
            r"
            document.getAnimations().forEach(anim => {{
                anim.pause();
                anim.currentTime = {current_time_ms};
            }});
            document.querySelectorAll('svg').forEach(svg => {{
                if (typeof svg.pauseAnimations === 'function') {{
                    svg.pauseAnimations();
                    svg.setCurrentTime({current_time_sec});
                }}
            }});
            "
        );
        tab.evaluate(&eval_script, false)?;

        let png_data = tab.capture_screenshot(
            headless_chrome::protocol::cdp::Page::CaptureScreenshotFormatOption::Png,
            None,
            None,
            true,
        )?;

        stdin.write_all(&png_data)?;
        progress.bump();
    }

    Ok(())
}