motionloom 0.1.0

MotionLoom DSL parser and renderer for video effects, scene graphs, motion graphics, and world graphs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// =========================================
// =========================================
// crates/motionloom/src/export/mod.rs

use std::path::Path;

use thiserror::Error;

/// Platform-neutral description of one rendered frame for export.
#[derive(Debug, Clone)]
pub struct VideoFrame {
    pub width: u32,
    pub height: u32,
    /// RGBA pixels, row-major, non-premultiplied.
    pub rgba: Vec<u8>,
}

impl VideoFrame {
    pub fn from_rgba_image(image: &image::RgbaImage) -> Self {
        let (width, height) = image.dimensions();
        Self {
            width,
            height,
            rgba: image.as_raw().clone(),
        }
    }
}

/// Errors that can occur while encoding a video.
#[derive(Debug, Error)]
pub enum EncodeError {
    #[error("failed to create output directory ({path}): {source}")]
    CreateOutputDir {
        path: std::path::PathBuf,
        source: std::io::Error,
    },
    #[error("failed to start encoder: {0}")]
    StartEncoder(String),
    #[error("encoder input was not available")]
    MissingEncoderInput,
    #[error("failed to write frame: {0}")]
    WriteFrame(std::io::Error),
    #[error("encoder failed: {0}")]
    EncoderFailed(String),
    #[error("video export is not available on this platform: {0}")]
    NotImplemented(String),
    #[error("encoder not started")]
    NotStarted,
}

/// Platform-neutral video encoder boundary.
///
/// Implementations handle native FFmpeg subprocesses and browser WebCodecs.
///
/// NOTE: The trait is currently synchronous. A future iteration may need an
/// async variant because WebCodecs `flush`/output-chunk assembly is naturally
/// promise-based.
pub trait VideoEncoder {
    /// Configure the encoder for the given output dimensions and frame rate.
    fn begin(&mut self, width: u32, height: u32, fps: f32) -> Result<(), EncodeError>;

    /// Append one RGBA frame. `frame_index` is informational.
    fn push_frame(&mut self, frame_index: u32, rgba: &[u8]) -> Result<(), EncodeError>;

    /// Finalize the output and return any result object (e.g. a Blob URL on
    /// WASM). Native implementations typically write to `output_path`.
    fn finish(&mut self) -> Result<(), EncodeError>;
}

#[cfg(not(target_arch = "wasm32"))]
mod native;

#[cfg(target_arch = "wasm32")]
mod wasm;

#[cfg(not(target_arch = "wasm32"))]
pub use native::FfmpegVideoEncoder;

#[cfg(target_arch = "wasm32")]
pub use wasm::WebCodecsVideoEncoder;

/// Convenience constructor that picks the correct platform encoder.
pub fn create_encoder(ffmpeg_bin: &str, output_path: &Path) -> Box<dyn VideoEncoder> {
    #[cfg(not(target_arch = "wasm32"))]
    {
        Box::new(FfmpegVideoEncoder::new(ffmpeg_bin, output_path))
    }
    #[cfg(target_arch = "wasm32")]
    {
        let _ = ffmpeg_bin;
        let _ = output_path;
        Box::new(WebCodecsVideoEncoder::new())
    }
}