use std::collections::BTreeMap;
use std::num::NonZeroU64;
use std::path::{Path, PathBuf};
use crate::diagnostic::Result;
use crate::model::{
AudioDomain, AudioSpec, ExactNumber, FrameCount, FrameRange, ImageFit, NodeId, ValueType,
VideoDomain, VideoSpec,
};
use crate::semantic::SourceOrigin;
use crate::source::SourceFile;
use super::policy::RenderPolicy;
use super::tools::{self, ExternalToolIdentity, ToolIdentity};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum PreparedExternalParameterValue {
Integer(i64),
Keyword(String),
File(PreparedAsset),
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum PreparedExternalArgument {
Text(String),
File(PreparedAsset),
}
#[derive(Clone, Debug)]
pub struct PreparedPlan {
format_version: u32,
engine_version: String,
semantic_hash: String,
render_policy: RenderPolicy,
video: VideoSpec,
audio: AudioSpec,
nodes: Vec<PreparedNode>,
result: NodeId,
named_values: BTreeMap<String, NodeId>,
output: PathBuf,
manifest: PathBuf,
ffmpeg: ToolIdentity,
ffprobe: ToolIdentity,
execution_namespace: String,
entrypoint_source: SourceFile,
}
impl PreparedPlan {
#[expect(
clippy::too_many_arguments,
reason = "the sole plan constructor makes every identity-bearing and publication field explicit without a duplicate builder"
)]
pub(super) fn new(
format_version: u32,
engine_version: String,
semantic_hash: String,
render_policy: RenderPolicy,
video: VideoSpec,
audio: AudioSpec,
nodes: Vec<PreparedNode>,
result: NodeId,
named_values: BTreeMap<String, NodeId>,
output: PathBuf,
manifest: PathBuf,
ffmpeg: ToolIdentity,
ffprobe: ToolIdentity,
execution_namespace: String,
entrypoint_source: SourceFile,
) -> Self {
Self {
format_version,
engine_version,
semantic_hash,
render_policy,
video,
audio,
nodes,
result,
named_values,
output,
manifest,
ffmpeg,
ffprobe,
execution_namespace,
entrypoint_source,
}
}
pub(crate) const fn format_version(&self) -> u32 {
self.format_version
}
pub(crate) fn engine_version(&self) -> &str {
&self.engine_version
}
pub fn prepared_json(&self) -> Result<String> {
crate::format::prepared_json::prepared_plan(self)
}
#[must_use]
pub fn semantic_hash(&self) -> &str {
&self.semantic_hash
}
#[must_use]
pub fn video(&self) -> &VideoSpec {
&self.video
}
#[must_use]
pub fn audio(&self) -> &AudioSpec {
&self.audio
}
#[must_use]
pub fn nodes(&self) -> &[PreparedNode] {
&self.nodes
}
#[must_use]
pub const fn result(&self) -> NodeId {
self.result
}
#[must_use]
pub fn named_values(&self) -> &BTreeMap<String, NodeId> {
&self.named_values
}
#[must_use]
pub fn output(&self) -> &Path {
&self.output
}
#[must_use]
pub fn manifest(&self) -> &Path {
&self.manifest
}
pub(crate) fn ffmpeg(&self) -> &ToolIdentity {
&self.ffmpeg
}
pub(crate) const fn render_policy(&self) -> RenderPolicy {
self.render_policy
}
pub(crate) fn ffprobe(&self) -> &ToolIdentity {
&self.ffprobe
}
pub(crate) fn execution_namespace(&self) -> &str {
&self.execution_namespace
}
pub(crate) fn verify_tool_identities(&self) -> Result<()> {
tools::verify_tool_identity(&self.ffmpeg, "FFmpeg")?;
tools::verify_tool_identity(&self.ffprobe, "FFprobe")
}
pub(crate) const fn entrypoint_source(&self) -> &SourceFile {
&self.entrypoint_source
}
}
#[derive(Clone, Debug)]
pub struct PreparedNode {
id: NodeId,
media: PreparedMedia,
origin: SourceOrigin,
fingerprint: String,
}
#[derive(Clone, Debug)]
pub(super) enum PreparedMedia {
Video {
kind: PreparedVideoKind,
domain: VideoDomain,
has_audio: bool,
},
Audio {
kind: PreparedAudioKind,
domain: AudioDomain,
},
}
#[derive(Clone, Copy, Debug)]
#[non_exhaustive]
pub enum PreparedNodeMedia<'a> {
Video {
kind: &'a PreparedVideoKind,
domain: &'a VideoDomain,
has_audio: bool,
},
Audio {
kind: &'a PreparedAudioKind,
domain: &'a AudioDomain,
},
}
impl PreparedNode {
pub(super) fn new(
id: NodeId,
media: PreparedMedia,
origin: SourceOrigin,
fingerprint: String,
) -> Self {
Self {
id,
media,
origin,
fingerprint,
}
}
pub(super) const fn prepared_media(&self) -> &PreparedMedia {
&self.media
}
#[must_use]
pub const fn id(&self) -> NodeId {
self.id
}
#[must_use]
pub const fn media(&self) -> PreparedNodeMedia<'_> {
match &self.media {
PreparedMedia::Video {
kind,
domain,
has_audio,
} => PreparedNodeMedia::Video {
kind,
domain,
has_audio: *has_audio,
},
PreparedMedia::Audio { kind, domain } => PreparedNodeMedia::Audio { kind, domain },
}
}
#[must_use]
pub const fn video_kind(&self) -> Option<&PreparedVideoKind> {
match &self.media {
PreparedMedia::Video { kind, .. } => Some(kind),
PreparedMedia::Audio { .. } => None,
}
}
#[must_use]
pub const fn audio_kind(&self) -> Option<&PreparedAudioKind> {
match &self.media {
PreparedMedia::Video { .. } => None,
PreparedMedia::Audio { kind, .. } => Some(kind),
}
}
#[must_use]
pub const fn value_type(&self) -> ValueType {
match self.media {
PreparedMedia::Video { .. } => ValueType::Video,
PreparedMedia::Audio { .. } => ValueType::Audio,
}
}
#[must_use]
pub const fn video_domain(&self) -> Option<&VideoDomain> {
match &self.media {
PreparedMedia::Video { domain, .. } => Some(domain),
PreparedMedia::Audio { .. } => None,
}
}
#[must_use]
pub const fn audio_domain(&self) -> Option<&AudioDomain> {
match &self.media {
PreparedMedia::Video { .. } => None,
PreparedMedia::Audio { domain, .. } => Some(domain),
}
}
#[must_use]
pub const fn has_audio(&self) -> bool {
match self.media {
PreparedMedia::Video { has_audio, .. } => has_audio,
PreparedMedia::Audio { .. } => false,
}
}
#[must_use]
pub const fn origin(&self) -> &SourceOrigin {
&self.origin
}
#[must_use]
pub fn fingerprint(&self) -> &str {
&self.fingerprint
}
pub(crate) fn visit_inputs(&self, visitor: impl FnMut(NodeId)) {
match &self.media {
PreparedMedia::Video { kind, .. } => kind.visit_inputs(visitor),
PreparedMedia::Audio { kind, .. } => kind.visit_inputs(visitor),
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum PreparedVideoKind {
ImageVideo {
asset: PreparedAsset,
frames: FrameCount,
fit: ImageFit,
},
VideoSource {
asset: PreparedAsset,
frames: FrameCount,
fit: ImageFit,
},
Slice {
input: NodeId,
range: FrameRange,
},
Repeat {
input: NodeId,
count: NonZeroU64,
frames: FrameCount,
},
ZoomIn {
input: NodeId,
by: ExactNumber,
},
FlashCut {
before: NodeId,
after: NodeId,
frames: FrameCount,
},
Crossfade {
before: NodeId,
after: NodeId,
frames: FrameCount,
},
Concat {
inputs: Vec<NodeId>,
},
SetAudio {
audio: NodeId,
video: NodeId,
},
AudioOnBlack {
audio: NodeId,
},
ExternalVideo {
executable: ExternalToolIdentity,
arguments: Vec<PreparedExternalArgument>,
inputs: BTreeMap<String, NodeId>,
parameters: BTreeMap<String, PreparedExternalParameterValue>,
preserve_input: String,
},
}
impl PreparedVideoKind {
pub(crate) fn visit_inputs(&self, mut visitor: impl FnMut(NodeId)) {
match self {
Self::ImageVideo { .. } | Self::VideoSource { .. } => {}
Self::Slice { input, .. }
| Self::Repeat { input, .. }
| Self::ZoomIn { input, .. }
| Self::AudioOnBlack { audio: input } => visitor(*input),
Self::FlashCut { before, after, .. } | Self::Crossfade { before, after, .. } => {
visitor(*before);
visitor(*after);
}
Self::Concat { inputs } => inputs.iter().copied().for_each(&mut visitor),
Self::SetAudio { audio, video } => {
visitor(*audio);
visitor(*video);
}
Self::ExternalVideo { inputs, .. } => {
inputs.values().copied().for_each(visitor);
}
}
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum PreparedAudioKind {
AudioSource {
asset: PreparedAsset,
},
AudioSlice {
input: NodeId,
range: crate::model::SampleRange,
},
AudioRepeat {
input: NodeId,
count: NonZeroU64,
},
AudioConcat {
inputs: Vec<NodeId>,
},
ExtractAudio {
video: NodeId,
},
}
impl PreparedAudioKind {
pub(crate) fn visit_inputs(&self, mut visitor: impl FnMut(NodeId)) {
match self {
Self::AudioSource { .. } => {}
Self::AudioSlice { input, .. } | Self::AudioRepeat { input, .. } => visitor(*input),
Self::AudioConcat { inputs } => inputs.iter().copied().for_each(visitor),
Self::ExtractAudio { video } => visitor(*video),
}
}
}
#[derive(Clone, Debug)]
pub struct PreparedAsset {
source_path: PathBuf,
content_hash: String,
}
impl PreparedAsset {
pub(super) fn new(source_path: PathBuf, content_hash: String) -> Self {
Self {
source_path,
content_hash,
}
}
#[must_use]
pub fn source_path(&self) -> &Path {
&self.source_path
}
#[must_use]
pub fn content_hash(&self) -> &str {
&self.content_hash
}
}