Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use cap_enc_ffmpeg::{mov::MOVFile, prores::ProResEncoder};
use cap_media_info::{RawVideoFormat, VideoInfo};
use cap_project::XY;
use cap_rendering::{ProjectUniforms, RenderSegment, RenderedFrame};
use futures::FutureExt;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::{path::PathBuf, sync::Arc, time::Duration};
use crate::{ExportError, ExporterBase, mp4::temporary_export_output};
#[derive(Serialize, Deserialize, Clone, Copy, Debug, Type)]
pub struct MovExportSettings {
pub fps: u32,
pub resolution_base: XY<u32>,
#[serde(default)]
pub cursor_only: bool,
}
impl MovExportSettings {
pub async fn export(
self,
base: ExporterBase,
on_progress: impl FnMut(u32) -> bool + Send + 'static,
) -> Result<PathBuf, String> {
use cap_utils::operation_diagnostics::{Field, observe};
observe(
"export_mov",
&[
Field::number("requested_fps", self.fps as u64),
Field::number("requested_width", self.resolution_base.x as u64),
Field::number("requested_height", self.resolution_base.y as u64),
Field::identifier(
"resource",
cap_utils::operation_diagnostics::resource_id(&base.project_path),
),
Field::number(
"source_width",
base.render_constants.options.screen_size.x as u64,
),
Field::number(
"source_height",
base.render_constants.options.screen_size.y as u64,
),
Field::number("source_segments", base.segments.len() as u64),
Field::number("clips", base.project_config.clips.len() as u64),
Field::flag("captions", base.project_config.captions.is_some()),
Field::flag("streaming_audio", base.streaming_audio.is_some()),
],
self.export_inner(base, on_progress),
)
.await
}
async fn export_inner(
self,
base: ExporterBase,
mut on_progress: impl FnMut(u32) -> bool + Send + 'static,
) -> Result<PathBuf, String> {
if self.fps == 0 {
return Err("Export frame rate must be at least 1 fps".to_string());
}
let meta = &base.studio_meta;
let (tx_image_data, mut video_rx) = tokio::sync::mpsc::channel::<(RenderedFrame, u32)>(4);
let fps = self.fps;
let output_size = ProjectUniforms::get_output_size(
&base.render_constants.options,
&base.project_config,
self.resolution_base,
);
let mut mov_output_path = base.output_path.clone();
if mov_output_path.extension() != Some(std::ffi::OsStr::new("mov")) {
mov_output_path.set_extension("mov");
}
if let Some(parent) = mov_output_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let temporary_output = Arc::new(temporary_export_output(&mov_output_path)?);
let encoder_output_path = temporary_output.to_path_buf();
let encoder_temporary_output = temporary_output.clone();
let video_info =
VideoInfo::from_raw(RawVideoFormat::Rgba, output_size.0, output_size.1, fps);
let sample_timing = base.sample_timing.clone();
let encoder_thread = tokio::task::spawn_blocking(move || {
let _temporary_output_guard = encoder_temporary_output;
let mut mov_encoder = MOVFile::init(encoder_output_path, |output| {
ProResEncoder::builder(video_info).build(output)
})
.map_err(|e| ExportError::Other(format!("Failed to create MOV encoder: {e}")))?;
let mut reusable_frame = ffmpeg::frame::Video::new(
ffmpeg::format::Pixel::RGBA,
output_size.0,
output_size.1,
);
let mut frame_count = 0;
while let Some((frame, frame_number)) = video_rx.blocking_recv() {
if !on_progress(frame_count) {
return Err(ExportError::Other("Export cancelled".to_string()));
}
fill_rgba_frame(&mut reusable_frame, &frame)
.map_err(|e| ExportError::Other(format!("Failed to prepare frame: {e}")))?;
let encoded_frame = if sample_timing.is_some() {
frame_count
} else {
frame_number
};
let timestamp = Duration::from_secs_f64(encoded_frame as f64 / fps as f64);
mov_encoder
.queue_video_frame(&mut reusable_frame, timestamp)
.map_err(|e| ExportError::Other(format!("Failed to encode MOV frame: {e}")))?;
if sample_timing
.as_ref()
.is_some_and(|timing| timing.is_cancelled())
{
return Err(ExportError::Other("Export cancelled".into()));
}
frame_count += 1;
if let Some(timing) = &sample_timing {
timing.record_frame(frame.frame_number);
}
}
mov_encoder
.finish()
.map_err(|e| ExportError::Other(format!("Failed to finish MOV: {e}")))?;
Ok(())
})
.then(|f| async {
f.map_err(|e| e.to_string())
.and_then(|v| v.map_err(|v| v.to_string()))
});
let render_video_task = cap_rendering::render_video_to_channel(
&base.render_constants,
&base.project_config,
tx_image_data,
&base.recording_meta,
meta,
base.segments
.iter()
.map(|s| RenderSegment {
cursor: s.cursor.clone(),
keyboard: s.keyboard.clone(),
decoders: s.decoders.clone(),
render_display: !self.cursor_only,
})
.collect(),
fps,
self.resolution_base,
&base.recordings,
base.sample_windows.clone(),
false,
)
.then(|f| async { f.map_err(|v| v.to_string()) });
let (encoder_result, render_result) = tokio::join!(encoder_thread, render_video_task);
encoder_result?;
render_result?;
Arc::try_unwrap(temporary_output)
.map_err(|_| "Export output is still in use".to_string())?
.persist_replace(&mov_output_path)
.map_err(|error| error.to_string())?;
Ok(mov_output_path)
}
}
fn fill_rgba_frame(
ffmpeg_frame: &mut ffmpeg::frame::Video,
frame: &RenderedFrame,
) -> Result<(), String> {
let dst_stride = ffmpeg_frame.stride(0);
let src_stride = frame.padded_bytes_per_row as usize;
let row_bytes = (frame.width * 4) as usize;
for row in 0..frame.height as usize {
let src_start = row * src_stride;
let dst_start = row * dst_stride;
if src_start + row_bytes > frame.data.len()
|| dst_start + row_bytes > ffmpeg_frame.data_mut(0).len()
{
return Err("Frame buffer bounds exceeded".to_string());
}
ffmpeg_frame.data_mut(0)[dst_start..dst_start + row_bytes]
.copy_from_slice(&frame.data[src_start..src_start + row_bytes]);
}
Ok(())
}