Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use anyhow::{Context, Result};
use cap_project::{ProjectConfiguration, RecordingMeta, StudioRecordingMeta, XY};
use cap_rendering::{
ProjectRecordingsMeta, RecordingSegmentDecoders, RenderSegment, RenderVideoConstants,
RenderedFrame, SegmentVideoPaths,
};
use clap::{Parser, ValueEnum};
use image::{ImageBuffer, ImageFormat};
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::mpsc;
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
/// Path to the Cap project directory
project_path: PathBuf,
/// Output format for the rendered frame
#[arg(short, long, default_value = "png")]
format: OutputFormat,
/// Output file path (defaults to frame.png/jpeg/raw in current directory)
#[arg(short, long)]
output: Option<PathBuf>,
/// Output resolution width (defaults to project resolution)
#[arg(long)]
width: Option<u32>,
/// Output resolution height (defaults to project resolution)
#[arg(long)]
height: Option<u32>,
/// Timeline position to render, in seconds
#[arg(long, default_value_t = 0.0)]
time: f64,
/// Frame rate the timeline is sampled at; `--time` snaps to this grid
#[arg(long, default_value_t = 30)]
fps: u32,
}
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
enum OutputFormat {
/// PNG format (lossless, supports transparency)
Png,
/// JPEG format (lossy compression)
Jpeg,
/// Raw RGBA data
Raw,
}
impl std::fmt::Display for OutputFormat {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
OutputFormat::Png => write!(f, "png"),
OutputFormat::Jpeg => write!(f, "jpeg"),
OutputFormat::Raw => write!(f, "raw"),
}
}
}
#[tokio::main]
async fn main() -> Result<()> {
let args = Args::parse();
// Load the project similar to ExporterBase
println!("Loading project from: {}", args.project_path.display());
let project_config = ProjectConfiguration::load(&args.project_path)
.context("Failed to load project configuration")?;
let recording_meta = RecordingMeta::load_for_project(&args.project_path)
.map_err(|e| anyhow::anyhow!("Failed to load recording metadata: {}", e))?;
let studio_meta = recording_meta
.studio_meta()
.context("Project is not a studio recording")?
.clone();
let recordings = Arc::new(
ProjectRecordingsMeta::new(&recording_meta.project_path, &studio_meta)
.map_err(|e| anyhow::anyhow!("Failed to create project recordings meta: {}", e))?,
);
let render_constants = Arc::new(
RenderVideoConstants::new(
&recordings.segments,
recording_meta.clone(),
studio_meta.clone(),
)
.await
.context("Failed to create render constants")?,
);
let render_segments: Vec<RenderSegment> = match &studio_meta {
StudioRecordingMeta::SingleSegment { segment } => {
let decoders = RecordingSegmentDecoders::new(
&recording_meta,
&studio_meta,
SegmentVideoPaths {
display: recording_meta.path(&segment.display.path),
camera: segment
.camera
.as_ref()
.map(|c| recording_meta.path(&c.path)),
},
0,
false,
)
.await
.map_err(|e| anyhow::anyhow!("Failed to create decoders for single segment: {}", e))?;
vec![RenderSegment {
cursor: Arc::new(Default::default()),
keyboard: Arc::new(Default::default()),
decoders,
render_display: true,
}]
}
StudioRecordingMeta::MultipleSegments { inner, .. } => {
let mut segments = Vec::new();
for (i, s) in inner.segments.iter().enumerate() {
let decoders = RecordingSegmentDecoders::new(
&recording_meta,
&studio_meta,
SegmentVideoPaths {
display: recording_meta.path(&s.display.path),
camera: s.camera.as_ref().map(|c| recording_meta.path(&c.path)),
},
i,
false,
)
.await
.map_err(|e| {
anyhow::anyhow!("Failed to create decoders for segment {}: {}", i, e)
})?;
let cursor = Arc::new(s.cursor_events(&recording_meta));
let keyboard = Arc::new(s.keyboard_events(&recording_meta));
segments.push(RenderSegment {
cursor,
keyboard,
decoders,
render_display: true,
});
}
segments
}
};
// Determine output size
let output_size = if let (Some(width), Some(height)) = (args.width, args.height) {
(width, height)
} else {
(1920, 1080) // Default resolution
};
// Determine output path
let output_path = args.output.unwrap_or_else(|| {
let extension = match args.format {
OutputFormat::Png => "png",
OutputFormat::Jpeg => "jpg",
OutputFormat::Raw => "raw",
};
PathBuf::from(format!("frame.{extension}"))
});
// Ensure output directory exists
if let Some(parent) = output_path.parent() {
std::fs::create_dir_all(parent).context("Failed to create output directory")?;
}
let fps = args.fps.max(1);
let target_frame = (args.time.max(0.0) * fps as f64).round() as u32;
println!(
"Rendering frame {} (t={:.3}s @ {}fps) at {}x{}",
target_frame,
target_frame as f64 / fps as f64,
fps,
output_size.0,
output_size.1
);
println!("Output: {}", output_path.display());
// Set up rendering pipeline
let (tx, mut rx) = mpsc::channel::<(RenderedFrame, u32)>(1);
// Start rendering in a separate task
let render_task = tokio::task::spawn(async move {
cap_rendering::render_video_to_channel(
&render_constants,
&project_config,
tx,
&recording_meta.clone(),
&studio_meta,
render_segments,
fps,
XY::new(output_size.0, output_size.1),
&recordings,
None,
false,
)
.await
});
let mut received = None;
while let Some((frame, frame_number)) = rx.recv().await {
if frame_number >= target_frame {
received = Some((frame, frame_number));
break;
}
}
let (frame, frame_number) =
received.ok_or_else(|| anyhow::anyhow!("No frame received at t={}s", args.time))?;
println!(
"Received frame {} ({}x{})",
frame_number, frame.width, frame.height
);
render_task.abort();
// Save the frame in the requested format
match args.format {
OutputFormat::Png => save_as_png(&frame, &output_path)?,
OutputFormat::Jpeg => save_as_jpeg(&frame, &output_path)?,
OutputFormat::Raw => save_as_raw(&frame, &output_path)?,
}
println!("✅ Frame saved to: {}", output_path.display());
Ok(())
}
fn save_as_png(frame: &RenderedFrame, output_path: &PathBuf) -> Result<()> {
// Use RGBA data directly for PNG to preserve transparency
let rgba_data: Vec<u8> = frame
.data
.chunks(frame.padded_bytes_per_row as usize)
.flat_map(|row| row[0..(frame.width * 4) as usize].to_vec())
.collect();
let rgba_img =
ImageBuffer::<image::Rgba<u8>, Vec<u8>>::from_raw(frame.width, frame.height, rgba_data)
.context("Failed to create image from frame data")?;
rgba_img
.save_with_format(output_path, ImageFormat::Png)
.context("Failed to save PNG")?;
Ok(())
}
fn save_as_jpeg(frame: &RenderedFrame, output_path: &PathBuf) -> Result<()> {
// Convert RGBA data to RGB for JPEG
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]]) // Skip alpha channel
})
.collect();
let rgb_img =
ImageBuffer::<image::Rgb<u8>, Vec<u8>>::from_raw(frame.width, frame.height, rgb_data)
.context("Failed to create image from frame data")?;
rgb_img
.save_with_format(output_path, ImageFormat::Jpeg)
.context("Failed to save JPEG")?;
Ok(())
}
fn save_as_raw(frame: &RenderedFrame, output_path: &PathBuf) -> Result<()> {
// Save raw RGBA data
std::fs::write(output_path, &*frame.data).context("Failed to save raw frame data")?;
Ok(())
}