Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
mod estimate_request;
use crate::editor_window::{OptionalWindowEditorInstance, WindowEditorInstance};
use crate::{FramesRendered, get_video_metadata};
use cap_export::{ExporterBase, make_cursor_only_project};
use cap_project::{RecordingMeta, TimelineFrameMapping, XY};
use cap_rendering::{
FrameRenderer, ProjectRecordingsMeta, ProjectUniforms, RenderSegment, RenderVideoConstants,
RendererLayers, TransitionRenderInput, ZoomTransformTimeline,
};
use cap_utils::export_resources::{DiskBudget, ExportResources, estimated_working_bytes};
use futures::FutureExt;
use image::codecs::jpeg::JpegEncoder;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::any::Any;
use std::future::Future;
use std::panic::AssertUnwindSafe;
use std::{
collections::HashMap,
path::{Path, PathBuf},
process::Stdio,
sync::{
Arc, LazyLock, Mutex, MutexGuard,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
};
use tauri::Manager;
use tauri_plugin_dialog::{DialogExt, MessageDialogButtons, MessageDialogKind};
use tokio::io::AsyncBufReadExt;
use tokio_util::sync::CancellationToken;
use tracing::{error, info, instrument, warn};
fn panic_message(panic: Box<dyn Any + Send>) -> String {
if let Some(msg) = panic.downcast_ref::<&str>() {
msg.to_string()
} else if let Some(msg) = panic.downcast_ref::<String>() {
msg.clone()
} else {
"unknown panic".to_string()
}
}
fn export_panic_error(panic: Box<dyn Any + Send>) -> String {
let panic_msg = panic_message(panic);
error!(
target: "cap_desktop_export",
panic = %panic_msg,
"export command panicked"
);
sentry::capture_message(
&format!("Export command panicked: {panic_msg}"),
sentry::Level::Error,
);
"Export failed unexpectedly".to_string()
}
#[cfg(all(windows, not(debug_assertions)))]
async fn run_export_command<T, F, Fut>(make_future: F) -> Result<T, String>
where
T: Send + 'static,
F: FnOnce() -> Fut + Send + 'static,
Fut: Future<Output = Result<T, String>> + 'static,
{
let (tx, rx) = tokio::sync::oneshot::channel();
// Windows release builds can stack-overflow in Tauri's IPC command entry before the save
// dialog or exporter sidecar starts. Keep the export future off that command-entry stack.
std::thread::Builder::new()
.name("cap-export-command".to_string())
.stack_size(EXPORT_COMMAND_THREAD_STACK_SIZE)
.spawn(move || {
let result = match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(runtime) => runtime.block_on(async move {
match AssertUnwindSafe(make_future()).catch_unwind().await {
Ok(result) => result,
Err(panic) => Err(export_panic_error(panic)),
}
}),
Err(err) => Err(format!("Failed to build export command runtime: {err}")),
};
let _ = tx.send(result);
})
.map_err(|err| format!("Failed to spawn export command thread: {err}"))?;
rx.await
.map_err(|err| format!("Export command thread stopped: {err}"))?
}
#[cfg(not(all(windows, not(debug_assertions))))]
async fn run_export_command<T, F, Fut>(make_future: F) -> Result<T, String>
where
F: FnOnce() -> Fut,
Fut: Future<Output = Result<T, String>>,
{
match AssertUnwindSafe(make_future()).catch_unwind().await {
Ok(result) => result,
Err(panic) => Err(export_panic_error(panic)),
}
}
async fn run_protected_export(
project_path: &Path,
settings: &ExportSettings,
progress: ExportProgress,
force_ffmpeg: bool,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
match AssertUnwindSafe(do_export(
project_path,
settings,
progress,
force_ffmpeg,
cancel_token,
))
.catch_unwind()
.await
{
Ok(result) => result,
Err(panic) => {
let panic_msg = panic_message(panic);
error!(
target: "cap_desktop_export",
panic = %panic_msg,
"export task panicked"
);
sentry::capture_message(
&format!("Export task panicked: {panic_msg}"),
sentry::Level::Error,
);
Err("Export failed unexpectedly".to_string())
}
}
}
const EXPORTER_STDERR_TAIL_LIMIT: usize = 80;
const EXPORT_PROGRESS_FORWARD_INTERVAL: std::time::Duration = std::time::Duration::from_millis(100);
#[cfg(all(windows, not(debug_assertions)))]
const EXPORT_COMMAND_THREAD_STACK_SIZE: usize = 16 * 1024 * 1024;
static ACTIVE_EXPORT_SESSIONS: AtomicUsize = AtomicUsize::new(0);
static ACTIVE_EXPORT_CANCELLATIONS: LazyLock<Mutex<HashMap<String, ActiveExportCancellation>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
static ACTIVE_EXPORT_WINDOW_SESSIONS: LazyLock<Mutex<HashMap<String, usize>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
static NEXT_EXPORT_COMMAND_ID: AtomicUsize = AtomicUsize::new(1);
#[cfg(windows)]
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
#[derive(Deserialize)]
#[serde(tag = "type")]
enum ExportSidecarMessage {
Progress {
rendered_count: u32,
total_frames: u32,
},
Completed {
path: PathBuf,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ExportWorkerMode {
HardwareOptimized,
SoftwareSafe,
}
impl ExportWorkerMode {
fn force_ffmpeg_decoder(self, requested: bool) -> bool {
requested || matches!(self, Self::SoftwareSafe)
}
fn is_software_safe(self) -> bool {
matches!(self, Self::SoftwareSafe)
}
}
#[derive(Clone)]
struct ExportProgress(tauri::ipc::Channel<FramesRendered>);
#[derive(Debug, PartialEq, Eq)]
enum ExportSaveDestination {
Selected(PathBuf),
#[cfg(any(target_os = "macos", test))]
Default,
}
#[cfg(any(target_os = "macos", test))]
fn resolve_macos_export_destination(
result: Result<Option<PathBuf>, String>,
) -> Option<ExportSaveDestination> {
match result {
Ok(path) => path.map(ExportSaveDestination::Selected),
Err(error) => {
warn!(
error,
"Save dialog unavailable; keeping the export in its project output folder"
);
Some(ExportSaveDestination::Default)
}
}
}
struct ExportSaveDialogRequest {
#[cfg(not(target_os = "linux"))]
app: tauri::AppHandle,
#[cfg(target_os = "linux")]
parent: tauri::Window,
#[cfg(target_os = "linux")]
cancel_token: CancellationToken,
file_name: String,
file_type: String,
}
impl ExportProgress {
fn send(&self, progress: FramesRendered) -> bool {
self.0.send(progress).is_ok()
}
}
struct ExportProgressForwarder {
progress: ExportProgress,
last_emit_at: Option<std::time::Instant>,
}
impl ExportProgressForwarder {
fn new(progress: ExportProgress) -> Self {
Self {
progress,
last_emit_at: None,
}
}
fn send(&mut self, rendered_count: u32, total_frames: u32) -> bool {
let now = std::time::Instant::now();
let should_emit = rendered_count == 0
|| rendered_count >= total_frames
|| self
.last_emit_at
.is_none_or(|last| now.duration_since(last) >= EXPORT_PROGRESS_FORWARD_INTERVAL);
if !should_emit {
return true;
}
self.last_emit_at = Some(now);
self.progress.send(FramesRendered {
rendered_count,
total_frames,
})
}
}
struct ActiveExportCancellation {
token: CancellationToken,
window_label: Option<String>,
}
struct ExportCancellationGuard {
export_id: String,
token: CancellationToken,
}
impl ExportCancellationGuard {
fn new(export_id: String, window_label: Option<String>) -> Self {
let token = CancellationToken::new();
active_export_cancellations().insert(
export_id.clone(),
ActiveExportCancellation {
token: token.clone(),
window_label,
},
);
Self { export_id, token }
}
fn token(&self) -> CancellationToken {
self.token.clone()
}
}
impl Drop for ExportCancellationGuard {
fn drop(&mut self) {
active_export_cancellations().remove(&self.export_id);
}
}
fn active_export_cancellations() -> MutexGuard<'static, HashMap<String, ActiveExportCancellation>> {
match ACTIVE_EXPORT_CANCELLATIONS.lock() {
Ok(guard) => guard,
Err(err) => err.into_inner(),
}
}
fn active_export_window_sessions() -> MutexGuard<'static, HashMap<String, usize>> {
match ACTIVE_EXPORT_WINDOW_SESSIONS.lock() {
Ok(guard) => guard,
Err(err) => err.into_inner(),
}
}
fn next_export_command_id(prefix: &str) -> String {
let id = NEXT_EXPORT_COMMAND_ID.fetch_add(1, Ordering::AcqRel);
format!("{prefix}-{id}")
}
fn cancel_export_by_id(export_id: &str) -> bool {
let cancellations = active_export_cancellations();
if let Some(active_export) = cancellations.get(export_id) {
active_export.token.cancel();
return true;
}
false
}
pub fn cancel_exports_for_window(window_label: &str) {
let tokens = {
let cancellations = active_export_cancellations();
cancellations
.values()
.filter(|active_export| active_export.window_label.as_deref() == Some(window_label))
.map(|active_export| active_export.token.clone())
.collect::<Vec<_>>()
};
for token in &tokens {
token.cancel();
}
let released_sessions = release_export_sessions_for_window(window_label);
if !tokens.is_empty() || released_sessions > 0 {
info!(
window = window_label,
cancelled_count = tokens.len(),
released_sessions,
"Cancelled window exports"
);
}
}
pub fn cancel_all_exports() {
let tokens = {
let cancellations = active_export_cancellations();
cancellations
.values()
.map(|active_export| active_export.token.clone())
.collect::<Vec<_>>()
};
for token in &tokens {
token.cancel();
}
let released_sessions = release_all_window_export_sessions();
if !tokens.is_empty() || released_sessions > 0 {
info!(
cancelled_count = tokens.len(),
released_sessions, "Cancelled active exports"
);
}
}
#[tauri::command]
#[specta::specta]
#[instrument]
pub fn cancel_export(export_id: String) -> bool {
cancel_export_by_id(&export_id)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window))]
pub fn cancel_current_window_exports(window: tauri::Window) {
cancel_exports_for_window(window.label());
}
fn retain_export_session() {
let active_exports = ACTIVE_EXPORT_SESSIONS.fetch_add(1, Ordering::AcqRel) + 1;
info!(active_exports, "Export session guard started");
}
fn release_export_session() {
let mut current = ACTIVE_EXPORT_SESSIONS.load(Ordering::Acquire);
loop {
if current == 0 {
tracing::warn!("Export session guard release requested with no active exports");
return;
}
match ACTIVE_EXPORT_SESSIONS.compare_exchange(
current,
current - 1,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => {
info!(
active_exports = current - 1,
"Export session guard released"
);
return;
}
Err(next) => current = next,
}
}
}
pub fn export_session_active() -> bool {
ACTIVE_EXPORT_SESSIONS.load(Ordering::Acquire) > 0
}
fn retain_export_session_for_window(window_label: &str) {
retain_export_session();
let mut sessions = active_export_window_sessions();
*sessions.entry(window_label.to_string()).or_insert(0) += 1;
}
fn release_export_session_for_window(window_label: &str) {
let should_release = {
let mut sessions = active_export_window_sessions();
if let Some(count) = sessions.get_mut(window_label) {
*count -= 1;
if *count == 0 {
sessions.remove(window_label);
}
true
} else {
false
}
};
if should_release {
release_export_session();
} else {
tracing::warn!(
window = window_label,
"Export session guard release requested with no active window export"
);
}
}
fn release_export_sessions_for_window(window_label: &str) -> usize {
let count = active_export_window_sessions()
.remove(window_label)
.unwrap_or(0);
for _ in 0..count {
release_export_session();
}
count
}
fn release_all_window_export_sessions() -> usize {
let count = active_export_window_sessions()
.drain()
.map(|(_, count)| count)
.sum::<usize>();
for _ in 0..count {
release_export_session();
}
count
}
#[tauri::command]
#[specta::specta]
pub fn begin_export_session(window: tauri::Window) {
retain_export_session_for_window(window.label());
}
#[tauri::command]
#[specta::specta]
pub fn end_export_session(window: tauri::Window) {
release_export_session_for_window(window.label());
}
struct ExportSessionGuard;
impl ExportSessionGuard {
fn new() -> Self {
retain_export_session();
Self
}
}
impl Drop for ExportSessionGuard {
fn drop(&mut self) {
release_export_session();
}
}
#[cfg(windows)]
pub(crate) fn configure_exporter_command(command: &mut tokio::process::Command) {
command.creation_flags(CREATE_NO_WINDOW);
}
#[cfg(not(windows))]
pub(crate) fn configure_exporter_command(_command: &mut tokio::process::Command) {}
async fn run_out_of_process_export(
project_path: &Path,
settings: &ExportSettings,
progress: ExportProgress,
force_ffmpeg: bool,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
let mode = initial_export_worker_mode();
match run_out_of_process_export_attempt(
project_path,
settings,
progress.clone(),
force_ffmpeg,
mode,
cancel_token.clone(),
)
.await
{
Ok(path) => Ok(path),
Err(e) if e != "Export cancelled" && !mode.is_software_safe() => {
error!(
error = %e,
"Export worker failed, retrying with software rendering and encoding"
);
run_out_of_process_export_attempt(
project_path,
settings,
progress,
force_ffmpeg,
ExportWorkerMode::SoftwareSafe,
cancel_token,
)
.await
}
Err(e) => Err(e),
}
}
fn initial_export_worker_mode() -> ExportWorkerMode {
if should_start_export_worker_in_software_safe_mode() {
ExportWorkerMode::SoftwareSafe
} else {
ExportWorkerMode::HardwareOptimized
}
}
async fn run_out_of_process_export_attempt(
project_path: &Path,
settings: &ExportSettings,
progress: ExportProgress,
force_ffmpeg: bool,
mode: ExportWorkerMode,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
use cap_utils::operation_diagnostics::{Field, Operation};
let mut diagnostic = Operation::start(
"export_worker",
&[
Field::identifier(
"resource",
cap_utils::operation_diagnostics::resource_id(project_path),
),
Field::number("requested_fps", settings.fps() as u64),
Field::flag("software_safe", mode.is_software_safe()),
Field::flag(
"force_ffmpeg_decoder",
mode.force_ffmpeg_decoder(force_ffmpeg),
),
],
);
let result = run_out_of_process_export_attempt_inner(
project_path,
settings,
progress,
force_ffmpeg,
mode,
cancel_token,
&mut diagnostic,
)
.await;
diagnostic.finish(result.is_ok());
result
}
async fn run_out_of_process_export_attempt_inner(
project_path: &Path,
settings: &ExportSettings,
progress: ExportProgress,
force_ffmpeg: bool,
mode: ExportWorkerMode,
cancel_token: CancellationToken,
diagnostic: &mut cap_utils::operation_diagnostics::Operation,
) -> Result<PathBuf, String> {
use cap_utils::operation_diagnostics::Field;
if cancel_token.is_cancelled() {
return Err("Export cancelled".to_string());
}
diagnostic.stage("resolving_worker");
let bin_path = resolve_exporter_binary()?;
let settings_json = serde_json::to_string(settings)
.map_err(|e| format!("Failed to serialize settings: {e}"))?;
let force_ffmpeg_decoder = mode.force_ffmpeg_decoder(force_ffmpeg);
let mut progress_forwarder = ExportProgressForwarder::new(progress);
info!(
path = %bin_path.display(),
project_path = %project_path.display(),
force_ffmpeg = force_ffmpeg_decoder,
mode = ?mode,
"Starting export worker process"
);
let mut command = tokio::process::Command::new(&bin_path);
command
.arg("export")
.arg(project_path)
.arg("--settings-json")
.arg(settings_json)
.stdin(Stdio::null());
if let Ok(parent) = serde_json::to_string(&diagnostic.id()) {
command.env("CAP_DIAGNOSTIC_PARENT", parent);
}
command.arg("--progress-json");
if force_ffmpeg_decoder {
command.arg("--force-ffmpeg-decoder");
}
if mode.is_software_safe() {
command.env("CAP_EXPORT_FORCE_SOFTWARE_ENCODER", "1");
if cfg!(windows) {
command.env("CAP_RENDER_FORCE_SOFTWARE_ADAPTER", "1");
}
}
configure_exporter_command(&mut command);
let mut child = cap_utils::process::spawn_with_piped_output(command).map_err(|e| {
format!(
"Failed to start export worker '{}': {e}",
bin_path.display()
)
})?;
if let Some(process_id) = child.id() {
diagnostic.field(Field::number("worker_process", process_id as u64));
}
diagnostic.stage("waiting_for_progress");
let stdout = child
.stdout
.take()
.ok_or_else(|| "Export worker stdout was not captured".to_string())?;
let stderr = child
.stderr
.take()
.ok_or_else(|| "Export worker stderr was not captured".to_string())?;
let stderr_task = tokio::spawn(collect_exporter_stderr_tail(stderr));
let mut completed_path = None;
let mut next_diagnostic_frame = 0;
let mut stdout_lines = tokio::io::BufReader::new(stdout).lines();
while let Some(line) = tokio::select! {
line = stdout_lines.next_line() => {
line.map_err(|e| format!("Failed reading export worker stdout: {e}"))?
}
_ = cancel_token.cancelled() => {
let _ = child.kill().await;
let _ = child.wait().await;
let _ = stderr_task.await;
diagnostic.stage("cancelled");
return Err("Export cancelled".to_string());
}
} {
match serde_json::from_str::<ExportSidecarMessage>(&line) {
Ok(ExportSidecarMessage::Progress {
rendered_count,
total_frames,
}) => {
if rendered_count >= next_diagnostic_frame {
diagnostic.field(Field::number("rendered_frames", rendered_count as u64));
diagnostic.field(Field::number("expected_frames", total_frames as u64));
diagnostic.stage("rendering");
next_diagnostic_frame =
rendered_count.saturating_add((total_frames / 10).max(1));
}
if !progress_forwarder.send(rendered_count, total_frames) {
let _ = child.kill().await;
diagnostic.stage("cancelled");
return Err("Export cancelled".to_string());
}
}
Ok(ExportSidecarMessage::Completed { path }) => {
diagnostic.field(Field::flag("worker_reported_completion", true));
diagnostic.stage("waiting_for_worker_exit");
completed_path = Some(path);
}
Err(e) => {
error!(
line = %line,
error = %e,
"Ignoring invalid export worker stdout line"
);
}
}
}
let status = tokio::select! {
status = child.wait() => {
status.map_err(|e| format!("Failed waiting for export worker: {e}"))?
}
_ = cancel_token.cancelled() => {
let _ = child.kill().await;
let _ = child.wait().await;
let _ = stderr_task.await;
diagnostic.stage("cancelled");
return Err("Export cancelled".to_string());
}
};
diagnostic.field(Field::flag("worker_exit_success", status.success()));
if let Some(code) = status.code() {
diagnostic.field(Field::number(
"worker_exit_code_bits",
u64::from(code as u32),
));
}
#[cfg(unix)]
{
use std::os::unix::process::ExitStatusExt;
if let Some(signal) = status.signal() {
diagnostic.field(Field::number("worker_signal", signal as u64));
}
}
diagnostic.stage("worker_exited");
let stderr_tail = stderr_task.await.unwrap_or_default();
if !status.success() {
if let Some(path) = completed_path {
// A worker can report completion and then abort during Windows GPU/codec teardown.
// Treat the completed output as authoritative so a post-export sidecar crash does
// not become a failed export for the user.
error!(
status = %status,
path = %path.display(),
"Export worker exited unsuccessfully after reporting completion"
);
return Ok(path);
}
let stderr_tail = stderr_tail.join("\n");
return Err(format!(
"Export worker exited with status {status}. Stderr tail:\n{stderr_tail}"
));
}
completed_path
.ok_or_else(|| "Export worker finished without reporting an output path".to_string())
}
async fn collect_exporter_stderr_tail(stderr: tokio::process::ChildStderr) -> Vec<String> {
let mut lines = tokio::io::BufReader::new(stderr).lines();
let mut tail = Vec::new();
loop {
match lines.next_line().await {
Ok(Some(line)) => {
if cap_utils::operation_diagnostics::relay_worker_record(&line) {
continue;
}
if cfg!(debug_assertions) {
info!(line = %line, "Export worker stderr");
}
tail.push(line);
if tail.len() > EXPORTER_STDERR_TAIL_LIMIT {
tail.remove(0);
}
}
Ok(None) => break,
Err(e) => {
tail.push(format!("failed reading stderr: {e}"));
break;
}
}
}
tail
}
pub(crate) fn resolve_exporter_binary() -> Result<PathBuf, String> {
let exe = std::env::current_exe().map_err(|e| format!("current_exe: {e}"))?;
if let Some(dir) = exe.parent() {
for candidate in adjacent_exporter_binary_candidates(dir) {
if candidate.exists() {
warn_if_exporter_stale(&exe, &candidate);
return Ok(candidate);
}
}
}
if let Ok(cwd) = std::env::current_dir() {
for root in std::iter::once(cwd.as_path()).chain(cwd.ancestors()) {
for candidate in exporter_binary_candidates(root) {
if candidate.exists() {
warn_if_exporter_stale(&exe, &candidate);
return Ok(candidate);
}
}
}
}
Err(format!(
"Export worker binary not found; place {} next to the app executable or build the Tauri sidecar bundle",
exporter_bin_name()
))
}
/// Dev-loop trap: `tauri dev` rebuilds the app but not the exporter sidecar,
/// so exports can silently run renderer code from days earlier and disagree
/// with the preview. Debug builds log loudly when that is happening.
fn warn_if_exporter_stale(app_exe: &Path, exporter: &Path) {
if !cfg!(debug_assertions) {
return;
}
let mtime = |p: &Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
if let (Some(app_time), Some(exporter_time)) = (mtime(app_exe), mtime(exporter))
&& let Ok(lag) = app_time.duration_since(exporter_time)
&& lag.as_secs() > 60
{
tracing::warn!(
exporter = %exporter.display(),
lag_secs = lag.as_secs(),
"Export worker binary is older than the app; exports may not match \
the preview. Rebuild it (cargo build -p cap) and copy it over \
target/debug/cap-exporter."
);
}
}
fn exporter_binary_candidates(root: &Path) -> Vec<PathBuf> {
let mut candidates = Vec::new();
if cfg!(debug_assertions) {
candidates.extend(debug_exporter_binary_candidates(root));
}
candidates.push(
root.join("apps")
.join("desktop")
.join("src-tauri")
.join("binaries")
.join(exporter_bin_name()),
);
if let Some(target_triple) = current_target_triple() {
candidates.push(
root.join("apps")
.join("desktop")
.join("src-tauri")
.join("binaries")
.join(format!(
"cap-exporter-{target_triple}{}",
std::env::consts::EXE_SUFFIX
)),
);
}
candidates
}
fn debug_exporter_binary_candidates(root: &Path) -> Vec<PathBuf> {
let mut candidates = vec![
root.join("target").join("debug").join(exporter_bin_name()),
root.join("target")
.join("debug")
.join(format!("cap{}", std::env::consts::EXE_SUFFIX)),
];
if let Some(target_triple) = current_target_triple() {
candidates.push(
root.join("target")
.join(target_triple)
.join("debug")
.join(exporter_bin_name()),
);
candidates.push(
root.join("target")
.join(target_triple)
.join("debug")
.join(format!("cap{}", std::env::consts::EXE_SUFFIX)),
);
candidates.push(root.join("target").join("debug").join(format!(
"cap-exporter-{target_triple}{}",
std::env::consts::EXE_SUFFIX
)));
}
candidates
}
fn adjacent_exporter_binary_candidates(dir: &Path) -> Vec<PathBuf> {
let mut candidates = Vec::new();
candidates.push(dir.join(exporter_bin_name()));
if let Some(target_triple) = current_target_triple() {
candidates.push(dir.join(format!(
"cap-exporter-{target_triple}{}",
std::env::consts::EXE_SUFFIX
)));
}
for subdir in ["../MacOS", "../Resources"] {
candidates.push(dir.join(subdir).join(exporter_bin_name()));
if let Some(target_triple) = current_target_triple() {
candidates.push(dir.join(subdir).join(format!(
"cap-exporter-{target_triple}{}",
std::env::consts::EXE_SUFFIX
)));
}
}
candidates
}
fn current_target_triple() -> Option<&'static str> {
if cfg!(all(
target_os = "windows",
target_arch = "x86_64",
target_env = "msvc"
)) {
Some("x86_64-pc-windows-msvc")
} else if cfg!(all(
target_os = "windows",
target_arch = "aarch64",
target_env = "msvc"
)) {
Some("aarch64-pc-windows-msvc")
} else if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
Some("aarch64-apple-darwin")
} else if cfg!(all(target_os = "macos", target_arch = "x86_64")) {
Some("x86_64-apple-darwin")
} else {
None
}
}
fn exporter_bin_name() -> &'static str {
if cfg!(windows) {
"cap-exporter.exe"
} else {
"cap-exporter"
}
}
struct ExportActiveGuard<'a>(&'a AtomicBool);
impl Drop for ExportActiveGuard<'_> {
fn drop(&mut self) {
self.0.store(false, Ordering::Release);
tracing::info!("Resuming editor preview after export");
}
}
struct ExportPreviewActiveGuard<'a>(&'a AtomicBool);
impl<'a> ExportPreviewActiveGuard<'a> {
fn try_new(flag: &'a AtomicBool) -> Result<Self, String> {
flag.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
.map(|_| Self(flag))
.map_err(|_| "Export preview generation is already in progress".to_string())
}
}
impl Drop for ExportPreviewActiveGuard<'_> {
fn drop(&mut self) {
self.0.store(false, Ordering::Release);
}
}
async fn wait_for_export_preview_idle_or_cancel(
flag: &AtomicBool,
cancel_token: &CancellationToken,
) -> Result<(), String> {
while flag.load(Ordering::Acquire) {
tokio::select! {
_ = tokio::time::sleep(std::time::Duration::from_millis(20)) => {}
_ = cancel_token.cancelled() => return Err("Export cancelled".to_string()),
}
}
Ok(())
}
#[derive(Serialize, Deserialize, Clone, Copy, Debug, Type)]
#[serde(tag = "format")]
pub enum ExportSettings {
Mp4(cap_export::mp4::Mp4ExportSettings),
Gif(cap_export::gif::GifExportSettings),
Mov(cap_export::mov::MovExportSettings),
}
impl ExportSettings {
fn fps(&self) -> u32 {
match self {
ExportSettings::Mp4(settings) => settings.fps,
ExportSettings::Gif(settings) => settings.fps,
ExportSettings::Mov(settings) => settings.fps,
}
}
fn force_ffmpeg_decoder(&self) -> bool {
match self {
ExportSettings::Mp4(settings) => settings.force_ffmpeg_decoder,
ExportSettings::Gif(_) | ExportSettings::Mov(_) => false,
}
}
fn cursor_only(&self) -> bool {
match self {
ExportSettings::Mov(settings) => settings.cursor_only,
_ => false,
}
}
}
fn export_project_config(
project_config: cap_project::ProjectConfiguration,
cursor_only: bool,
) -> cap_project::ProjectConfiguration {
if cursor_only {
make_cursor_only_project(project_config)
} else {
project_config
}
}
async fn do_export(
project_path: &Path,
settings: &ExportSettings,
progress: ExportProgress,
force_ffmpeg: bool,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
if cancel_token.is_cancelled() {
return Err("Export cancelled".to_string());
}
let mut exporter_builder =
ExporterBase::builder(project_path.to_path_buf()).with_force_ffmpeg_decoder(force_ffmpeg);
if settings.cursor_only() {
let meta = RecordingMeta::load_for_project(project_path).map_err(|e| e.to_string())?;
exporter_builder =
exporter_builder.with_config(export_project_config(meta.project_config(), true));
}
let exporter_base = exporter_builder.build().await.map_err(|e| e.to_string())?;
let total_frames = exporter_base.total_frames(settings.fps());
if !progress.send(FramesRendered {
rendered_count: 0,
total_frames,
}) {
return Err("Export cancelled".to_string());
}
match settings {
ExportSettings::Mp4(mp4_settings) => {
let progress = progress.clone();
let cancel_token = cancel_token.clone();
mp4_settings
.export(exporter_base, move |frame_index| {
if cancel_token.is_cancelled() {
return false;
}
progress.send(FramesRendered {
rendered_count: (frame_index + 1).min(total_frames),
total_frames,
})
})
.await
}
ExportSettings::Gif(gif_settings) => {
let progress = progress.clone();
let cancel_token = cancel_token.clone();
gif_settings
.export(exporter_base, move |frame_index| {
if cancel_token.is_cancelled() {
return false;
}
progress.send(FramesRendered {
rendered_count: (frame_index + 1).min(total_frames),
total_frames,
})
})
.await
}
ExportSettings::Mov(mov_settings) => {
let progress = progress.clone();
let cancel_token = cancel_token.clone();
mov_settings
.export(exporter_base, move |frame_index| {
if cancel_token.is_cancelled() {
return false;
}
progress.send(FramesRendered {
rendered_count: (frame_index + 1).min(total_frames),
total_frames,
})
})
.await
}
}
}
fn is_frame_decode_error(error: &str) -> bool {
error.contains("Failed to decode video frames")
|| error.contains("Too many consecutive frame failures")
|| error.contains("waiting for frame 0")
}
fn should_force_ffmpeg_export(_project_path: &Path, settings: &ExportSettings) -> bool {
settings.force_ffmpeg_decoder()
}
fn should_force_ffmpeg_preview() -> bool {
false
}
fn should_start_export_worker_in_software_safe_mode() -> bool {
false
}
fn should_use_out_of_process_export() -> bool {
cfg!(any(target_os = "macos", target_os = "windows"))
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window, progress, editor))]
pub async fn export_video(
window: tauri::Window,
project_path: PathBuf,
progress: tauri::ipc::Channel<FramesRendered>,
settings: ExportSettings,
editor: OptionalWindowEditorInstance,
) -> Result<PathBuf, String> {
let window_label = window.label().to_string();
let app = window.app_handle().clone();
Box::pin(run_export_command(move || async move {
let cancellation_guard =
ExportCancellationGuard::new(next_export_command_id("export"), Some(window_label));
let resources = export_resource_preflight(
&app,
&project_path,
&settings,
&editor,
None,
&cancellation_guard.token(),
)
.await?;
export_video_inner(
project_path,
settings,
editor,
ExportProgress(progress),
cancellation_guard.token(),
resources,
)
.await
}))
.await
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window, progress, editor))]
pub async fn export_video_with_id(
window: tauri::Window,
project_path: PathBuf,
progress: tauri::ipc::Channel<FramesRendered>,
settings: ExportSettings,
export_id: String,
editor: OptionalWindowEditorInstance,
) -> Result<PathBuf, String> {
let window_label = window.label().to_string();
let app = window.app_handle().clone();
Box::pin(run_export_command(move || async move {
let cancellation_guard = ExportCancellationGuard::new(export_id, Some(window_label));
let resources = export_resource_preflight(
&app,
&project_path,
&settings,
&editor,
None,
&cancellation_guard.token(),
)
.await?;
export_video_inner(
project_path,
settings,
editor,
ExportProgress(progress),
cancellation_guard.token(),
resources,
)
.await
}))
.await
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window, progress, editor))]
pub async fn export_video_to_file(
window: tauri::Window,
project_path: PathBuf,
progress: tauri::ipc::Channel<FramesRendered>,
settings: ExportSettings,
file_name: String,
file_type: String,
editor: OptionalWindowEditorInstance,
) -> Result<PathBuf, String> {
let app = window.app_handle().clone();
let window_label = window.label().to_string();
Box::pin(run_export_command(move || async move {
let cancellation_guard = ExportCancellationGuard::new(
next_export_command_id("export-to-file"),
Some(window_label),
);
export_video_to_file_inner(
app.clone(),
project_path,
settings,
editor,
ExportProgress(progress),
ExportSaveDialogRequest {
#[cfg(not(target_os = "linux"))]
app,
#[cfg(target_os = "linux")]
parent: window,
#[cfg(target_os = "linux")]
cancel_token: cancellation_guard.token(),
file_name,
file_type,
},
cancellation_guard.token(),
)
.await
}))
.await
}
async fn export_video_to_file_inner(
app: tauri::AppHandle,
project_path: PathBuf,
settings: ExportSettings,
editor: OptionalWindowEditorInstance,
progress: ExportProgress,
save_dialog: ExportSaveDialogRequest,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
let _session_guard = ExportSessionGuard::new();
let Some(save_path) = show_export_save_dialog(save_dialog).await? else {
return Err("Save dialog cancelled".to_string());
};
let destination = match &save_path {
ExportSaveDestination::Selected(path) => Some(path.as_path()),
#[cfg(any(target_os = "macos", test))]
ExportSaveDestination::Default => None,
};
let resources = export_resource_preflight(
&app,
&project_path,
&settings,
&editor,
destination,
&cancel_token,
)
.await?;
let output_path = export_video_inner(
project_path,
settings,
editor,
progress,
cancel_token,
resources,
)
.await?;
match save_path {
ExportSaveDestination::Selected(path) => {
copy_export_to_path(&output_path, &path).await?;
Ok(path)
}
#[cfg(any(target_os = "macos", test))]
ExportSaveDestination::Default => Ok(output_path),
}
}
async fn export_resource_preflight(
app: &tauri::AppHandle,
project_path: &Path,
settings: &ExportSettings,
editor: &OptionalWindowEditorInstance,
destination: Option<&Path>,
cancel: &CancellationToken,
) -> Result<ExportResources, String> {
if cancel.is_cancelled() {
return Err("Export cancelled".into());
}
let estimate = editor
.as_ref()
.map(|editor| {
let duration = export_estimate_duration(
&editor.project_config.1.borrow(),
editor.recordings.duration(),
);
estimated_working_bytes(
export_estimates_for_duration(settings, duration).estimated_size_mb,
)
})
.unwrap_or(0);
let mut disks = vec![DiskBudget {
path: project_path.to_path_buf(),
description: "your recording drive",
estimated_bytes: estimate,
}];
if let Some(path) = destination {
disks.push(DiskBudget {
path: path.to_path_buf(),
description: "your export drive",
estimated_bytes: estimate,
});
}
let resources = ExportResources::new(disks);
if let Some(message) = resources.check().await? {
if cancel.is_cancelled() {
return Err("Export cancelled".into());
}
let (sender, receiver) = tokio::sync::oneshot::channel();
app.dialog()
.message(message)
.title("Check export resources")
.kind(MessageDialogKind::Warning)
.buttons(MessageDialogButtons::OkCancelCustom(
"Proceed anyway".into(),
"Go back".into(),
))
.show(move |confirmed| {
let _ = sender.send(confirmed);
});
let confirmed = tokio::select! {
biased;
_ = cancel.cancelled() => false,
confirmed = receiver => confirmed.unwrap_or(false),
};
if !confirmed {
return Err("Export cancelled".into());
}
let _ = resources.check().await?;
}
if cancel.is_cancelled() {
return Err("Export cancelled".into());
}
Ok(resources)
}
async fn export_video_inner(
project_path: PathBuf,
settings: ExportSettings,
editor: OptionalWindowEditorInstance,
progress: ExportProgress,
cancel_token: CancellationToken,
resources: ExportResources,
) -> Result<PathBuf, String> {
let stopped = cancel_token.child_token();
resources
.supervise(
export_video_attempts(project_path, settings, editor, progress, stopped.clone()),
|| stopped.cancel(),
)
.await
}
async fn export_video_attempts(
project_path: PathBuf,
settings: ExportSettings,
editor: OptionalWindowEditorInstance,
progress: ExportProgress,
cancel_token: CancellationToken,
) -> Result<PathBuf, String> {
let _session_guard = ExportSessionGuard::new();
let force_ffmpeg = should_force_ffmpeg_export(&project_path, &settings);
info!(
project_path = %project_path.display(),
force_ffmpeg,
settings = ?settings,
"Starting export"
);
let _guard = if let Some(ref ed) = *editor {
ed.export_active.store(true, Ordering::Release);
tracing::info!("Pausing editor preview during export");
Some(ExportActiveGuard(&ed.export_active))
} else {
None
};
if let Some(ref ed) = *editor {
wait_for_export_preview_idle_or_cancel(&ed.export_preview_active, &cancel_token).await?;
}
let result = if should_use_out_of_process_export() {
run_out_of_process_export(
&project_path,
&settings,
progress.clone(),
force_ffmpeg,
cancel_token.clone(),
)
.await
} else {
run_protected_export(
&project_path,
&settings,
progress.clone(),
force_ffmpeg,
cancel_token.clone(),
)
.await
};
match result {
Ok(path) => {
info!("Exported to {} completed", path.display());
Ok(path)
}
Err(e) if !force_ffmpeg && is_frame_decode_error(&e) => {
if cancel_token.is_cancelled() {
return Err("Export cancelled".to_string());
}
info!(
"Export failed with frame decode error, retrying with FFmpeg decoder: {}",
e
);
let retry_result = if should_use_out_of_process_export() {
run_out_of_process_export(
&project_path,
&settings,
progress,
true,
cancel_token.clone(),
)
.await
} else {
run_protected_export(
&project_path,
&settings,
progress,
true,
cancel_token.clone(),
)
.await
};
match retry_result {
Ok(path) => {
info!(
"Export succeeded with FFmpeg decoder fallback: {}",
path.display()
);
Ok(path)
}
Err(retry_e) => {
if cancel_token.is_cancelled() || retry_e == "Export cancelled" {
return Err("Export cancelled".to_string());
}
sentry::capture_message(&retry_e, sentry::Level::Error);
Err(retry_e)
}
}
}
Err(e) if cancel_token.is_cancelled() || e == "Export cancelled" => {
Err("Export cancelled".to_string())
}
Err(e) => {
sentry::capture_message(&e, sentry::Level::Error);
Err(e)
}
}
}
async fn show_export_save_dialog(
request: ExportSaveDialogRequest,
) -> Result<Option<ExportSaveDestination>, String> {
let ExportSaveDialogRequest {
#[cfg(not(target_os = "linux"))]
app,
#[cfg(target_os = "linux")]
parent,
#[cfg(target_os = "linux")]
cancel_token,
file_name,
file_type,
} = request;
info!(file_name, file_type, "Save file dialog requested");
let (name, extension) = match file_type.as_str() {
"mp4" => ("MP4 Video", "mp4"),
"gif" => ("GIF Image", "gif"),
"mov" => ("MOV Video", "mov"),
_ => {
warn!(file_type, "Invalid export save file dialog type");
return Err("Invalid file type".to_string());
}
};
info!(file_name, name, extension, "Showing save file dialog");
#[cfg(target_os = "linux")]
let result = show_linux_save_dialog(parent, cancel_token, file_name, name, extension)
.await
.map(|path| path.map(ExportSaveDestination::Selected));
#[cfg(target_os = "macos")]
let result = Ok(resolve_macos_export_destination(
show_macos_save_dialog(&app, file_name, extension).await,
));
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
let result = {
let (tx, rx) = tokio::sync::oneshot::channel();
app.dialog()
.file()
.set_title("Save File")
.set_file_name(file_name)
.add_filter(name, &[extension])
.save_file(move |path| {
let _ = tx.send(path.and_then(|p| p.as_path().map(PathBuf::from)));
});
rx.await
.map_err(|error| error.to_string())
.map(|path| path.map(ExportSaveDestination::Selected))
};
result.inspect(|result| {
info!(path = ?result, "Save file dialog completed");
})
}
#[cfg(target_os = "macos")]
pub(crate) async fn show_macos_save_dialog(
app: &tauri::AppHandle,
file_name: String,
extension: &'static str,
) -> Result<Option<PathBuf>, String> {
let (tx, rx) = tokio::sync::oneshot::channel();
app.run_on_main_thread(move || {
crate::macos_save_panel::show(&file_name, &[extension], move |result| {
let _ = tx.send(result);
});
})
.map_err(|error| format!("Unable to show save dialog: {error}"))?;
rx.await
.map_err(|error| format!("Save dialog stopped before completing: {error}"))?
}
#[cfg(target_os = "linux")]
pub(crate) async fn show_linux_save_dialog(
parent: tauri::Window,
cancel_token: CancellationToken,
file_name: String,
name: &'static str,
extension: &'static str,
) -> Result<Option<PathBuf>, String> {
let (tx, rx) = tokio::sync::oneshot::channel();
let window = parent.clone();
parent
.run_on_main_thread(move || {
use gtk::prelude::*;
let prepared = window
.gtk_window()
.map_err(|error| format!("Export window is unavailable: {error}"))
.map(|parent| parent.upcast::<gtk::Window>())
.and_then(|parent| {
create_linux_export_save_dialog(&parent, &file_name, name, extension)
.map(|dialog| (parent, dialog))
});
match prepared {
Ok((parent, dialog)) => {
run_linux_export_save_dialog(parent, dialog, cancel_token, tx);
}
Err(error) => {
let _ = tx.send(Err(error));
}
}
})
.map_err(|error| format!("Unable to show export save dialog: {error}"))?;
rx.await.map_err(|error| error.to_string())?
}
#[cfg(target_os = "linux")]
fn create_linux_export_save_dialog(
parent: >k::Window,
file_name: &str,
filter_name: &str,
extension: &str,
) -> Result<gtk::FileChooserNative, String> {
use gtk::prelude::*;
if parent.in_destruction() || !parent.is_mapped() {
return Err("Export window is no longer available".to_string());
}
// rfd's GTK backend discards its parent, so tiled compositors can clip the save controls.
let dialog = gtk::FileChooserNative::new(
Some("Save File"),
Some(parent),
gtk::FileChooserAction::Save,
None,
None,
);
dialog.set_do_overwrite_confirmation(true);
if !file_name.contains('\0') {
dialog.set_current_name(file_name);
}
let filter = gtk::FileFilter::new();
filter.set_name(Some(filter_name));
filter.add_pattern(&format!("*.{extension}"));
dialog.add_filter(filter);
Ok(dialog)
}
#[cfg(target_os = "linux")]
fn run_linux_export_save_dialog(
parent: gtk::Window,
dialog: gtk::FileChooserNative,
cancel_token: CancellationToken,
mut result_tx: tokio::sync::oneshot::Sender<Result<Option<PathBuf>, String>>,
) {
use gtk::prelude::*;
let (destroy_tx, destroyed) = tokio::sync::oneshot::channel();
let destroy_tx = std::cell::Cell::new(Some(destroy_tx));
let parent_destroyed = std::rc::Rc::new(std::cell::Cell::new(false));
let destroyed_flag = parent_destroyed.clone();
let destroy_handler = parent.connect_destroy(move |_| {
destroyed_flag.set(true);
if let Some(sender) = destroy_tx.take() {
let _ = sender.send(());
}
});
std::mem::drop(gtk::glib::MainContext::default().spawn_local(async move {
let result = tokio::select! {
biased;
_ = cancel_token.cancelled() => Err("Export cancelled".to_string()),
_ = result_tx.closed() => Err("Export cancelled".to_string()),
_ = destroyed => Err("Export window was closed".to_string()),
response = dialog.run_future() => {
Ok(if response == gtk::ResponseType::Accept {
dialog.filename()
} else {
None
})
}
};
if !parent_destroyed.get() {
parent.disconnect(destroy_handler);
}
dialog.destroy();
let _ = result_tx.send(result);
}));
}
async fn copy_export_to_path(src: &Path, dst: &Path) -> Result<(), String> {
info!(
src = %src.display(),
dst = %dst.display(),
"Copying exported video to selected path"
);
if let Some(parent) = dst.parent() {
tokio::fs::create_dir_all(parent)
.await
.map_err(|e| format!("Failed to create export target directory: {e}"))?;
}
let bytes = tokio::fs::copy(src, dst)
.await
.map_err(|e| format!("Failed to copy exported file: {e}"))?;
let src_size = tokio::fs::metadata(src)
.await
.map_err(|e| format!("Failed to read exported file metadata: {e}"))?
.len();
if bytes != src_size {
let _ = tokio::fs::remove_file(dst).await;
return Err(format!(
"Export copy verification failed: copied {bytes} bytes but source is {src_size} bytes"
));
}
info!(bytes, dst = %dst.display(), "Copied exported video to selected path");
Ok(())
}
#[derive(Debug, serde::Serialize, specta::Type)]
pub struct ExportEstimates {
pub duration_seconds: f64,
pub estimated_time_seconds: f64,
pub estimated_size_mb: f64,
}
static EXPORT_ESTIMATE_REQUESTS: LazyLock<estimate_request::EstimateRequests> =
LazyLock::new(estimate_request::EstimateRequests::default);
#[tauri::command]
#[specta::specta]
pub fn cancel_export_estimates(editor: WindowEditorInstance) {
EXPORT_ESTIMATE_REQUESTS.cancel(&editor.project_path);
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor, on_estimate))]
pub async fn get_export_estimates(
path: PathBuf,
settings: ExportSettings,
on_estimate: tauri::ipc::Channel<cap_export::estimates::ExportEstimates>,
editor: WindowEditorInstance,
) -> Result<cap_export::estimates::ExportEstimates, String> {
if path != editor.project_path {
return Err("Export estimate does not match the open project".into());
}
EXPORT_ESTIMATE_REQUESTS
.run(path.clone(), |cancel| async move {
let project = load_export_preview_config(path, settings.cursor_only()).await?;
let settings = match settings {
ExportSettings::Mp4(settings) => {
cap_export::settings::ExportSettings::Mp4(settings)
}
ExportSettings::Gif(settings) => {
cap_export::settings::ExportSettings::Gif(settings)
}
ExportSettings::Mov(settings) => {
cap_export::settings::ExportSettings::Mov(settings)
}
};
cap_export::estimates::estimate_export(
(**editor).clone(),
project,
settings,
cancel,
move |estimate| {
let _ = on_estimate.send(estimate);
},
)
.await
})
.await
}
fn export_estimates_for_duration(
settings: &ExportSettings,
duration_seconds: f64,
) -> ExportEstimates {
let (resolution, fps) = match settings {
ExportSettings::Mp4(s) => (s.resolution_base, s.fps),
ExportSettings::Gif(s) => (s.resolution_base, s.fps),
ExportSettings::Mov(s) => (s.resolution_base, s.fps),
};
let (width, height) = (resolution.x, resolution.y);
let total_pixels = (width * height) as f64;
let fps_f64 = fps as f64;
let total_frames = (duration_seconds * fps_f64).ceil();
let (estimated_size_mb, estimated_time_seconds) = match &settings {
ExportSettings::Mp4(mp4_settings) => {
let bits_per_pixel = mp4_settings.effective_bpp() as f64;
let effective_fps = ((fps_f64 - 30.0).max(0.0) * 0.6) + fps_f64.min(30.0);
let video_bitrate = total_pixels * bits_per_pixel * effective_fps;
let audio_bitrate = 192_000.0;
let total_bitrate = video_bitrate + audio_bitrate;
let encoder_efficiency = 0.5;
let size_mb =
(total_bitrate * encoder_efficiency * duration_seconds) / (8.0 * 1024.0 * 1024.0);
let effective_render_fps = match (width, height) {
(w, _) if w >= 3840 => 175.0,
_ => 290.0,
};
let time_estimate = total_frames / effective_render_fps;
(size_mb, time_estimate)
}
ExportSettings::Gif(_) => {
let bytes_per_frame = total_pixels * 0.5;
let gif_efficiency = 0.07;
let size_mb = (bytes_per_frame * gif_efficiency * total_frames) / (1024.0 * 1024.0);
let frames_per_sec = match (width, height) {
(w, h) if w <= 1280 && h <= 720 => 10.0,
(w, h) if w <= 1920 && h <= 1080 => 5.0,
_ => 2.0,
};
let time_estimate = total_frames / frames_per_sec;
(size_mb, time_estimate)
}
ExportSettings::Mov(_) => {
let size_mb = estimate_cursor_only_size_mb(total_pixels, total_frames);
let effective_render_fps = match (width, height) {
(w, _) if w >= 3840 => 140.0,
_ => 220.0,
};
let time_estimate = total_frames / effective_render_fps;
(size_mb, time_estimate)
}
};
ExportEstimates {
duration_seconds,
estimated_time_seconds,
estimated_size_mb,
}
}
#[derive(Debug, Serialize, Deserialize, Type)]
pub struct ExportPreviewSettings {
pub fps: u32,
pub resolution_base: XY<u32>,
pub compression_bpp: f32,
#[serde(default)]
pub cursor_only: bool,
}
#[derive(Debug, Serialize, Deserialize, Type)]
pub struct ExportPreviewResult {
pub jpeg_base64: String,
pub estimated_size_mb: f64,
pub actual_width: u32,
pub actual_height: u32,
pub frame_render_time_ms: f64,
pub total_frames: u32,
}
fn estimate_cursor_only_size_mb(total_pixels: f64, total_frames: f64) -> f64 {
let bytes_per_frame = total_pixels * 0.4;
(bytes_per_frame * total_frames) / (1024.0 * 1024.0)
}
fn export_estimate_duration(
project_config: &cap_project::ProjectConfiguration,
source_duration: f64,
) -> f64 {
project_config
.timeline
.as_ref()
.map(cap_project::TimelineConfiguration::duration)
.unwrap_or(source_duration)
}
fn bpp_to_jpeg_quality(bpp: f32) -> u8 {
((bpp - 0.04) / (0.3 - 0.04) * (95.0 - 40.0) + 40.0).clamp(40.0, 95.0) as u8
}
#[tauri::command]
#[specta::specta]
#[instrument(skip_all)]
pub async fn generate_export_preview(
project_path: PathBuf,
frame_time: f64,
settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
match AssertUnwindSafe(generate_export_preview_inner(
project_path,
frame_time,
settings,
))
.catch_unwind()
.await
{
Ok(result) => result,
Err(panic) => {
let panic_msg = panic_message(panic);
error!(
target: "cap_desktop_export",
panic = %panic_msg,
"generate_export_preview panicked"
);
sentry::capture_message(
&format!("Export preview panicked: {panic_msg}"),
sentry::Level::Error,
);
Err("Export preview failed unexpectedly".to_string())
}
}
}
#[instrument(skip_all)]
async fn generate_export_preview_inner(
project_path: PathBuf,
frame_time: f64,
settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
use base64::{Engine, engine::general_purpose::STANDARD};
use cap_editor::create_segments;
use std::time::Instant;
let recording_meta = RecordingMeta::load_for_project(&project_path)
.map_err(|e| format!("Failed to load recording meta: {e}"))?;
let cap_project::RecordingMetaInner::Studio(studio_meta) = &recording_meta.inner else {
return Err("Cannot preview non-studio recordings".to_string());
};
let mut project_config =
export_project_config(recording_meta.project_config(), settings.cursor_only);
let recordings = Arc::new(
ProjectRecordingsMeta::new(&recording_meta.project_path, studio_meta)
.map_err(|e| format!("Failed to load recordings: {e}"))?,
);
synchronize_preview_timing(
&recording_meta,
&mut project_config,
&recordings
.segments
.iter()
.map(|segment| segment.display.duration)
.collect::<Vec<_>>(),
);
let project_config = Arc::new(project_config);
let render_constants = Arc::new(
RenderVideoConstants::new(
&recordings.segments,
recording_meta.clone(),
(**studio_meta).clone(),
)
.await
.map_err(|e| format!("Failed to create render constants: {e}"))?,
);
let force_ffmpeg = should_force_ffmpeg_preview();
info!(
project_path = %project_path.display(),
force_ffmpeg,
"Starting export preview"
);
let segments = create_segments(&recording_meta, studio_meta, force_ffmpeg)
.await
.map_err(|e| format!("Failed to create segments: {e}"))?;
let render_segments: Vec<RenderSegment> = segments
.iter()
.map(|s| RenderSegment {
cursor: s.cursor.clone(),
keyboard: s.keyboard.clone(),
decoders: s.decoders.clone(),
render_display: !settings.cursor_only,
})
.collect();
let transition_mapping = project_config.timeline.as_ref().and_then(|timeline| {
if timeline.transitions.is_empty() {
return None;
}
match timeline.get_frame_mapping(frame_time) {
Some(TimelineFrameMapping::Transition {
outgoing,
kind,
progress,
..
}) => Some((outgoing, kind, progress)),
_ => None,
}
});
let Some((segment_time, segment)) = project_config.get_segment_time(frame_time) else {
return Err("Frame time is outside video duration".to_string());
};
let render_segment = &render_segments[segment.recording_clip as usize];
let clip_config = project_config
.clips
.iter()
.find(|v| v.index == segment.recording_clip);
let render_start = Instant::now();
let segment_frames = render_segment
.decoders
.get_frames(
segment_time as f32,
!project_config.camera.hide && render_segment.render_display,
render_segment.render_display,
clip_config.map(|v| v.offsets).unwrap_or_default(),
)
.await
.ok_or_else(|| "Failed to decode frame".to_string())?;
let frame_number = (frame_time * settings.fps as f64).floor() as u32;
let total_duration = project_config
.timeline
.as_ref()
.map(|t| t.duration())
.unwrap_or(0.0);
let mut zoom_timeline = ZoomTransformTimeline::from_project_for_clip(
&project_config,
&render_segment.cursor,
total_duration,
render_constants.options.screen_size,
segment.recording_clip,
);
zoom_timeline.ensure_precomputed_until((frame_number as f32 + 1.0) / settings.fps as f32);
let uniforms = ProjectUniforms::new(
&render_constants,
&project_config,
frame_number,
settings.fps,
settings.resolution_base,
&render_segment.cursor,
&segment_frames,
total_duration,
&zoom_timeline,
);
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 frame = if let Some((outgoing, kind, progress)) = transition_mapping {
let outgoing_segment = &render_segments[outgoing.segment.recording_clip as usize];
let outgoing_offsets = project_config
.clips
.iter()
.find(|clip| clip.index == outgoing.segment.recording_clip)
.map(|clip| clip.offsets)
.unwrap_or_default();
let outgoing_frames = outgoing_segment
.decoders
.get_frames(
outgoing.source_time as f32,
!project_config.camera.hide && outgoing_segment.render_display,
outgoing_segment.render_display,
outgoing_offsets,
)
.await
.ok_or_else(|| "Failed to decode outgoing frame".to_string())?;
let mut outgoing_zoom = ZoomTransformTimeline::from_project_for_outgoing_clip(
&project_config,
&outgoing_segment.cursor,
total_duration,
render_constants.options.screen_size,
outgoing.segment.recording_clip,
);
outgoing_zoom.ensure_precomputed_until((frame_number as f32 + 1.0) / settings.fps as f32);
let outgoing_uniforms = ProjectUniforms::new(
&render_constants,
&project_config,
frame_number,
settings.fps,
settings.resolution_base,
&outgoing_segment.cursor,
&outgoing_frames,
total_duration,
&outgoing_zoom,
);
frame_renderer
.render_transition_immediate(
TransitionRenderInput {
segment_frames: outgoing_frames,
uniforms: outgoing_uniforms,
cursor: &outgoing_segment.cursor,
render_display: outgoing_segment.render_display,
},
TransitionRenderInput {
segment_frames,
uniforms,
cursor: &render_segment.cursor,
render_display: render_segment.render_display,
},
kind,
progress as f32,
&mut layers,
)
.await
} else {
frame_renderer
.render_immediate(
segment_frames,
uniforms,
&render_segment.cursor,
render_segment.render_display,
&mut layers,
)
.await
}
.map_err(|e| format!("Failed to render frame: {e}"))?;
let frame_render_time_ms = render_start.elapsed().as_secs_f64() * 1000.0;
let width = frame.width;
let height = frame.height;
let rgb_data: Vec<u8> = frame
.data
.chunks(frame.padded_bytes_per_row as usize)
.flat_map(|row| {
row[0..(frame.width * 4) as usize]
.chunks(4)
.flat_map(|chunk| [chunk[0], chunk[1], chunk[2]])
})
.collect();
let jpeg_quality = bpp_to_jpeg_quality(settings.compression_bpp);
let mut jpeg_buffer = Vec::new();
{
let mut encoder = JpegEncoder::new_with_quality(&mut jpeg_buffer, jpeg_quality);
encoder
.encode(&rgb_data, width, height, image::ExtendedColorType::Rgb8)
.map_err(|e| format!("Failed to encode JPEG: {e}"))?;
}
let jpeg_base64 = STANDARD.encode(&jpeg_buffer);
let total_pixels = (settings.resolution_base.x * settings.resolution_base.y) as f64;
let fps_f64 = settings.fps as f64;
let metadata = get_video_metadata(project_path.clone()).await?;
let duration_seconds = export_estimate_duration(&project_config, metadata.duration);
let total_frames = (duration_seconds * fps_f64).ceil() as u32;
let estimated_size_mb = if settings.cursor_only {
let total_frames_f64 = (duration_seconds * fps_f64).ceil();
estimate_cursor_only_size_mb(total_pixels, total_frames_f64)
} else {
let effective_fps = ((fps_f64 - 30.0).max(0.0) * 0.6) + fps_f64.min(30.0);
let video_bitrate = total_pixels * settings.compression_bpp as f64 * effective_fps;
let audio_bitrate = 192_000.0;
let total_bitrate = video_bitrate + audio_bitrate;
let encoder_efficiency = 0.5;
(total_bitrate * encoder_efficiency * duration_seconds) / (8.0 * 1024.0 * 1024.0)
};
Ok(ExportPreviewResult {
jpeg_base64,
estimated_size_mb,
actual_width: width,
actual_height: height,
frame_render_time_ms,
total_frames,
})
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::tempdir;
#[test]
fn native_save_failure_uses_the_rendered_project_output() {
assert_eq!(
resolve_macos_export_destination(Err("NSSavePanel unavailable".to_string())),
Some(ExportSaveDestination::Default),
);
}
#[test]
fn cancelling_a_native_save_dialog_does_not_export() {
assert_eq!(resolve_macos_export_destination(Ok(None)), None);
}
#[test]
fn native_save_selection_keeps_the_requested_destination() {
let path = PathBuf::from("selected.mp4");
assert_eq!(
resolve_macos_export_destination(Ok(Some(path.clone()))),
Some(ExportSaveDestination::Selected(path)),
);
}
#[tokio::test]
async fn export_preview_reads_saved_caption_choice_after_stale_live_preview_update() {
for export_with_subtitles in [false, true] {
let dir = tempdir().unwrap();
let mut saved = cap_project::ProjectConfiguration {
captions: Some(cap_project::CaptionsData {
settings: cap_project::CaptionSettings {
enabled: true,
export_with_subtitles,
..Default::default()
},
..Default::default()
}),
..Default::default()
};
saved.write(dir.path()).unwrap();
let (sender, receiver) = tokio::sync::watch::channel(saved.clone());
saved
.captions
.as_mut()
.unwrap()
.settings
.export_with_subtitles = !export_with_subtitles;
saved.captions.as_mut().unwrap().settings.enabled = false;
sender.send(saved).unwrap();
let preview = load_export_preview_config(dir.path().to_path_buf(), false)
.await
.unwrap();
let settings = preview.captions.unwrap().settings;
assert!(settings.enabled);
assert_eq!(settings.export_with_subtitles, export_with_subtitles);
assert!(
!receiver
.borrow()
.captions
.as_ref()
.unwrap()
.settings
.enabled
);
let persisted = cap_project::ProjectConfiguration::load(dir.path()).unwrap();
assert!(persisted.captions.as_ref().unwrap().settings.enabled);
}
}
#[tokio::test]
async fn export_preview_reports_missing_or_malformed_saved_config() {
let dir = tempdir().unwrap();
let missing = load_export_preview_config(dir.path().to_path_buf(), false)
.await
.unwrap_err();
assert!(missing.contains("Failed to read saved project config"));
std::fs::write(dir.path().join("project-config.json"), "{not valid json").unwrap();
let malformed = load_export_preview_config(dir.path().to_path_buf(), false)
.await
.unwrap_err();
assert!(malformed.contains("Failed to read saved project config"));
}
#[tokio::test]
async fn saved_export_preview_projects_captions_after_a_cut() {
let directory = tempdir().unwrap();
let mut meta: RecordingMeta = serde_json::from_value(serde_json::json!({
"pretty_name":"preview", "segments":[], "cursors":{}
}))
.unwrap();
meta.project_path = directory.path().to_path_buf();
let config: cap_project::ProjectConfiguration = serde_json::from_value(serde_json::json!({
"timeline": {
"segments":[
{"start":0.0,"end":5.0,"timescale":1.0},
{"start":6.0,"end":10.0,"timescale":1.0}
], "zoomSegments":[]
},
"captions": {
"sourceTimed":true, "settings":{},
"segments":[{"id":"word","text":"retained","start":8.0,"end":8.5,"words":[]}]
}
}))
.unwrap();
config.write(directory.path()).unwrap();
let mut preview = load_export_preview_config(directory.path().to_path_buf(), false)
.await
.unwrap();
synchronize_preview_timing(&meta, &mut preview, &[10.0]);
let caption = &preview.timeline.as_ref().unwrap().caption_segments[0];
assert_eq!(caption.start, 7.0);
assert_eq!(caption.end, 7.5);
assert_eq!(caption.text, "retained");
let mut cursor_only = load_export_preview_config(directory.path().to_path_buf(), true)
.await
.unwrap();
synchronize_preview_timing(&meta, &mut cursor_only, &[10.0]);
assert!(cursor_only.captions.is_none());
}
#[test]
fn export_preview_rejects_unloaded_incoming_and_outgoing_media() {
let medias = ["first", "second"];
assert_eq!(export_preview_media(&medias, 0).unwrap(), &"first");
assert_eq!(export_preview_media(&medias, 1).unwrap(), &"second");
assert!(export_preview_media(&medias, 2).is_err());
assert!(export_preview_media(&medias, u32::MAX).is_err());
assert!(export_preview_media::<()>(&[], 0).is_err());
}
#[test]
fn export_preview_caption_policy_preserves_editor_and_cursor_only_states() {
for enabled in [false, true] {
for export in [false, true] {
for cursor_only in [false, true] {
let editor = cap_project::ProjectConfiguration {
captions: Some(cap_project::CaptionsData {
settings: cap_project::CaptionSettings {
enabled,
export_with_subtitles: export,
..Default::default()
},
..Default::default()
}),
..Default::default()
};
let original = serde_json::to_value(&editor).unwrap();
let preview = export_project_config(editor.clone(), cursor_only);
if cursor_only {
assert!(preview.captions.is_none());
} else {
assert_eq!(preview.captions.unwrap().settings.enabled, enabled);
}
assert_eq!(serde_json::to_value(editor).unwrap(), original);
}
}
}
}
#[test]
fn export_estimates_use_source_duration_without_a_timeline() {
assert_eq!(
export_estimate_duration(&cap_project::ProjectConfiguration::default(), 361.0),
361.0
);
}
#[test]
fn export_estimates_follow_trims_and_playback_speed() {
for (timescale, expected) in [(1.0, 12.0), (2.0, 6.0)] {
let project = serde_json::from_value(serde_json::json!({
"timeline": {
"segments": [{"start": 45.0, "end": 57.0, "timescale": timescale}],
"zoomSegments": []
}
}))
.unwrap();
assert_eq!(export_estimate_duration(&project, 361.0), expected);
}
}
#[test]
fn export_estimates_include_transition_overlap() {
let project = serde_json::from_value(serde_json::json!({
"timeline": {
"segments": [
{"start": 5.0, "end": 11.0, "timescale": 1.0},
{"start": 20.0, "end": 26.0, "timescale": 1.0}
],
"transitions": [{"segmentIndex": 1, "type": "cross-fade", "duration": 1.0}],
"zoomSegments": []
}
}))
.unwrap();
assert_eq!(export_estimate_duration(&project, 361.0), 11.0);
}
#[test]
fn export_settings_exposes_force_ffmpeg_for_mp4_only() {
let mp4_settings = ExportSettings::Mp4(cap_export::mp4::Mp4ExportSettings {
fps: 30,
resolution_base: XY { x: 1280, y: 720 },
compression: cap_export::mp4::ExportCompression::Web,
custom_bpp: None,
force_ffmpeg_decoder: true,
optimize_filesize: false,
});
let gif_settings = ExportSettings::Gif(cap_export::gif::GifExportSettings {
fps: 15,
resolution_base: XY { x: 1280, y: 720 },
quality: None,
});
assert!(mp4_settings.force_ffmpeg_decoder());
assert!(!gif_settings.force_ffmpeg_decoder());
}
#[test]
fn frame_decode_error_matcher_includes_initial_frame_timeout() {
assert!(is_frame_decode_error(
"Export timed out 3 times consecutively after 120s each waiting for frame 0"
));
}
#[cfg(not(target_os = "windows"))]
#[test]
fn recovered_projects_do_not_force_ffmpeg_without_explicit_setting() {
let dir = tempdir().unwrap();
std::fs::write(
dir.path()
.join(crate::recording::FRAGMENTED_EXPORT_FFMPEG_MARKER),
b"fragmented-remux",
)
.unwrap();
let gif_settings = ExportSettings::Gif(cap_export::gif::GifExportSettings {
fps: 15,
resolution_base: XY { x: 1280, y: 720 },
quality: None,
});
assert!(!should_force_ffmpeg_export(dir.path(), &gif_settings));
}
#[test]
fn exports_do_not_force_ffmpeg_without_explicit_setting() {
let dir = tempdir().unwrap();
let gif_settings = ExportSettings::Gif(cap_export::gif::GifExportSettings {
fps: 15,
resolution_base: XY { x: 1280, y: 720 },
quality: None,
});
assert!(!should_force_ffmpeg_export(dir.path(), &gif_settings));
}
#[test]
fn export_worker_starts_in_hardware_mode() {
assert!(!should_start_export_worker_in_software_safe_mode());
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip_all)]
pub async fn generate_export_preview_fast(
editor: WindowEditorInstance,
frame_time: f64,
settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
match AssertUnwindSafe(generate_export_preview_fast_inner(
editor, frame_time, settings,
))
.catch_unwind()
.await
{
Ok(result) => result,
Err(panic) => {
let panic_msg = panic_message(panic);
error!(
target: "cap_desktop_export",
panic = %panic_msg,
"generate_export_preview_fast panicked"
);
sentry::capture_message(
&format!("Export preview panicked: {panic_msg}"),
sentry::Level::Error,
);
Err("Export preview failed unexpectedly".to_string())
}
}
}
async fn load_export_preview_config(
project_path: PathBuf,
cursor_only: bool,
) -> Result<cap_project::ProjectConfiguration, String> {
tokio::task::spawn_blocking(move || {
cap_project::ProjectConfiguration::load(&project_path)
.map(|config| export_project_config(config, cursor_only))
.map_err(|error| {
format!("Failed to read saved project config for export preview: {error}")
})
})
.await
.map_err(|error| format!("Failed to load export preview config: {error}"))?
}
fn synchronize_preview_timing(
meta: &RecordingMeta,
project: &mut cap_project::ProjectConfiguration,
display_durations: &[f64],
) {
cap_project::synchronize_legacy_keyboard(meta, project);
cap_project::synchronize_captions(project, display_durations);
}
fn export_preview_media<T>(medias: &[T], recording_clip: u32) -> Result<&T, String> {
medias.get(recording_clip as usize).ok_or_else(|| {
format!(
"Recording clip {recording_clip} is unavailable in this editor. Reopen the project before exporting."
)
})
}
#[instrument(skip_all)]
async fn generate_export_preview_fast_inner(
editor: WindowEditorInstance,
frame_time: f64,
settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
if editor.export_active.load(Ordering::Acquire) {
return Err("Export is in progress - preview generation skipped".to_string());
}
use base64::{Engine, engine::general_purpose::STANDARD};
use std::time::Instant;
let _preview_guard = ExportPreviewActiveGuard::try_new(&editor.export_preview_active)?;
crate::gpu_context::ensure_shared_device_available()?;
let mut project_config =
load_export_preview_config(editor.project_path.clone(), settings.cursor_only).await?;
let meta = editor.meta().clone();
let recordings = editor.recordings.clone();
let project_config = tokio::task::spawn_blocking(move || {
synchronize_preview_timing(
&meta,
&mut project_config,
&recordings
.segments
.iter()
.map(|segment| segment.display.duration)
.collect::<Vec<_>>(),
);
project_config
})
.await
.map_err(|error| format!("Failed to synchronize export preview timing: {error}"))?;
let project_config = Arc::new(project_config);
let transition_mapping = project_config.timeline.as_ref().and_then(|timeline| {
if timeline.transitions.is_empty() {
return None;
}
match timeline.get_frame_mapping(frame_time) {
Some(TimelineFrameMapping::Transition {
outgoing,
kind,
progress,
..
}) => Some((outgoing, kind, progress)),
_ => None,
}
});
let Some((segment_time, segment)) = project_config.get_segment_time(frame_time) else {
return Err("Frame time is outside video duration".to_string());
};
let segment_media = export_preview_media(&editor.segment_medias, segment.recording_clip)?;
let clip_config = project_config
.clips
.iter()
.find(|v| v.index == segment.recording_clip);
let render_start = Instant::now();
let segment_frames = segment_media
.decoders
.get_frames(
segment_time as f32,
!project_config.camera.hide && !settings.cursor_only,
!settings.cursor_only,
clip_config.map(|v| v.offsets).unwrap_or_default(),
)
.await;
let segment_frames = segment_frames.ok_or_else(|| "Failed to decode frame".to_string())?;
let frame_number = (frame_time * settings.fps as f64).floor() as u32;
let total_duration = project_config
.timeline
.as_ref()
.map(|t| t.duration())
.unwrap_or(0.0);
let mut zoom_timeline = ZoomTransformTimeline::from_project_for_clip(
&project_config,
&segment_media.cursor,
total_duration,
editor.render_constants.options.screen_size,
segment.recording_clip,
);
zoom_timeline.ensure_precomputed_until((frame_number as f32 + 1.0) / settings.fps as f32);
let uniforms = ProjectUniforms::new(
&editor.render_constants,
&project_config,
frame_number,
settings.fps,
settings.resolution_base,
&segment_media.cursor,
&segment_frames,
total_duration,
&zoom_timeline,
);
crate::gpu_context::ensure_shared_device_available()?;
let mut frame_renderer = FrameRenderer::new(&editor.render_constants);
let mut layers = RendererLayers::new_with_options(
&editor.render_constants.device,
&editor.render_constants.queue,
editor.render_constants.is_software_adapter,
);
let frame = if let Some((outgoing, kind, progress)) = transition_mapping {
let outgoing_media =
export_preview_media(&editor.segment_medias, outgoing.segment.recording_clip)?;
let outgoing_offsets = project_config
.clips
.iter()
.find(|clip| clip.index == outgoing.segment.recording_clip)
.map(|clip| clip.offsets)
.unwrap_or_default();
let outgoing_frames = outgoing_media
.decoders
.get_frames(
outgoing.source_time as f32,
!project_config.camera.hide && !settings.cursor_only,
!settings.cursor_only,
outgoing_offsets,
)
.await
.ok_or_else(|| "Failed to decode outgoing frame".to_string())?;
let mut outgoing_zoom = ZoomTransformTimeline::from_project_for_outgoing_clip(
&project_config,
&outgoing_media.cursor,
total_duration,
editor.render_constants.options.screen_size,
outgoing.segment.recording_clip,
);
outgoing_zoom.ensure_precomputed_until((frame_number as f32 + 1.0) / settings.fps as f32);
let outgoing_uniforms = ProjectUniforms::new(
&editor.render_constants,
&project_config,
frame_number,
settings.fps,
settings.resolution_base,
&outgoing_media.cursor,
&outgoing_frames,
total_duration,
&outgoing_zoom,
);
frame_renderer
.render_transition_immediate(
TransitionRenderInput {
segment_frames: outgoing_frames,
uniforms: outgoing_uniforms,
cursor: &outgoing_media.cursor,
render_display: !settings.cursor_only,
},
TransitionRenderInput {
segment_frames,
uniforms,
cursor: &segment_media.cursor,
render_display: !settings.cursor_only,
},
kind,
progress as f32,
&mut layers,
)
.await
} else {
frame_renderer
.render_immediate(
segment_frames,
uniforms,
&segment_media.cursor,
!settings.cursor_only,
&mut layers,
)
.await
}
.map_err(|e| format!("Failed to render frame: {e}"))?;
let frame_render_time_ms = render_start.elapsed().as_secs_f64() * 1000.0;
let width = frame.width;
let height = frame.height;
let rgb_data: Vec<u8> = frame
.data
.chunks(frame.padded_bytes_per_row as usize)
.flat_map(|row| {
row[0..(frame.width * 4) as usize]
.chunks(4)
.flat_map(|chunk| [chunk[0], chunk[1], chunk[2]])
})
.collect();
let jpeg_quality = bpp_to_jpeg_quality(settings.compression_bpp);
let mut jpeg_buffer = Vec::new();
{
let mut encoder = JpegEncoder::new_with_quality(&mut jpeg_buffer, jpeg_quality);
encoder
.encode(&rgb_data, width, height, image::ExtendedColorType::Rgb8)
.map_err(|e| format!("Failed to encode JPEG: {e}"))?;
}
let jpeg_base64 = STANDARD.encode(&jpeg_buffer);
let total_pixels = (settings.resolution_base.x * settings.resolution_base.y) as f64;
let fps_f64 = settings.fps as f64;
let duration_seconds = export_estimate_duration(&project_config, editor.recordings.duration());
let total_frames = (duration_seconds * fps_f64).ceil() as u32;
let estimated_size_mb = if settings.cursor_only {
let total_frames_f64 = (duration_seconds * fps_f64).ceil();
estimate_cursor_only_size_mb(total_pixels, total_frames_f64)
} else {
let effective_fps = ((fps_f64 - 30.0).max(0.0) * 0.6) + fps_f64.min(30.0);
let video_bitrate = total_pixels * settings.compression_bpp as f64 * effective_fps;
let audio_bitrate = 192_000.0;
let total_bitrate = video_bitrate + audio_bitrate;
let encoder_efficiency = 0.5;
(total_bitrate * encoder_efficiency * duration_seconds) / (8.0 * 1024.0 * 1024.0)
};
Ok(ExportPreviewResult {
jpeg_base64,
estimated_size_mb,
actual_width: width,
actual_height: height,
frame_render_time_ms,
total_frames,
})
}