Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

6.8 KB
Raw Blame
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)
    }
}