#![allow(clippy::trivially_copy_pass_by_ref)]
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::{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::new(
"E_INVALID_PLAN",
"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)?)
}
}
#[allow(clippy::too_many_lines)]
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::new(
"E_INVALID_PLAN",
"external programs do not have an FFmpeg recipe",
node.origin().span.clone(),
)),
}
}