clipasm 0.3.2

A strict, typed language for compiling and rendering Video and Audio graphs
Documentation
mod audio;
mod context;
mod effects;
mod export;
mod external;
mod filters;
mod media;
mod recipe;
mod timeline;
mod transitions;

use std::path::{Path, PathBuf};

use crate::diagnostic::{BuiltinDiagnostic, Diagnostic, Result};
use crate::preflight::{
    PreparedAudioKind, PreparedNode, PreparedNodeMedia, PreparedPlan, PreparedVideoKind,
};

use context::{RenderContext, StagedArtifact};
pub(crate) use export::export_recipe;
pub(crate) use recipe::{FfmpegArgument, FfmpegRecipe, RecipeContext};

pub(super) struct Executor<'a> {
    plan: &'a PreparedPlan,
}

impl<'a> Executor<'a> {
    pub(super) const fn new(plan: &'a PreparedPlan) -> Self {
        Self { plan }
    }

    pub(super) fn stage_export(
        &self,
        artifact: &Path,
        staged: &Path,
        result: &PreparedNode,
    ) -> Result<()> {
        let PreparedNodeMedia::Video {
            domain, has_audio, ..
        } = result.media()
        else {
            return Err(Diagnostic::builtin(
                BuiltinDiagnostic::InvalidPlan,
                "prepared result is Audio, but rendering requires Video",
                result.origin().span.clone(),
            ));
        };
        export::stage_export(
            result.id(),
            artifact,
            staged,
            self.plan.video(),
            *self.plan.audio(),
            domain,
            has_audio,
            self.plan.render_policy(),
            self.plan.ffmpeg().executable(),
            self.plan.ffprobe().executable(),
        )
    }

    pub(in crate::render) fn render_node(
        &self,
        node: &PreparedNode,
        artifacts: &[Option<PathBuf>],
        destination: &Path,
    ) -> Result<StagedArtifact> {
        let extension = match node.value_type() {
            crate::model::ValueType::Audio => self.plan.render_policy().working_audio_extension(),
            crate::model::ValueType::Video => self.plan.render_policy().working_video_extension(),
        };
        let staged = StagedArtifact::new(destination, extension)?;
        let context = RenderContext::new(self.plan, node, artifacts, staged.path());
        Self::render_into(node, &context)?;
        Ok(staged)
    }

    fn render_into(node: &PreparedNode, context: &RenderContext<'_>) -> Result<()> {
        if let PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::ExternalVideo {
                    executable,
                    arguments,
                    inputs,
                    parameters,
                    ..
                },
            ..
        } = node.media()
        {
            return external::video(context, executable, arguments, inputs, parameters);
        }
        let recipe_context = context.recipe_context();
        context.finish_ffmpeg(&ffmpeg_recipe(node, &recipe_context)?)
    }
}

pub(crate) fn ffmpeg_recipe(
    node: &PreparedNode,
    context: &RecipeContext<'_>,
) -> Result<FfmpegRecipe> {
    match node.media() {
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::ImageVideo { asset, fit, frames },
            ..
        } => media::image(context, asset, *fit, *frames),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::VideoSource { asset, fit, frames },
            has_audio,
            ..
        } => media::video_source(context, asset, *fit, *frames, has_audio),
        PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::AudioSource { asset },
            domain,
        } => Ok(audio::source(context, asset, domain)),
        PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::AudioSlice { input, range },
            ..
        } => Ok(audio::slice(context, *input, range.start(), range.end())),
        PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::AudioRepeat { input, count },
            domain,
        } => Ok(audio::repeat(context, *input, count.get(), domain)),
        PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::AudioConcat { inputs },
            domain,
        } => Ok(audio::concat(context, inputs, domain)),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::Slice { input, range },
            ..
        } => timeline::slice(context, *input, range.start(), range.end()),
        PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::Repeat {
                    input,
                    count,
                    frames,
                },
            ..
        } => timeline::repeat(context, *input, *count, *frames),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::ZoomIn { input, by },
            domain,
            ..
        } => effects::zoom_in(context, *input, by, domain),
        PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::FlashCut {
                    before,
                    after,
                    frames,
                },
            domain,
            ..
        } => transitions::flash_cut(context, *before, *after, *frames, domain),
        PreparedNodeMedia::Video {
            kind:
                PreparedVideoKind::Crossfade {
                    before,
                    after,
                    frames,
                },
            domain,
            ..
        } => transitions::crossfade(context, *before, *after, *frames, domain),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::Concat { inputs },
            domain,
            ..
        } => timeline::concat(context, inputs, domain),
        PreparedNodeMedia::Audio {
            kind: PreparedAudioKind::ExtractAudio { video },
            domain,
        } => Ok(audio::extract(context, *video, domain)),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::SetAudio { audio, video },
            domain,
            ..
        } => media::set_audio(context, *audio, *video, domain),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::AudioOnBlack { audio },
            domain,
            ..
        } => media::audio_on_black(context, *audio, domain),
        PreparedNodeMedia::Video {
            kind: PreparedVideoKind::ExternalVideo { .. },
            ..
        } => Err(Diagnostic::builtin(
            BuiltinDiagnostic::InvalidPlan,
            "external programs do not have an FFmpeg recipe",
            node.origin().span.clone(),
        )),
    }
}