Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

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