Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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};
use tracing::trace;
use crate::{ExportError, ExporterBase, prepare_new_output};
#[derive(Serialize, Deserialize, Clone, Copy, Debug, Type)]
pub struct GifQuality {
/// Encoding quality from 1-100 (default: 90)
pub quality: Option<u8>,
/// Whether to prioritize speed over quality (default: false)
pub fast: Option<bool>,
}
#[derive(Serialize, Deserialize, Clone, Copy, Debug, Type)]
pub struct GifExportSettings {
pub fps: u32,
pub resolution_base: XY<u32>,
pub quality: Option<GifQuality>,
}
impl Default for GifExportSettings {
fn default() -> Self {
Self {
fps: 30,
resolution_base: XY { x: 1920, y: 1080 },
quality: None,
}
}
}
impl GifExportSettings {
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_gif",
&[
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> {
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,
);
// Ensure the output path has .gif extension
let mut gif_output_path = base.output_path.clone();
if gif_output_path.extension() != Some(std::ffi::OsStr::new("gif")) {
gif_output_path.set_extension("gif");
}
if let Some(parent) = gif_output_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
trace!(
"Creating GIF encoder at path '{}'",
gif_output_path.display()
);
// Create GIF encoder with quality settings
let quality = self
.quality
.map(|q| cap_enc_gif::GifQuality {
quality: q.quality.unwrap_or(90),
fast: q.fast.unwrap_or(false),
})
.unwrap_or_default();
let temporary_output = prepare_new_output(&gif_output_path)?;
let mut gif_encoder = cap_enc_gif::GifEncoderWrapper::new_with_quality(
temporary_output
.as_ref()
.map_or(gif_output_path.as_path(), AsRef::as_ref),
output_size.0,
output_size.1,
fps,
quality,
)
.map_err(|e| format!("Failed to create GIF encoder: {e}"))?;
let sample_timing = base.sample_timing.clone();
let encoder_thread = tokio::task::spawn_blocking(move || {
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()));
}
let add_result = match Arc::try_unwrap(frame.data) {
Ok(data) => {
gif_encoder.add_frame_owned(data, frame.padded_bytes_per_row as usize)
}
Err(shared) => {
gif_encoder.add_frame(&shared, frame.padded_bytes_per_row as usize)
}
};
if let Err(e) = add_result {
return Err(ExportError::Other(format!(
"Failed to add frame to GIF: {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);
}
}
if let Err(e) = gif_encoder.finish() {
return Err(ExportError::Other(format!("Failed to finish GIF: {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: true,
})
.collect(),
fps,
self.resolution_base,
&base.recordings,
base.sample_windows.clone(),
true,
)
.then(|f| async { f.map_err(|v| v.to_string()) });
tokio::try_join!(encoder_thread, render_video_task)?;
if let Some(temporary_output) = temporary_output {
temporary_output
.persist_noclobber(&gif_output_path)
.map_err(|e| e.to_string())?;
}
Ok(gif_output_path)
}
}